feat: database setup & migration handlers build: logging & configuration

cmd/cli/main.go

···
 import (
 	"context"
 	"fmt"
-	"log"
 	"os"
 
 	"github.com/charmbracelet/fang"
 	"github.com/spf13/cobra"
+	"stormlightlabs.org/noteleaf/cmd/handlers"
 	"stormlightlabs.org/noteleaf/internal/store"
+	"stormlightlabs.org/noteleaf/internal/utils"
 )
 
 // App represents the main CLI application
···
 }
 
 func main() {
+	// Initialize logging early
+	logger := utils.NewLogger("info", "text")
+	utils.Logger = logger
+
 	app, err := NewApp()
 	if err != nil {
-		log.Fatalf("Failed to initialize application: %v", err)
+		logger.Fatal("Failed to initialize application", "error", err)
 	}
 	defer app.Close()
 
···
 		Short: "A TaskWarrior-inspired CLI with media queues and reading lists",
 	}
 
-	// Task management commands
+	rootCmd.AddCommand(&cobra.Command{
+		Use:   "setup",
+		Short: "Initialize the application database and configuration",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return handlers.Setup(cmd.Context(), args)
+		},
+	})
+
+	rootCmd.AddCommand(&cobra.Command{
+		Use:   "reset",
+		Short: "Reset the application (removes all data)",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return handlers.Reset(cmd.Context(), args)
+		},
+	})
+
+	rootCmd.AddCommand(&cobra.Command{
+		Use:   "status",
+		Short: "Show application status and configuration",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return handlers.Status(cmd.Context(), args)
+		},
+	})
+
 	rootCmd.AddCommand(&cobra.Command{
 		Use:   "add [description]",
 		Short: "Add a new task",
···
 		},
 	})
 
-	// Movie queue commands
 	movieCmd := &cobra.Command{
 		Use:   "movie",
 		Short: "Manage movie watch queue",
···
 
 	rootCmd.AddCommand(movieCmd)
 
-	// TV show commands
 	tvCmd := &cobra.Command{
 		Use:   "tv",
 		Short: "Manage TV show watch queue",
···
 
 	rootCmd.AddCommand(tvCmd)
 
-	// Book commands
 	bookCmd := &cobra.Command{
 		Use:   "book",
 		Short: "Manage reading list",
···
 
 	rootCmd.AddCommand(bookCmd)
 
-	// Configuration commands
 	rootCmd.AddCommand(&cobra.Command{
 		Use:   "config [key] [value]",
 		Short: "Manage configuration",

cmd/handlers/handlers.go

···
 package handlers
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"stormlightlabs.org/noteleaf/internal/store"
+	"stormlightlabs.org/noteleaf/internal/utils"
+)
+
+// Setup initializes the application database and configuration
+func Setup(ctx context.Context, args []string) error {
+	logger := utils.GetLogger()
+	logger.Info("Setting up noteleaf")
+
+	configDir, err := store.GetConfigDir()
+	if err != nil {
+		logger.Error("Failed to get config directory", "error", err)
+		return fmt.Errorf("failed to get config directory: %w", err)
+	}
+
+	logger.Info("Using config directory", "path", configDir)
+	fmt.Printf("Config directory: %s\n", configDir)
+
+	dbPath := filepath.Join(configDir, "noteleaf.db")
+	if _, err := os.Stat(dbPath); err == nil {
+		fmt.Println("Database already exists. Use --force to recreate.")
+		return nil
+	}
+
+	db, err := store.NewDatabase()
+	if err != nil {
+		return fmt.Errorf("failed to initialize database: %w", err)
+	}
+	defer db.Close()
+
+	fmt.Printf("Database created: %s\n", db.GetPath())
+
+	config, err := store.LoadConfig()
+	if err != nil {
+		return fmt.Errorf("failed to create configuration: %w", err)
+	}
+
+	configPath, err := store.GetConfigPath()
+	if err != nil {
+		return fmt.Errorf("failed to get config path: %w", err)
+	}
+
+	fmt.Printf("Configuration created: %s\n", configPath)
+	fmt.Printf("Date format: %s\n", config.DateFormat)
+	fmt.Printf("Color scheme: %s\n", config.ColorScheme)
+	fmt.Printf("Default view: %s\n", config.DefaultView)
+
+	runner := db.NewMigrationRunner()
+	migrations, err := runner.GetAppliedMigrations()
+	if err != nil {
+		return fmt.Errorf("failed to get migration status: %w", err)
+	}
+
+	fmt.Printf("Applied migrations: %d\n", len(migrations))
+	for _, m := range migrations {
+		fmt.Printf("  - %s (%s)\n", m.Version, m.AppliedAt)
+	}
+
+	fmt.Println("Setup completed successfully!")
+	fmt.Println("\nYou can now use noteleaf commands:")
+	fmt.Println("  noteleaf add \"Buy groceries\"")
+	fmt.Println("  noteleaf list")
+	fmt.Println("  noteleaf movie add \"The Matrix\"")
+
+	return nil
+}
+
+// Reset recreates the database and configuration (destructive)
+func Reset(ctx context.Context, args []string) error {
+	fmt.Println("Resetting noteleaf...")
+
+	configDir, err := store.GetConfigDir()
+	if err != nil {
+		return fmt.Errorf("failed to get config directory: %w", err)
+	}
+
+	dbPath := filepath.Join(configDir, "noteleaf.db")
+	if err := os.Remove(dbPath); err != nil && !os.IsNotExist(err) {
+		return fmt.Errorf("failed to remove database: %w", err)
+	}
+
+	configPath, err := store.GetConfigPath()
+	if err != nil {
+		return fmt.Errorf("failed to get config path: %w", err)
+	}
+
+	if err := os.Remove(configPath); err != nil && !os.IsNotExist(err) {
+		return fmt.Errorf("failed to remove config: %w", err)
+	}
+
+	fmt.Println("Reset completed. Run 'noteleaf setup' to reinitialize.")
+	return nil
+}
+
+// Status shows the current application status
+func Status(ctx context.Context, args []string) error {
+	configDir, err := store.GetConfigDir()
+	if err != nil {
+		return fmt.Errorf("failed to get config directory: %w", err)
+	}
+
+	fmt.Printf("Config directory: %s\n", configDir)
+
+	dbPath := filepath.Join(configDir, "noteleaf.db")
+	if _, err := os.Stat(dbPath); err != nil {
+		fmt.Println("Database: Not found")
+		fmt.Println("Run 'noteleaf setup' to initialize.")
+		return nil
+	}
+
+	fmt.Printf("Database: %s\n", dbPath)
+
+	configPath, err := store.GetConfigPath()
+	if err != nil {
+		return fmt.Errorf("failed to get config path: %w", err)
+	}
+
+	if _, err := os.Stat(configPath); err != nil {
+		fmt.Println("Configuration: Not found")
+	} else {
+		fmt.Printf("Configuration: %s\n", configPath)
+	}
+
+	db, err := store.NewDatabase()
+	if err != nil {
+		return fmt.Errorf("failed to connect to database: %w", err)
+	}
+	defer db.Close()
+
+	runner := db.NewMigrationRunner()
+	applied, err := runner.GetAppliedMigrations()
+	if err != nil {
+		return fmt.Errorf("failed to get applied migrations: %w", err)
+	}
+
+	available, err := runner.GetAvailableMigrations()
+	if err != nil {
+		return fmt.Errorf("failed to get available migrations: %w", err)
+	}
+
+	fmt.Printf("Migrations: %d/%d applied\n", len(applied), len(available))
+
+	return nil
+}

cmd/handlers/handlers_test.go

···
+package handlers
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"stormlightlabs.org/noteleaf/internal/store"
+)
+
+func createTestDir(t *testing.T) string {
+	tempDir, err := os.MkdirTemp("", "noteleaf-test-*")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+
+	oldConfigHome := os.Getenv("XDG_CONFIG_HOME")
+	os.Setenv("XDG_CONFIG_HOME", tempDir)
+
+	t.Cleanup(func() {
+		os.Setenv("XDG_CONFIG_HOME", oldConfigHome)
+		os.RemoveAll(tempDir)
+	})
+
+	return tempDir
+}
+
+func TestSetup(t *testing.T) {
+	t.Run("creates database and config files", func(t *testing.T) {
+		_ = createTestDir(t)
+		ctx := context.Background()
+
+		err := Setup(ctx, []string{})
+		if err != nil {
+			t.Errorf("Setup failed: %v", err)
+		}
+
+		configDir, err := store.GetConfigDir()
+		if err != nil {
+			t.Fatalf("Failed to get config dir: %v", err)
+		}
+
+		dbPath := filepath.Join(configDir, "noteleaf.db")
+		if _, err := os.Stat(dbPath); os.IsNotExist(err) {
+			t.Error("Database file was not created")
+		}
+
+		configPath, err := store.GetConfigPath()
+		if err != nil {
+			t.Fatalf("Failed to get config path: %v", err)
+		}
+
+		if _, err := os.Stat(configPath); os.IsNotExist(err) {
+			t.Error("Config file was not created")
+		}
+
+	})
+
+	t.Run("handles existing database gracefully", func(t *testing.T) {
+		_ = createTestDir(t)
+		ctx := context.Background()
+
+		err1 := Setup(ctx, []string{})
+		if err1 != nil {
+			t.Errorf("First setup failed: %v", err1)
+		}
+
+		err2 := Setup(ctx, []string{})
+		if err2 != nil {
+			t.Errorf("Second setup should not fail: %v", err2)
+		}
+
+	})
+
+	t.Run("initializes migrations", func(t *testing.T) {
+		_ = createTestDir(t)
+		ctx := context.Background()
+
+		err := Setup(ctx, []string{})
+		if err != nil {
+			t.Errorf("Setup failed: %v", err)
+		}
+
+		db, err := store.NewDatabase()
+		if err != nil {
+			t.Fatalf("Failed to connect to database: %v", err)
+		}
+		defer db.Close()
+
+		runner := db.NewMigrationRunner()
+		migrations, err := runner.GetAppliedMigrations()
+		if err != nil {
+			t.Fatalf("Failed to get migrations: %v", err)
+		}
+
+		if len(migrations) == 0 {
+			t.Error("No migrations were applied")
+		}
+
+		var count int
+		err = db.QueryRow("SELECT COUNT(*) FROM migrations").Scan(&count)
+		if err != nil {
+			t.Errorf("Failed to query migrations table: %v", err)
+		}
+
+		if count == 0 {
+			t.Error("Migrations table is empty")
+		}
+
+	})
+}
+
+func TestReset(t *testing.T) {
+	t.Run("removes database and config files", func(t *testing.T) {
+		_ = createTestDir(t)
+		ctx := context.Background()
+
+		err := Setup(ctx, []string{})
+		if err != nil {
+			t.Fatalf("Setup failed: %v", err)
+		}
+
+		configDir, err := store.GetConfigDir()
+		if err != nil {
+			t.Fatalf("Failed to get config dir: %v", err)
+		}
+
+		dbPath := filepath.Join(configDir, "noteleaf.db")
+		configPath, err := store.GetConfigPath()
+		if err != nil {
+			t.Fatalf("Failed to get config path: %v", err)
+		}
+
+		if _, err := os.Stat(dbPath); os.IsNotExist(err) {
+			t.Fatal("Database should exist before reset")
+		}
+
+		if _, err := os.Stat(configPath); os.IsNotExist(err) {
+			t.Fatal("Config should exist before reset")
+		}
+
+		err = Reset(ctx, []string{})
+		if err != nil {
+			t.Errorf("Reset failed: %v", err)
+		}
+
+		if _, err := os.Stat(dbPath); !os.IsNotExist(err) {
+			t.Error("Database file should be removed after reset")
+		}
+
+		if _, err := os.Stat(configPath); !os.IsNotExist(err) {
+			t.Error("Config file should be removed after reset")
+		}
+
+	})
+
+	t.Run("handles non-existent files gracefully", func(t *testing.T) {
+		_ = createTestDir(t)
+		ctx := context.Background()
+
+		err := Reset(ctx, []string{})
+		if err != nil {
+			t.Errorf("Reset should handle non-existent files: %v", err)
+		}
+
+	})
+}
+
+func TestStatus(t *testing.T) {
+	t.Run("reports status when setup", func(t *testing.T) {
+		_ = createTestDir(t)
+		ctx := context.Background()
+
+		err := Setup(ctx, []string{})
+		if err != nil {
+			t.Fatalf("Setup failed: %v", err)
+		}
+
+		err = Status(ctx, []string{})
+		if err != nil {
+			t.Errorf("Status failed: %v", err)
+		}
+
+	})
+
+	t.Run("reports status when not setup", func(t *testing.T) {
+		_ = createTestDir(t)
+		ctx := context.Background()
+
+		err := Status(ctx, []string{})
+		if err != nil {
+			t.Errorf("Status should not fail when not setup: %v", err)
+		}
+
+	})
+
+	t.Run("shows migration information", func(t *testing.T) {
+		_ = createTestDir(t)
+		ctx := context.Background()
+
+		err := Setup(ctx, []string{})
+		if err != nil {
+			t.Fatalf("Setup failed: %v", err)
+		}
+
+		err = Status(ctx, []string{})
+		if err != nil {
+			t.Errorf("Status failed: %v", err)
+		}
+
+	})
+}
+
+func TestIntegration(t *testing.T) {
+	t.Run("full setup-reset-status cycle", func(t *testing.T) {
+		_ = createTestDir(t)
+		ctx := context.Background()
+
+		err := Status(ctx, []string{})
+		if err != nil {
+			t.Errorf("Initial status failed: %v", err)
+		}
+
+		err = Setup(ctx, []string{})
+		if err != nil {
+			t.Errorf("Setup failed: %v", err)
+		}
+
+		err = Status(ctx, []string{})
+		if err != nil {
+			t.Errorf("Status after setup failed: %v", err)
+		}
+
+		configDir, _ := store.GetConfigDir()
+		dbPath := filepath.Join(configDir, "noteleaf.db")
+		if _, err := os.Stat(dbPath); os.IsNotExist(err) {
+			t.Error("Database should exist after setup")
+		}
+
+		err = Reset(ctx, []string{})
+		if err != nil {
+			t.Errorf("Reset failed: %v", err)
+		}
+
+		if _, err := os.Stat(dbPath); !os.IsNotExist(err) {
+			t.Error("Database should not exist after reset")
+		}
+
+		err = Status(ctx, []string{})
+		if err != nil {
+			t.Errorf("Status after reset failed: %v", err)
+		}
+
+	})
+
+	t.Run("concurrent operations", func(t *testing.T) {
+		_ = createTestDir(t)
+		ctx := context.Background()
+
+		err := Setup(ctx, []string{})
+		if err != nil {
+			t.Fatalf("Setup failed: %v", err)
+		}
+
+		done := make(chan error, 3)
+
+		for range 3 {
+			go func() {
+				time.Sleep(time.Millisecond * 10)
+				done <- Status(ctx, []string{})
+			}()
+		}
+
+		for i := range 3 {
+			if err := <-done; err != nil {
+				t.Errorf("Concurrent status operation %d failed: %v", i, err)
+			}
+		}
+	})
+}

go.mod

···
 go 1.24.5
 
 require (
-	github.com/BurntSushi/toml v1.5.0 // indirect
-	github.com/alecthomas/chroma/v2 v2.14.0 // indirect
+	github.com/BurntSushi/toml v1.5.0
+	github.com/charmbracelet/fang v0.3.0
+	github.com/mattn/go-sqlite3 v1.14.32
+	github.com/spf13/cobra v1.9.1
+)
+
+require (
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
-	github.com/aymanbagabas/go-udiff v0.2.0 // indirect
-	github.com/aymerick/douceur v0.2.0 // indirect
-	github.com/charmbracelet/bubbles v0.21.0 // indirect
-	github.com/charmbracelet/bubbletea v1.3.6 // indirect
 	github.com/charmbracelet/colorprofile v0.3.1 // indirect
-	github.com/charmbracelet/fang v0.3.0 // indirect
-	github.com/charmbracelet/glamour v0.10.0 // indirect
-	github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834 // indirect
+	github.com/charmbracelet/lipgloss v1.1.0 // indirect
 	github.com/charmbracelet/lipgloss/v2 v2.0.0-beta1 // indirect
-	github.com/charmbracelet/log v0.4.2 // indirect
+	github.com/charmbracelet/log v0.4.2
 	github.com/charmbracelet/x/ansi v0.9.3 // indirect
 	github.com/charmbracelet/x/cellbuf v0.0.13 // indirect
 	github.com/charmbracelet/x/exp/charmtone v0.0.0-20250603201427-c31516f43444 // indirect
 	github.com/charmbracelet/x/exp/golden v0.0.0-20241011142426-46044092ad91 // indirect
-	github.com/charmbracelet/x/exp/slice v0.0.0-20250327172914-2fdc97757edf // indirect
 	github.com/charmbracelet/x/term v0.2.1 // indirect
-	github.com/dlclark/regexp2 v1.11.0 // indirect
-	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
 	github.com/go-logfmt/logfmt v0.6.0 // indirect
-	github.com/gorilla/css v1.0.1 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/mattn/go-localereader v0.0.1 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
-	github.com/mattn/go-sqlite3 v1.14.32 // indirect
-	github.com/microcosm-cc/bluemonday v1.0.27 // indirect
-	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
 	github.com/muesli/cancelreader v0.2.2 // indirect
 	github.com/muesli/mango v0.1.0 // indirect
 	github.com/muesli/mango-cobra v1.2.0 // indirect
 	github.com/muesli/mango-pflag v0.1.0 // indirect
-	github.com/muesli/reflow v0.3.0 // indirect
 	github.com/muesli/roff v0.1.0 // indirect
 	github.com/muesli/termenv v0.16.0 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
-	github.com/spf13/cobra v1.9.1 // indirect
 	github.com/spf13/pflag v1.0.6 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
-	github.com/yuin/goldmark v1.7.8 // indirect
-	github.com/yuin/goldmark-emoji v1.0.5 // indirect
 	golang.org/x/exp v0.0.0-20231006140011-7918f672742d // indirect
-	golang.org/x/net v0.33.0 // indirect
-	golang.org/x/sync v0.15.0 // indirect
 	golang.org/x/sys v0.33.0 // indirect
-	golang.org/x/term v0.31.0 // indirect
 	golang.org/x/text v0.24.0 // indirect
 )

go.sum

···
 github.com/BurntSushi/toml v1.5.0 h1:W5quZX/G/csjUnuI8SUYlsHs9M38FC7znL0lIO+DvMg=
 github.com/BurntSushi/toml v1.5.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
-github.com/alecthomas/chroma/v2 v2.14.0 h1:R3+wzpnUArGcQz7fCETQBzO5n9IMNi13iIs46aU4V9E=
-github.com/alecthomas/chroma/v2 v2.14.0/go.mod h1:QolEbTfmUHIMVpBqxeDnNBj2uoeI4EbYP4i6n68SG4I=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
 github.com/aymanbagabas/go-udiff v0.2.0 h1:TK0fH4MteXUDspT88n8CKzvK0X9O2xu9yQjWpi6yML8=
 github.com/aymanbagabas/go-udiff v0.2.0/go.mod h1:RE4Ex0qsGkTAJoQdQQCA0uG+nAzJO/pI/QwceO5fgrA=
-github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
-github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
-github.com/charmbracelet/bubbles v0.21.0 h1:9TdC97SdRVg/1aaXNVWfFH3nnLAwOXr8Fn6u6mfQdFs=
-github.com/charmbracelet/bubbles v0.21.0/go.mod h1:HF+v6QUR4HkEpz62dx7ym2xc71/KBHg+zKwJtMw+qtg=
-github.com/charmbracelet/bubbletea v1.3.6 h1:VkHIxPJQeDt0aFJIsVxw8BQdh/F/L2KKZGsK6et5taU=
-github.com/charmbracelet/bubbletea v1.3.6/go.mod h1:oQD9VCRQFF8KplacJLo28/jofOI2ToOfGYeFgBBxHOc=
-github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc h1:4pZI35227imm7yK2bGPcfpFEmuY1gc2YSTShr4iJBfs=
-github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc/go.mod h1:X4/0JoqgTIPSFcRA/P6INZzIuyqdFY5rm8tb41s9okk=
 github.com/charmbracelet/colorprofile v0.3.1 h1:k8dTHMd7fgw4bnFd7jXTLZrSU/CQrKnL3m+AxCzDz40=
 github.com/charmbracelet/colorprofile v0.3.1/go.mod h1:/GkGusxNs8VB/RSOh3fu0TJmQ4ICMMPApIIVn0KszZ0=
 github.com/charmbracelet/fang v0.3.0 h1:Be6TB+ExS8VWizTQRJgjqbJBudKrmVUet65xmFPGhaA=
 github.com/charmbracelet/fang v0.3.0/go.mod h1:b0ZfEXZeBds0I27/wnTfnv2UVigFDXHhrFNwQztfA0M=
-github.com/charmbracelet/glamour v0.10.0 h1:MtZvfwsYCx8jEPFJm3rIBFIMZUfUJ765oX8V6kXldcY=
-github.com/charmbracelet/glamour v0.10.0/go.mod h1:f+uf+I/ChNmqo087elLnVdCiVgjSKWuXa/l6NU2ndYk=
 github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY=
 github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30=
-github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834 h1:ZR7e0ro+SZZiIZD7msJyA+NjkCNNavuiPBLgerbOziE=
-github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834/go.mod h1:aKC/t2arECF6rNOnaKaVU6y4t4ZeHQzqfxedE/VkVhA=
-github.com/charmbracelet/lipgloss/v2 v2.0.0-beta.2 h1:vq2enzx1Hr3UenVefpPEf+E2xMmqtZoSHhx8IE+V8ug=
-github.com/charmbracelet/lipgloss/v2 v2.0.0-beta.2/go.mod h1:EJWvaCrhOhNGVZMvcjc0yVryl4qqpMs8tz0r9WyEkdQ=
 github.com/charmbracelet/lipgloss/v2 v2.0.0-beta1 h1:SOylT6+BQzPHEjn15TIzawBPVD0QmhKXbcb3jY0ZIKU=
 github.com/charmbracelet/lipgloss/v2 v2.0.0-beta1/go.mod h1:tRlx/Hu0lo/j9viunCN2H+Ze6JrmdjQlXUQvvArgaOc=
 github.com/charmbracelet/log v0.4.2 h1:hYt8Qj6a8yLnvR+h7MwsJv/XvmBJXiueUcI3cIxsyig=
 github.com/charmbracelet/log v0.4.2/go.mod h1:qifHGX/tc7eluv2R6pWIpyHDDrrb/AG71Pf2ysQu5nw=
-github.com/charmbracelet/x/ansi v0.8.0 h1:9GTq3xq9caJW8ZrBTe0LIe2fvfLR/bYXKTx2llXn7xE=
-github.com/charmbracelet/x/ansi v0.8.0/go.mod h1:wdYl/ONOLHLIVmQaxbIYEC/cRKOQyjTkowiI4blgS9Q=
 github.com/charmbracelet/x/ansi v0.9.3 h1:BXt5DHS/MKF+LjuK4huWrC6NCvHtexww7dMayh6GXd0=
 github.com/charmbracelet/x/ansi v0.9.3/go.mod h1:3RQDQ6lDnROptfpWuUVIUG64bD2g2BgntdxH0Ya5TeE=
-github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd h1:vy0GVL4jeHEwG5YOXDmi86oYw2yuYUGqz6a8sLwg0X8=
-github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd/go.mod h1:xe0nKWGd3eJgtqZRaN9RjMtK7xUYchjzPr7q6kcvCCs=
 github.com/charmbracelet/x/cellbuf v0.0.13 h1:/KBBKHuVRbq1lYx5BzEHBAFBP8VcQzJejZ/IA3iR28k=
 github.com/charmbracelet/x/cellbuf v0.0.13/go.mod h1:xe0nKWGd3eJgtqZRaN9RjMtK7xUYchjzPr7q6kcvCCs=
 github.com/charmbracelet/x/exp/charmtone v0.0.0-20250603201427-c31516f43444 h1:IJDiTgVE56gkAGfq0lBEloWgkXMk4hl/bmuPoicI4R0=
 github.com/charmbracelet/x/exp/charmtone v0.0.0-20250603201427-c31516f43444/go.mod h1:T9jr8CzFpjhFVHjNjKwbAD7KwBNyFnj2pntAO7F2zw0=
 github.com/charmbracelet/x/exp/golden v0.0.0-20241011142426-46044092ad91 h1:payRxjMjKgx2PaCWLZ4p3ro9y97+TVLZNaRZgJwSVDQ=
 github.com/charmbracelet/x/exp/golden v0.0.0-20241011142426-46044092ad91/go.mod h1:wDlXFlCrmJ8J+swcL/MnGUuYnqgQdW9rhSD61oNMb6U=
-github.com/charmbracelet/x/exp/slice v0.0.0-20250327172914-2fdc97757edf h1:rLG0Yb6MQSDKdB52aGX55JT1oi0P0Kuaj7wi1bLUpnI=
-github.com/charmbracelet/x/exp/slice v0.0.0-20250327172914-2fdc97757edf/go.mod h1:B3UgsnsBZS/eX42BlaNiJkD1pPOUa+oF1IYC6Yd2CEU=
 github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ=
 github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNEEkHUMCmsxdUg=
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
-github.com/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI=
-github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
-github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
-github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/go-logfmt/logfmt v0.6.0 h1:wGYYu3uicYdqXVgoYbvnkrPVXkuLM1p1ifugDMEdRi4=
 github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
-github.com/gorilla/css v1.0.1 h1:ntNaBIghp6JmvWnxbZKANoLyuXTPZ4cAMlo6RyhlbO8=
-github.com/gorilla/css v1.0.1/go.mod h1:BvnYkspnSzMmwRK+b8/xgNPLiIuNZr6vbZBTPQ2A3b0=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
 github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4=
-github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=
-github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
 github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-sqlite3 v1.14.32 h1:JD12Ag3oLy1zQA+BNn74xRgaBbdhbNIDYvQUEuuErjs=
 github.com/mattn/go-sqlite3 v1.14.32/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
-github.com/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwXFM08ygZfk=
-github.com/microcosm-cc/bluemonday v1.0.27/go.mod h1:jFi9vgW+H7c3V0lb6nR74Ib/DIB5OBs92Dimizgw2cA=
-github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI=
-github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo=
 github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
 github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
 github.com/muesli/mango v0.1.0 h1:DZQK45d2gGbql1arsYA4vfg4d7I9Hfx5rX/GCmzsAvI=
···
 github.com/muesli/mango-cobra v1.2.0/go.mod h1:vMJL54QytZAJhCT13LPVDfkvCUJ5/4jNUKF/8NC2UjA=
 github.com/muesli/mango-pflag v0.1.0 h1:UADqbYgpUyRoBja3g6LUL+3LErjpsOwaC9ywvBWe7Sg=
 github.com/muesli/mango-pflag v0.1.0/go.mod h1:YEQomTxaCUp8PrbhFh10UfbhbQrM/xJ4i2PB8VTLLW0=
-github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s=
-github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8=
 github.com/muesli/roff v0.1.0 h1:YD0lalCotmYuF5HhZliKWlIx7IEhiXeSfq7hNjFqGF8=
 github.com/muesli/roff v0.1.0/go.mod h1:pjAHQM9hdUUwm/krAfrLGgJkXJ+YuhtsfZ42kieB2Ig=
 github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=
 github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=
-github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
···
 github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wxYW0=
 github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
 github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
-github.com/yuin/goldmark v1.7.1/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E=
-github.com/yuin/goldmark v1.7.8 h1:iERMLn0/QJeHFhxSt3p6PeN9mGnvIKSpG9YYorDMnic=
-github.com/yuin/goldmark v1.7.8/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E=
-github.com/yuin/goldmark-emoji v1.0.5 h1:EMVWyCGPlXJfUXBXpuMu+ii3TIaxbVBnEX9uaDC4cIk=
-github.com/yuin/goldmark-emoji v1.0.5/go.mod h1:tTkZEbwu5wkPmgTcitqddVxY9osFZiavD+r4AzQrh1U=
 golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
 golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
-golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
-golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
-golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8=
-golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
-golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
-golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
 golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/term v0.31.0 h1:erwDkOK1Msy6offm1mOgvspSkslFnIGsFnxOKoufg3o=
-golang.org/x/term v0.31.0/go.mod h1:R4BeIy7D95HzImkxGkTW1UQTtP54tio2RyHz7PwK0aw=
-golang.org/x/text v0.3.8 h1:nAL+RVCQ9uMn3vJZbV+MRnydTJFPf8qqY42YiA6MrqY=
-golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
 golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0=
 golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/models/models.go

···
+package models
+
+import (
+	"encoding/json"
+	"time"
+)
+
+// Model defines the common interface that all domain models must implement
+type Model interface {
+	// GetID returns the primary key identifier
+	GetID() int64
+
+	// SetID sets the primary key identifier
+	SetID(id int64)
+
+	// GetTableName returns the database table name for this model
+	GetTableName() string
+
+	// GetCreatedAt returns when the model was created
+	GetCreatedAt() time.Time
+
+	// SetCreatedAt sets when the model was created
+	SetCreatedAt(t time.Time)
+
+	// GetUpdatedAt returns when the model was last updated
+	GetUpdatedAt() time.Time
+
+	// SetUpdatedAt sets when the model was last updated
+	SetUpdatedAt(t time.Time)
+}
+
+// Task represents a task item with TaskWarrior-inspired fields
+type Task struct {
+	ID          int64  `json:"id"`
+	UUID        string `json:"uuid"`
+	Description string `json:"description"`
+	// pending, completed, deleted
+	Status string `json:"status"`
+	// A-Z or empty
+	Priority string     `json:"priority,omitempty"`
+	Project  string     `json:"project,omitempty"`
+	Tags     []string   `json:"tags,omitempty"`
+	Due      *time.Time `json:"due,omitempty"`
+	Entry    time.Time  `json:"entry"`
+	Modified time.Time  `json:"modified"`
+	// completion time
+	End *time.Time `json:"end,omitempty"`
+	// when task was started
+	Start       *time.Time `json:"start,omitempty"`
+	Annotations []string   `json:"annotations,omitempty"`
+}
+
+// Movie represents a movie in the watch queue
+type Movie struct {
+	ID    int64  `json:"id"`
+	Title string `json:"title"`
+	Year  int    `json:"year,omitempty"`
+	// queued, watched, removed
+	Status  string     `json:"status"`
+	Rating  float64    `json:"rating,omitempty"`
+	Notes   string     `json:"notes,omitempty"`
+	Added   time.Time  `json:"added"`
+	Watched *time.Time `json:"watched,omitempty"`
+}
+
+// TVShow represents a TV show in the watch queue
+type TVShow struct {
+	ID      int64  `json:"id"`
+	Title   string `json:"title"`
+	Season  int    `json:"season,omitempty"`
+	Episode int    `json:"episode,omitempty"`
+	// queued, watching, watched, removed
+	Status      string     `json:"status"`
+	Rating      float64    `json:"rating,omitempty"`
+	Notes       string     `json:"notes,omitempty"`
+	Added       time.Time  `json:"added"`
+	LastWatched *time.Time `json:"last_watched,omitempty"`
+}
+
+// Book represents a book in the reading list
+type Book struct {
+	ID     int64  `json:"id"`
+	Title  string `json:"title"`
+	Author string `json:"author,omitempty"`
+	// queued, reading, finished, removed
+	Status string `json:"status"`
+	// percentage 0-100
+	Progress int        `json:"progress"`
+	Pages    int        `json:"pages,omitempty"`
+	Rating   float64    `json:"rating,omitempty"`
+	Notes    string     `json:"notes,omitempty"`
+	Added    time.Time  `json:"added"`
+	Started  *time.Time `json:"started,omitempty"`
+	Finished *time.Time `json:"finished,omitempty"`
+}
+
+// MarshalTags converts tags slice to JSON string for database storage
+func (t *Task) MarshalTags() (string, error) {
+	if len(t.Tags) == 0 {
+		return "", nil
+	}
+	data, err := json.Marshal(t.Tags)
+	return string(data), err
+}
+
+// UnmarshalTags converts JSON string from database to tags slice
+func (t *Task) UnmarshalTags(data string) error {
+	if data == "" {
+		t.Tags = nil
+		return nil
+	}
+	return json.Unmarshal([]byte(data), &t.Tags)
+}
+
+// MarshalAnnotations converts annotations slice to JSON string for database storage
+func (t *Task) MarshalAnnotations() (string, error) {
+	if len(t.Annotations) == 0 {
+		return "", nil
+	}
+	data, err := json.Marshal(t.Annotations)
+	return string(data), err
+}
+
+// UnmarshalAnnotations converts JSON string from database to annotations slice
+func (t *Task) UnmarshalAnnotations(data string) error {
+	if data == "" {
+		t.Annotations = nil
+		return nil
+	}
+	return json.Unmarshal([]byte(data), &t.Annotations)
+}
+
+// IsCompleted returns true if the task is marked as completed
+func (t *Task) IsCompleted() bool {
+	return t.Status == "completed"
+}
+
+// IsPending returns true if the task is pending
+func (t *Task) IsPending() bool {
+	return t.Status == "pending"
+}
+
+// IsDeleted returns true if the task is deleted
+func (t *Task) IsDeleted() bool {
+	return t.Status == "deleted"
+}
+
+// HasPriority returns true if the task has a priority set
+func (t *Task) HasPriority() bool {
+	return t.Priority != ""
+}
+
+// IsWatched returns true if the movie has been watched
+func (m *Movie) IsWatched() bool {
+	return m.Status == "watched"
+}
+
+// IsQueued returns true if the movie is in the queue
+func (m *Movie) IsQueued() bool {
+	return m.Status == "queued"
+}
+
+// IsWatching returns true if the TV show is currently being watched
+func (tv *TVShow) IsWatching() bool {
+	return tv.Status == "watching"
+}
+
+// IsWatched returns true if the TV show has been watched
+func (tv *TVShow) IsWatched() bool {
+	return tv.Status == "watched"
+}
+
+// IsQueued returns true if the TV show is in the queue
+func (tv *TVShow) IsQueued() bool {
+	return tv.Status == "queued"
+}
+
+// IsReading returns true if the book is currently being read
+func (b *Book) IsReading() bool {
+	return b.Status == "reading"
+}
+
+// IsFinished returns true if the book has been finished
+func (b *Book) IsFinished() bool {
+	return b.Status == "finished"
+}
+
+// IsQueued returns true if the book is in the queue
+func (b *Book) IsQueued() bool {
+	return b.Status == "queued"
+}
+
+// ProgressPercent returns the reading progress as a percentage
+func (b *Book) ProgressPercent() int {
+	return b.Progress
+}
+
+func (t *Task) GetID() int64                { return t.ID }
+func (t *Task) SetID(id int64)              { t.ID = id }
+func (t *Task) GetTableName() string        { return "tasks" }
+func (t *Task) GetCreatedAt() time.Time     { return t.Entry }
+func (t *Task) SetCreatedAt(time time.Time) { t.Entry = time }
+func (t *Task) GetUpdatedAt() time.Time     { return t.Modified }
+func (t *Task) SetUpdatedAt(time time.Time) { t.Modified = time }
+
+func (m *Movie) GetID() int64                { return m.ID }
+func (m *Movie) SetID(id int64)              { m.ID = id }
+func (m *Movie) GetTableName() string        { return "movies" }
+func (m *Movie) GetCreatedAt() time.Time     { return m.Added }
+func (m *Movie) SetCreatedAt(time time.Time) { m.Added = time }
+func (m *Movie) GetUpdatedAt() time.Time     { return m.Added }
+func (m *Movie) SetUpdatedAt(time time.Time) { m.Added = time }
+
+func (tv *TVShow) GetID() int64                { return tv.ID }
+func (tv *TVShow) SetID(id int64)              { tv.ID = id }
+func (tv *TVShow) GetTableName() string        { return "tv_shows" }
+func (tv *TVShow) GetCreatedAt() time.Time     { return tv.Added }
+func (tv *TVShow) SetCreatedAt(time time.Time) { tv.Added = time }
+func (tv *TVShow) GetUpdatedAt() time.Time     { return tv.Added }
+func (tv *TVShow) SetUpdatedAt(time time.Time) { tv.Added = time }
+
+func (b *Book) GetID() int64                { return b.ID }
+func (b *Book) SetID(id int64)              { b.ID = id }
+func (b *Book) GetTableName() string        { return "books" }
+func (b *Book) GetCreatedAt() time.Time     { return b.Added }
+func (b *Book) SetCreatedAt(time time.Time) { b.Added = time }
+func (b *Book) GetUpdatedAt() time.Time     { return b.Added }
+func (b *Book) SetUpdatedAt(time time.Time) { b.Added = time }

internal/models/task.go

···
-package models
-
-import (
-	"encoding/json"
-	"time"
-)
-
-// Task represents a task item with TaskWarrior-inspired fields
-type Task struct {
-	ID          int64     `json:"id"`
-	UUID        string    `json:"uuid"`
-	Description string    `json:"description"`
-	Status      string    `json:"status"` // pending, completed, deleted
-	Priority    string    `json:"priority,omitempty"` // A-Z or empty
-	Project     string    `json:"project,omitempty"`
-	Tags        []string  `json:"tags,omitempty"`
-	Due         *time.Time `json:"due,omitempty"`
-	Entry       time.Time `json:"entry"`
-	Modified    time.Time `json:"modified"`
-	End         *time.Time `json:"end,omitempty"` // completion time
-	Start       *time.Time `json:"start,omitempty"` // when task was started
-	Annotations []string  `json:"annotations,omitempty"`
-}
-
-// Movie represents a movie in the watch queue
-type Movie struct {
-	ID          int64     `json:"id"`
-	Title       string    `json:"title"`
-	Year        int       `json:"year,omitempty"`
-	Status      string    `json:"status"` // queued, watched, removed
-	Rating      float64   `json:"rating,omitempty"`
-	Notes       string    `json:"notes,omitempty"`
-	Added       time.Time `json:"added"`
-	Watched     *time.Time `json:"watched,omitempty"`
-}
-
-// TVShow represents a TV show in the watch queue
-type TVShow struct {
-	ID           int64     `json:"id"`
-	Title        string    `json:"title"`
-	Season       int       `json:"season,omitempty"`
-	Episode      int       `json:"episode,omitempty"`
-	Status       string    `json:"status"` // queued, watching, watched, removed
-	Rating       float64   `json:"rating,omitempty"`
-	Notes        string    `json:"notes,omitempty"`
-	Added        time.Time `json:"added"`
-	LastWatched  *time.Time `json:"last_watched,omitempty"`
-}
-
-// Book represents a book in the reading list
-type Book struct {
-	ID           int64     `json:"id"`
-	Title        string    `json:"title"`
-	Author       string    `json:"author,omitempty"`
-	Status       string    `json:"status"` // queued, reading, finished, removed
-	Progress     int       `json:"progress"` // percentage 0-100
-	Pages        int       `json:"pages,omitempty"`
-	Rating       float64   `json:"rating,omitempty"`
-	Notes        string    `json:"notes,omitempty"`
-	Added        time.Time `json:"added"`
-	Started      *time.Time `json:"started,omitempty"`
-	Finished     *time.Time `json:"finished,omitempty"`
-}
-
-// MarshalTags converts tags slice to JSON string for database storage
-func (t *Task) MarshalTags() (string, error) {
-	if len(t.Tags) == 0 {
-		return "", nil
-	}
-	data, err := json.Marshal(t.Tags)
-	return string(data), err
-}
-
-// UnmarshalTags converts JSON string from database to tags slice
-func (t *Task) UnmarshalTags(data string) error {
-	if data == "" {
-		t.Tags = nil
-		return nil
-	}
-	return json.Unmarshal([]byte(data), &t.Tags)
-}
-
-// MarshalAnnotations converts annotations slice to JSON string for database storage
-func (t *Task) MarshalAnnotations() (string, error) {
-	if len(t.Annotations) == 0 {
-		return "", nil
-	}
-	data, err := json.Marshal(t.Annotations)
-	return string(data), err
-}
-
-// UnmarshalAnnotations converts JSON string from database to annotations slice
-func (t *Task) UnmarshalAnnotations(data string) error {
-	if data == "" {
-		t.Annotations = nil
-		return nil
-	}
-	return json.Unmarshal([]byte(data), &t.Annotations)
-}
-
-// IsCompleted returns true if the task is marked as completed
-func (t *Task) IsCompleted() bool {
-	return t.Status == "completed"
-}
-
-// IsPending returns true if the task is pending
-func (t *Task) IsPending() bool {
-	return t.Status == "pending"
-}
-
-// IsDeleted returns true if the task is deleted
-func (t *Task) IsDeleted() bool {
-	return t.Status == "deleted"
-}
-
-// HasPriority returns true if the task has a priority set
-func (t *Task) HasPriority() bool {
-	return t.Priority != ""
-}
-
-// IsWatched returns true if the movie has been watched
-func (m *Movie) IsWatched() bool {
-	return m.Status == "watched"
-}
-
-// IsQueued returns true if the movie is in the queue
-func (m *Movie) IsQueued() bool {
-	return m.Status == "queued"
-}
-
-// IsWatching returns true if the TV show is currently being watched
-func (tv *TVShow) IsWatching() bool {
-	return tv.Status == "watching"
-}
-
-// IsWatched returns true if the TV show has been watched
-func (tv *TVShow) IsWatched() bool {
-	return tv.Status == "watched"
-}
-
-// IsQueued returns true if the TV show is in the queue
-func (tv *TVShow) IsQueued() bool {
-	return tv.Status == "queued"
-}
-
-// IsReading returns true if the book is currently being read
-func (b *Book) IsReading() bool {
-	return b.Status == "reading"
-}
-
-// IsFinished returns true if the book has been finished
-func (b *Book) IsFinished() bool {
-	return b.Status == "finished"
-}
-
-// IsQueued returns true if the book is in the queue
-func (b *Book) IsQueued() bool {
-	return b.Status == "queued"
-}
-
-// ProgressPercent returns the reading progress as a percentage
-func (b *Book) ProgressPercent() int {
-	return b.Progress
-}

internal/repo/repo.go

···
+package repo
+
+import (
+	"context"
+
+	"stormlightlabs.org/noteleaf/internal/models"
+)
+
+// Repository defines a general, behavior-focused interface for data access
+type Repository interface {
+	// Create stores a new model and returns its assigned ID
+	Create(ctx context.Context, model models.Model) (int64, error)
+
+	// Get retrieves a model by ID
+	Get(ctx context.Context, table string, id int64, dest models.Model) error
+
+	// Update modifies an existing model
+	Update(ctx context.Context, model models.Model) error
+
+	// Delete removes a model by ID
+	Delete(ctx context.Context, table string, id int64) error
+
+	// List retrieves models with optional filtering and sorting
+	List(ctx context.Context, table string, opts ListOptions, dest any) error
+
+	// Find retrieves models matching specific conditions
+	Find(ctx context.Context, table string, conditions map[string]any, dest any) error
+
+	// Count returns the number of models matching conditions
+	Count(ctx context.Context, table string, conditions map[string]any) (int64, error)
+
+	// Execute runs a custom query with parameters
+	Execute(ctx context.Context, query string, args ...any) error
+
+	// Query runs a custom query and returns results
+	Query(ctx context.Context, query string, dest any, args ...any) error
+}
+
+// ListOptions defines generic options for listing items
+type ListOptions struct {
+	// field: value pairs for WHERE conditions
+	Where  map[string]any
+	Limit  int
+	Offset int
+	// field name to sort by
+	SortBy string
+	// "asc" or "desc"
+	SortOrder string
+	// general search term
+	Search string
+	// fields to search in
+	SearchFields []string
+}

internal/store/config.go

···
 
 // Config holds application configuration
 type Config struct {
-	// Database settings
-	DatabasePath string `toml:"database_path,omitempty"`
-	
-	// Display settings
-	DateFormat   string `toml:"date_format"`
-	ColorScheme  string `toml:"color_scheme"`
-	DefaultView  string `toml:"default_view"`
-	
-	// Task settings
+	DatabasePath    string `toml:"database_path,omitempty"`
+	DateFormat      string `toml:"date_format"`
+	ColorScheme     string `toml:"color_scheme"`
+	DefaultView     string `toml:"default_view"`
 	DefaultPriority string `toml:"default_priority,omitempty"`
 	AutoArchive     bool   `toml:"auto_archive"`
-	
-	// Sync settings
-	SyncEnabled  bool   `toml:"sync_enabled"`
-	SyncEndpoint string `toml:"sync_endpoint,omitempty"`
-	SyncToken    string `toml:"sync_token,omitempty"`
-	
-	// Export settings
-	ExportFormat string `toml:"export_format"`
-	
-	// Media settings
-	MovieAPIKey string `toml:"movie_api_key,omitempty"`
-	BookAPIKey  string `toml:"book_api_key,omitempty"`
+	SyncEnabled     bool   `toml:"sync_enabled"`
+	SyncEndpoint    string `toml:"sync_endpoint,omitempty"`
+	SyncToken       string `toml:"sync_token,omitempty"`
+	ExportFormat    string `toml:"export_format"`
+	MovieAPIKey     string `toml:"movie_api_key,omitempty"`
+	BookAPIKey      string `toml:"book_api_key,omitempty"`
 }
 
 // DefaultConfig returns a configuration with sensible defaults
···
 	if err != nil {
 		return nil, fmt.Errorf("failed to get config directory: %w", err)
 	}
-	
+
 	configPath := filepath.Join(configDir, ".noteleaf.conf.toml")
-	
-	// If config file doesn't exist, create it with defaults
+
 	if _, err := os.Stat(configPath); os.IsNotExist(err) {
 		config := DefaultConfig()
 		if err := SaveConfig(config); err != nil {
···
 		}
 		return config, nil
 	}
-	
+
 	data, err := os.ReadFile(configPath)
 	if err != nil {
 		return nil, fmt.Errorf("failed to read config file: %w", err)
 	}
-	
+
 	config := DefaultConfig()
 	if err := toml.Unmarshal(data, config); err != nil {
 		return nil, fmt.Errorf("failed to parse config file: %w", err)
 	}
-	
+
 	return config, nil
 }
 
···
 	if err != nil {
 		return fmt.Errorf("failed to get config directory: %w", err)
 	}
-	
+
 	configPath := filepath.Join(configDir, ".noteleaf.conf.toml")
-	
+
 	data, err := toml.Marshal(config)
 	if err != nil {
 		return fmt.Errorf("failed to marshal config: %w", err)
 	}
-	
+
 	if err := os.WriteFile(configPath, data, 0644); err != nil {
 		return fmt.Errorf("failed to write config file: %w", err)
 	}
-	
+
 	return nil
 }
 
···
 		return "", err
 	}
 	return filepath.Join(configDir, ".noteleaf.conf.toml"), nil
-}
+}

internal/store/database.go

···
 	"os"
 	"path/filepath"
 	"runtime"
-	"sort"
-	"strings"
 
 	_ "github.com/mattn/go-sqlite3"
 )
···
 			return "", fmt.Errorf("APPDATA environment variable not set")
 		}
 		configDir = filepath.Join(appData, "noteleaf")
-	default: // Unix-like systems (Linux, macOS, BSD, etc.)
+	default:
 		xdgConfigHome := os.Getenv("XDG_CONFIG_HOME")
 		if xdgConfigHome == "" {
 			homeDir, err := os.UserHomeDir()
···
 		return nil, fmt.Errorf("failed to open database: %w", err)
 	}
 
-	// Enable foreign keys and WAL mode for better performance
 	if _, err := db.Exec("PRAGMA foreign_keys = ON"); err != nil {
 		db.Close()
 		return nil, fmt.Errorf("failed to enable foreign keys: %w", err)
···
 		path: dbPath,
 	}
 
-	// Run migrations
-	if err := database.runMigrations(); err != nil {
+	runner := NewMigrationRunner(db, migrationFiles)
+	if err := runner.RunMigrations(); err != nil {
 		db.Close()
 		return nil, fmt.Errorf("failed to run migrations: %w", err)
 	}
···
 	return database, nil
 }
 
-// runMigrations applies all pending migrations
-func (db *Database) runMigrations() error {
-	// Get all migration files
-	entries, err := migrationFiles.ReadDir("../sql/migrations")
-	if err != nil {
-		return fmt.Errorf("failed to read migrations directory: %w", err)
-	}
-
-	// Filter and sort up migrations
-	var upMigrations []string
-	for _, entry := range entries {
-		if strings.HasSuffix(entry.Name(), "_up.sql") {
-			upMigrations = append(upMigrations, entry.Name())
-		}
-	}
-	sort.Strings(upMigrations)
-
-	// Apply migrations in order
-	for _, migrationFile := range upMigrations {
-		version := extractVersionFromFilename(migrationFile)
-
-		// Check if migration already applied
-		var count int
-		err := db.QueryRow("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='migrations'").Scan(&count)
-		if err != nil {
-			return fmt.Errorf("failed to check migrations table: %w", err)
-		}
-
-		// If migrations table doesn't exist and this isn't migration 0000, skip
-		if count == 0 && version != "0000" {
-			continue
-		}
-
-		// Check if this specific migration was applied (only if migrations table exists)
-		if count > 0 {
-			var applied int
-			err = db.QueryRow("SELECT COUNT(*) FROM migrations WHERE version = ?", version).Scan(&applied)
-			if err != nil {
-				return fmt.Errorf("failed to check migration %s: %w", version, err)
-			}
-			if applied > 0 {
-				continue // Skip already applied migration
-			}
-		}
-
-		// Read and execute migration
-		content, err := migrationFiles.ReadFile("../sql/migrations/" + migrationFile)
-		if err != nil {
-			return fmt.Errorf("failed to read migration %s: %w", migrationFile, err)
-		}
-
-		if _, err := db.Exec(string(content)); err != nil {
-			return fmt.Errorf("failed to execute migration %s: %w", migrationFile, err)
-		}
-
-		// Record migration as applied (only if migrations table exists)
-		if count > 0 || version == "0000" {
-			if _, err := db.Exec("INSERT INTO migrations (version) VALUES (?)", version); err != nil {
-				return fmt.Errorf("failed to record migration %s: %w", version, err)
-			}
-		}
-	}
-
-	return nil
-}
-
-// extractVersionFromFilename extracts the 4-digit version from a migration filename
-func extractVersionFromFilename(filename string) string {
-	parts := strings.Split(filename, "_")
-	if len(parts) > 0 {
-		return parts[0]
-	}
-	return ""
+// NewMigrationRunnerFromDB creates a new migration runner from a Database instance
+func (db *Database) NewMigrationRunner() *MigrationRunner {
+	return NewMigrationRunner(db.DB, migrationFiles)
 }
 
 // GetPath returns the database file path

internal/store/migration.go

···
+package store
+
+import (
+	"database/sql"
+	"embed"
+	"fmt"
+	"sort"
+	"strings"
+)
+
+// Migration represents a single database migration
+type Migration struct {
+	Version   string
+	Name      string
+	UpSQL     string
+	DownSQL   string
+	Applied   bool
+	AppliedAt string
+}
+
+// MigrationRunner handles database migrations
+type MigrationRunner struct {
+	db             *sql.DB
+	migrationFiles embed.FS
+}
+
+// NewMigrationRunner creates a new migration runner
+func NewMigrationRunner(db *sql.DB, files embed.FS) *MigrationRunner {
+	return &MigrationRunner{
+		db:             db,
+		migrationFiles: files,
+	}
+}
+
+// RunMigrations applies all pending migrations
+func (mr *MigrationRunner) RunMigrations() error {
+	entries, err := mr.migrationFiles.ReadDir("sql/migrations")
+	if err != nil {
+		return fmt.Errorf("failed to read migrations directory: %w", err)
+	}
+
+	var upMigrations []string
+	for _, entry := range entries {
+		if strings.HasSuffix(entry.Name(), "_up.sql") {
+			upMigrations = append(upMigrations, entry.Name())
+		}
+	}
+	sort.Strings(upMigrations)
+
+	for _, migrationFile := range upMigrations {
+		version := extractVersionFromFilename(migrationFile)
+
+		var count int
+		err := mr.db.QueryRow("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='migrations'").Scan(&count)
+		if err != nil {
+			return fmt.Errorf("failed to check migrations table: %w", err)
+		}
+
+		if count == 0 && version != "0000" {
+			continue
+		}
+
+		if count > 0 {
+			var applied int
+			err = mr.db.QueryRow("SELECT COUNT(*) FROM migrations WHERE version = ?", version).Scan(&applied)
+			if err != nil {
+				return fmt.Errorf("failed to check migration %s: %w", version, err)
+			}
+			if applied > 0 {
+				continue
+			}
+		}
+
+		content, err := mr.migrationFiles.ReadFile("sql/migrations/" + migrationFile)
+		if err != nil {
+			return fmt.Errorf("failed to read migration %s: %w", migrationFile, err)
+		}
+
+		if _, err := mr.db.Exec(string(content)); err != nil {
+			return fmt.Errorf("failed to execute migration %s: %w", migrationFile, err)
+		}
+
+		if count > 0 || version == "0000" {
+			if _, err := mr.db.Exec("INSERT INTO migrations (version) VALUES (?)", version); err != nil {
+				return fmt.Errorf("failed to record migration %s: %w", version, err)
+			}
+		}
+	}
+
+	return nil
+}
+
+// GetAppliedMigrations returns a list of all applied migrations
+func (mr *MigrationRunner) GetAppliedMigrations() ([]Migration, error) {
+	var count int
+	err := mr.db.QueryRow("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='migrations'").Scan(&count)
+	if err != nil {
+		return nil, fmt.Errorf("failed to check migrations table: %w", err)
+	}
+
+	if count == 0 {
+		return []Migration{}, nil
+	}
+
+	rows, err := mr.db.Query("SELECT version, applied_at FROM migrations ORDER BY version")
+	if err != nil {
+		return nil, fmt.Errorf("failed to query migrations: %w", err)
+	}
+	defer rows.Close()
+
+	var migrations []Migration
+	for rows.Next() {
+		var m Migration
+		if err := rows.Scan(&m.Version, &m.AppliedAt); err != nil {
+			return nil, fmt.Errorf("failed to scan migration: %w", err)
+		}
+		m.Applied = true
+		migrations = append(migrations, m)
+	}
+
+	return migrations, nil
+}
+
+// GetAvailableMigrations returns all available migrations from embedded files
+func (mr *MigrationRunner) GetAvailableMigrations() ([]Migration, error) {
+	entries, err := mr.migrationFiles.ReadDir("sql/migrations")
+	if err != nil {
+		return nil, fmt.Errorf("failed to read migrations directory: %w", err)
+	}
+
+	migrationMap := make(map[string]*Migration)
+
+	for _, entry := range entries {
+		version := extractVersionFromFilename(entry.Name())
+		if version == "" {
+			continue
+		}
+
+		if migrationMap[version] == nil {
+			migrationMap[version] = &Migration{
+				Version: version,
+				Name:    extractNameFromFilename(entry.Name()),
+			}
+		}
+
+		content, err := mr.migrationFiles.ReadFile("sql/migrations/" + entry.Name())
+		if err != nil {
+			return nil, fmt.Errorf("failed to read migration file %s: %w", entry.Name(), err)
+		}
+
+		if strings.HasSuffix(entry.Name(), "_up.sql") {
+			migrationMap[version].UpSQL = string(content)
+		} else if strings.HasSuffix(entry.Name(), "_down.sql") {
+			migrationMap[version].DownSQL = string(content)
+		}
+	}
+
+	var migrations []Migration
+	for _, m := range migrationMap {
+		migrations = append(migrations, *m)
+	}
+	sort.Slice(migrations, func(i, j int) bool {
+		return migrations[i].Version < migrations[j].Version
+	})
+
+	return migrations, nil
+}
+
+// Rollback rolls back the last applied migration
+func (mr *MigrationRunner) Rollback() error {
+	var version string
+	err := mr.db.QueryRow("SELECT version FROM migrations ORDER BY version DESC LIMIT 1").Scan(&version)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return fmt.Errorf("no migrations to rollback")
+		}
+		return fmt.Errorf("failed to get last migration: %w", err)
+	}
+
+	entries, err := mr.migrationFiles.ReadDir("sql/migrations")
+	if err != nil {
+		return fmt.Errorf("failed to read migrations directory: %w", err)
+	}
+
+	var downContent []byte
+	for _, entry := range entries {
+		if strings.HasPrefix(entry.Name(), version) && strings.HasSuffix(entry.Name(), "_down.sql") {
+			downContent, err = mr.migrationFiles.ReadFile("sql/migrations/" + entry.Name())
+			if err != nil {
+				return fmt.Errorf("failed to read down migration: %w", err)
+			}
+			break
+		}
+	}
+
+	if downContent == nil {
+		return fmt.Errorf("down migration not found for version %s", version)
+	}
+
+	if _, err := mr.db.Exec(string(downContent)); err != nil {
+		return fmt.Errorf("failed to execute down migration: %w", err)
+	}
+
+	if _, err := mr.db.Exec("DELETE FROM migrations WHERE version = ?", version); err != nil {
+		return fmt.Errorf("failed to remove migration record: %w", err)
+	}
+
+	return nil
+}
+
+// extractVersionFromFilename extracts the 4-digit version from a migration filename
+func extractVersionFromFilename(filename string) string {
+	parts := strings.Split(filename, "_")
+	if len(parts) > 0 {
+		return parts[0]
+	}
+	return ""
+}
+
+func extractNameFromFilename(filename string) string {
+	parts := strings.Split(filename, "_")
+	if len(parts) < 3 {
+		return ""
+	}
+
+	name := strings.Join(parts[1:len(parts)-1], "_")
+	return strings.TrimSuffix(name, "_up")
+}

internal/utils/utils.go

···
+package utils
+
+import (
+	"os"
+	"strings"
+
+	"github.com/charmbracelet/log"
+)
+
+// Logger is the global application logger
+var Logger *log.Logger
+
+// NewLogger creates a new logger with the specified level and format
+func NewLogger(level string, format string) *log.Logger {
+	logger := log.New(os.Stderr)
+
+	switch strings.ToLower(level) {
+	case "debug":
+		logger.SetLevel(log.DebugLevel)
+	case "info":
+		logger.SetLevel(log.InfoLevel)
+	case "warn", "warning":
+		logger.SetLevel(log.WarnLevel)
+	case "error":
+		logger.SetLevel(log.ErrorLevel)
+	default:
+		logger.SetLevel(log.InfoLevel)
+	}
+
+	// Set format
+	if format == "json" {
+		logger.SetFormatter(log.JSONFormatter)
+	} else {
+		logger.SetFormatter(log.TextFormatter)
+		logger.SetReportTimestamp(true)
+	}
+
+	return logger
+}
+
+// GetLogger returns the global logger, creating a default one if it doesn't exist
+func GetLogger() *log.Logger {
+	if Logger == nil {
+		Logger = NewLogger("info", "text")
+	}
+	return Logger
+}

internal/utils/utils_test.go

···
+package utils
+
+import (
+	"bytes"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/charmbracelet/log"
+)
+
+func TestNewLogger(t *testing.T) {
+	t.Run("creates logger with info level", func(t *testing.T) {
+		logger := NewLogger("info", "text")
+		if logger == nil {
+			t.Fatal("Logger should not be nil")
+		}
+
+		if logger.GetLevel() != log.InfoLevel {
+			t.Errorf("Expected InfoLevel, got %v", logger.GetLevel())
+		}
+	})
+
+	t.Run("creates logger with debug level", func(t *testing.T) {
+		logger := NewLogger("debug", "text")
+		if logger.GetLevel() != log.DebugLevel {
+			t.Errorf("Expected DebugLevel, got %v", logger.GetLevel())
+		}
+	})
+
+	t.Run("creates logger with warn level", func(t *testing.T) {
+		logger := NewLogger("warn", "text")
+		if logger.GetLevel() != log.WarnLevel {
+			t.Errorf("Expected WarnLevel, got %v", logger.GetLevel())
+		}
+	})
+
+	t.Run("creates logger with warning level alias", func(t *testing.T) {
+		logger := NewLogger("warning", "text")
+		if logger.GetLevel() != log.WarnLevel {
+			t.Errorf("Expected WarnLevel, got %v", logger.GetLevel())
+		}
+	})
+
+	t.Run("creates logger with error level", func(t *testing.T) {
+		logger := NewLogger("error", "text")
+		if logger.GetLevel() != log.ErrorLevel {
+			t.Errorf("Expected ErrorLevel, got %v", logger.GetLevel())
+		}
+	})
+
+	t.Run("defaults to info level for invalid level", func(t *testing.T) {
+		logger := NewLogger("invalid", "text")
+		if logger.GetLevel() != log.InfoLevel {
+			t.Errorf("Expected InfoLevel for invalid input, got %v", logger.GetLevel())
+		}
+	})
+
+	t.Run("handles case insensitive levels", func(t *testing.T) {
+		logger := NewLogger("DEBUG", "text")
+		if logger.GetLevel() != log.DebugLevel {
+			t.Errorf("Expected DebugLevel for uppercase input, got %v", logger.GetLevel())
+		}
+	})
+
+	t.Run("creates logger with json format", func(t *testing.T) {
+		var buf bytes.Buffer
+		logger := NewLogger("info", "json")
+		logger.SetOutput(&buf)
+
+		logger.Info("test message")
+		output := buf.String()
+
+		if !strings.Contains(output, "{") || !strings.Contains(output, "}") {
+			t.Error("Expected JSON formatted output")
+		}
+	})
+
+	t.Run("creates logger with text format", func(t *testing.T) {
+		var buf bytes.Buffer
+		logger := NewLogger("info", "text")
+		logger.SetOutput(&buf)
+
+		logger.Info("test message")
+		output := buf.String()
+
+		if strings.Contains(output, "{") && strings.Contains(output, "}") {
+			t.Error("Expected text formatted output, not JSON")
+		}
+	})
+
+	t.Run("text format includes timestamp", func(t *testing.T) {
+		var buf bytes.Buffer
+		logger := NewLogger("info", "text")
+		logger.SetOutput(&buf)
+
+		logger.Info("test message")
+		output := buf.String()
+
+		if !strings.Contains(output, ":") {
+			t.Error("Expected timestamp in text format output")
+		}
+	})
+}
+
+func TestGetLogger(t *testing.T) {
+	t.Run("returns global logger when set", func(t *testing.T) {
+		originalLogger := Logger
+		defer func() { Logger = originalLogger }()
+
+		testLogger := NewLogger("debug", "json")
+		Logger = testLogger
+
+		retrieved := GetLogger()
+		if retrieved != testLogger {
+			t.Error("GetLogger should return the global logger")
+		}
+	})
+
+	t.Run("creates default logger when global is nil", func(t *testing.T) {
+		originalLogger := Logger
+		defer func() { Logger = originalLogger }()
+
+		Logger = nil
+
+		retrieved := GetLogger()
+		if retrieved == nil {
+			t.Fatal("GetLogger should create a default logger")
+		}
+
+		if retrieved.GetLevel() != log.InfoLevel {
+			t.Error("Default logger should have InfoLevel")
+		}
+
+		if Logger != retrieved {
+			t.Error("Global logger should be set after GetLogger call")
+		}
+	})
+
+	t.Run("subsequent calls return same logger", func(t *testing.T) {
+		originalLogger := Logger
+		defer func() { Logger = originalLogger }()
+
+		Logger = nil
+
+		logger1 := GetLogger()
+		logger2 := GetLogger()
+
+		if logger1 != logger2 {
+			t.Error("Subsequent GetLogger calls should return the same instance")
+		}
+	})
+}
+
+func TestLoggerIntegration(t *testing.T) {
+	t.Run("logger writes to stderr by default", func(t *testing.T) {
+		oldStderr := os.Stderr
+		r, w, _ := os.Pipe()
+		os.Stderr = w
+
+		logger := NewLogger("info", "text")
+		logger.Info("test message")
+
+		w.Close()
+		os.Stderr = oldStderr
+
+		var buf bytes.Buffer
+		buf.ReadFrom(r)
+		output := buf.String()
+
+		if !strings.Contains(output, "test message") {
+			t.Error("Logger should write to stderr by default")
+		}
+	})
+
+	t.Run("logger respects level filtering", func(t *testing.T) {
+		var buf bytes.Buffer
+		logger := NewLogger("error", "text")
+		logger.SetOutput(&buf)
+
+		logger.Debug("debug message")
+		logger.Info("info message")
+		logger.Warn("warn message")
+		logger.Error("error message")
+
+		output := buf.String()
+
+		if strings.Contains(output, "debug message") {
+			t.Error("Debug message should be filtered out at error level")
+		}
+		if strings.Contains(output, "info message") {
+			t.Error("Info message should be filtered out at error level")
+		}
+		if strings.Contains(output, "warn message") {
+			t.Error("Warn message should be filtered out at error level")
+		}
+		if !strings.Contains(output, "error message") {
+			t.Error("Error message should be included at error level")
+		}
+	})
+
+	t.Run("global logger persists between function calls", func(t *testing.T) {
+		originalLogger := Logger
+		defer func() { Logger = originalLogger }()
+
+		Logger = NewLogger("debug", "json")
+
+		retrieved := GetLogger()
+
+		if retrieved.GetLevel() != log.DebugLevel {
+			t.Error("Global logger settings should persist")
+		}
+	})
+}