Refactor blob storage to use UUID primary keys and implement streaming chunking

- Changed blob table to use ID (UUID) as primary key instead of hash
- Blob records are now created at packing start, enabling immediate chunk associations
- Implemented streaming chunking to process large files without memory exhaustion
- Fixed blob manifest generation to include all referenced blobs
- Updated all foreign key references from blob_hash to blob_id
- Added progress reporting and improved error handling
- Enforced encryption requirement for all blob packing
- Updated tests to use test encryption keys
- Added Cyrillic transliteration to README

internal/log/log.go

@@ -0,0 +1,175 @@
+package log
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	"golang.org/x/term"
+)
+
+// LogLevel represents the logging level
+type LogLevel int
+
+const (
+	LevelFatal LogLevel = iota
+	LevelError
+	LevelWarn
+	LevelNotice
+	LevelInfo
+	LevelDebug
+)
+
+// Logger configuration
+type Config struct {
+	Verbose bool
+	Debug   bool
+	Cron    bool
+}
+
+var logger *slog.Logger
+
+// Initialize sets up the global logger based on the provided configuration
+func Initialize(cfg Config) {
+	// Determine log level based on configuration
+	var level slog.Level
+
+	if cfg.Cron {
+		// In cron mode, only show fatal errors (which we'll handle specially)
+		level = slog.LevelError
+	} else if cfg.Debug || strings.Contains(os.Getenv("GODEBUG"), "vaultik") {
+		level = slog.LevelDebug
+	} else if cfg.Verbose {
+		level = slog.LevelInfo
+	} else {
+		level = slog.LevelWarn
+	}
+
+	// Create handler with appropriate level
+	opts := &slog.HandlerOptions{
+		Level: level,
+	}
+
+	// Check if stdout is a TTY
+	if term.IsTerminal(int(os.Stdout.Fd())) {
+		// Use colorized TTY handler
+		logger = slog.New(NewTTYHandler(os.Stdout, opts))
+	} else {
+		// Use JSON format for non-TTY output
+		logger = slog.New(slog.NewJSONHandler(os.Stdout, opts))
+	}
+
+	// Set as default logger
+	slog.SetDefault(logger)
+}
+
+// getCaller returns the caller information as a string
+func getCaller(skip int) string {
+	_, file, line, ok := runtime.Caller(skip)
+	if !ok {
+		return "unknown"
+	}
+	return fmt.Sprintf("%s:%d", filepath.Base(file), line)
+}
+
+// Fatal logs a fatal error and exits
+func Fatal(msg string, args ...any) {
+	if logger != nil {
+		// Add caller info to args
+		args = append(args, "caller", getCaller(2))
+		logger.Error(msg, args...)
+	}
+	os.Exit(1)
+}
+
+// Fatalf logs a formatted fatal error and exits
+func Fatalf(format string, args ...any) {
+	Fatal(fmt.Sprintf(format, args...))
+}
+
+// Error logs an error
+func Error(msg string, args ...any) {
+	if logger != nil {
+		args = append(args, "caller", getCaller(2))
+		logger.Error(msg, args...)
+	}
+}
+
+// Errorf logs a formatted error
+func Errorf(format string, args ...any) {
+	Error(fmt.Sprintf(format, args...))
+}
+
+// Warn logs a warning
+func Warn(msg string, args ...any) {
+	if logger != nil {
+		args = append(args, "caller", getCaller(2))
+		logger.Warn(msg, args...)
+	}
+}
+
+// Warnf logs a formatted warning
+func Warnf(format string, args ...any) {
+	Warn(fmt.Sprintf(format, args...))
+}
+
+// Notice logs a notice (mapped to Info level)
+func Notice(msg string, args ...any) {
+	if logger != nil {
+		args = append(args, "caller", getCaller(2))
+		logger.Info(msg, args...)
+	}
+}
+
+// Noticef logs a formatted notice
+func Noticef(format string, args ...any) {
+	Notice(fmt.Sprintf(format, args...))
+}
+
+// Info logs an info message
+func Info(msg string, args ...any) {
+	if logger != nil {
+		args = append(args, "caller", getCaller(2))
+		logger.Info(msg, args...)
+	}
+}
+
+// Infof logs a formatted info message
+func Infof(format string, args ...any) {
+	Info(fmt.Sprintf(format, args...))
+}
+
+// Debug logs a debug message
+func Debug(msg string, args ...any) {
+	if logger != nil {
+		args = append(args, "caller", getCaller(2))
+		logger.Debug(msg, args...)
+	}
+}
+
+// Debugf logs a formatted debug message
+func Debugf(format string, args ...any) {
+	Debug(fmt.Sprintf(format, args...))
+}
+
+// With returns a logger with additional context
+func With(args ...any) *slog.Logger {
+	if logger != nil {
+		return logger.With(args...)
+	}
+	return slog.Default()
+}
+
+// WithContext returns a logger with context
+func WithContext(ctx context.Context) *slog.Logger {
+	return logger
+}
+
+// Logger returns the underlying slog.Logger
+func Logger() *slog.Logger {
+	return logger
+}