feat: added albums table feat(wip): api service scaffold feat: crud commands for tasks

cmd/cli/commands.go

···
 	}
 
 	root.AddCommand(&cobra.Command{
-		Use:   "add [description]",
-		Short: "Add a new task",
-		Args:  cobra.MinimumNArgs(1),
+		Use:     "add [description]",
+		Short:   "Add a new task",
+		Aliases: []string{"create", "new"},
+		Args:    cobra.MinimumNArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			description := args[0]
-			fmt.Printf("Adding task: %s\n", description)
-			// TODO: Implement task creation
-			return nil
+			return handlers.CreateTask(cmd.Context(), args)
 		},
 	})
 
···
 		Short:   "List tasks",
 		Aliases: []string{"ls"},
 		RunE: func(cmd *cobra.Command, args []string) error {
-			fmt.Println("Listing tasks...")
-			// TODO: Implement task listing
+			return handlers.ListTasks(cmd.Context(), args)
+		},
+	})
+
+	root.AddCommand(&cobra.Command{
+		Use:   "view [task-id]",
+		Short: "View task by ID",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return handlers.ViewTask(cmd.Context(), args)
+		},
+	})
+
+	root.AddCommand(&cobra.Command{
+		Use:   "update [task-id] [options...]",
+		Short: "Update task properties",
+		Args:  cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return handlers.UpdateTask(cmd.Context(), args)
+		},
+	})
+
+	root.AddCommand(&cobra.Command{
+		Use:   "delete [task-id]",
+		Short: "Delete a task",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return handlers.DeleteTask(cmd.Context(), args)
+		},
+	})
+
+	root.AddCommand(&cobra.Command{
+		Use:     "projects",
+		Short:   "List projects",
+		Aliases: []string{"proj"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			fmt.Println("Listing projects...")
 			return nil
 		},
 	})
 
 	root.AddCommand(&cobra.Command{
-		Use:   "done [task-id]",
-		Short: "Mark task as completed",
-		Args:  cobra.ExactArgs(1),
+		Use:     "tags",
+		Short:   "List tags",
+		Aliases: []string{"t"},
 		RunE: func(cmd *cobra.Command, args []string) error {
-			taskID := args[0]
-			fmt.Printf("Marking task %s as done\n", taskID)
-			// TODO: Implement task completion
+			fmt.Println("Listing tags...")
 			return nil
+		},
+	})
+
+	root.AddCommand(&cobra.Command{
+		Use:     "contexts",
+		Short:   "List contexts (locations)",
+		Aliases: []string{"loc", "ctx", "locations"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			fmt.Println("Listing task contexts...")
+			return nil
+		},
+	})
+
+	root.AddCommand(&cobra.Command{
+		Use:     "done [task-id]",
+		Short:   "Mark task as completed",
+		Aliases: []string{"complete"},
+		Args:    cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return handlers.DoneTask(cmd.Context(), args)
 		},
 	})
 

cmd/handlers/tasks.go

···
+package handlers
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+	"github.com/stormlightlabs/noteleaf/internal/store"
+)
+
+// TaskHandler handles all task-related commands
+type TaskHandler struct {
+	db     *store.Database
+	config *store.Config
+	repos  *repo.Repositories
+}
+
+// NewTaskHandler creates a new task handler
+func NewTaskHandler() (*TaskHandler, error) {
+	db, err := store.NewDatabase()
+	if err != nil {
+		return nil, fmt.Errorf("failed to initialize database: %w", err)
+	}
+
+	config, err := store.LoadConfig()
+	if err != nil {
+		return nil, fmt.Errorf("failed to load configuration: %w", err)
+	}
+
+	repos := repo.NewRepositories(db.DB)
+
+	return &TaskHandler{
+		db:     db,
+		config: config,
+		repos:  repos,
+	}, nil
+}
+
+// Close cleans up resources
+func (h *TaskHandler) Close() error {
+	return h.db.Close()
+}
+
+// CreateTask creates a new task
+func CreateTask(ctx context.Context, args []string) error {
+	handler, err := NewTaskHandler()
+	if err != nil {
+		return fmt.Errorf("failed to initialize task handler: %w", err)
+	}
+	defer handler.Close()
+
+	return handler.createTask(ctx, args)
+}
+
+func (h *TaskHandler) createTask(ctx context.Context, args []string) error {
+	if len(args) < 1 {
+		return fmt.Errorf("task description required")
+	}
+
+	description := strings.Join(args, " ")
+	
+	task := &models.Task{
+		UUID:        uuid.New().String(),
+		Description: description,
+		Status:      "pending",
+	}
+
+	id, err := h.repos.Tasks.Create(ctx, task)
+	if err != nil {
+		return fmt.Errorf("failed to create task: %w", err)
+	}
+
+	fmt.Printf("Task created (ID: %d, UUID: %s): %s\n", id, task.UUID, task.Description)
+	return nil
+}
+
+// ListTasks lists all tasks with optional filtering
+func ListTasks(ctx context.Context, args []string) error {
+	handler, err := NewTaskHandler()
+	if err != nil {
+		return fmt.Errorf("failed to initialize task handler: %w", err)
+	}
+	defer handler.Close()
+
+	return handler.listTasks(ctx, args)
+}
+
+func (h *TaskHandler) listTasks(ctx context.Context, args []string) error {
+	opts := repo.TaskListOptions{}
+	
+	// Parse arguments for filtering
+	for i, arg := range args {
+		switch {
+		case arg == "--status" && i+1 < len(args):
+			opts.Status = args[i+1]
+		case arg == "--priority" && i+1 < len(args):
+			opts.Priority = args[i+1]
+		case arg == "--project" && i+1 < len(args):
+			opts.Project = args[i+1]
+		case arg == "--search" && i+1 < len(args):
+			opts.Search = args[i+1]
+		case arg == "--limit" && i+1 < len(args):
+			if limit, err := strconv.Atoi(args[i+1]); err == nil {
+				opts.Limit = limit
+			}
+		}
+	}
+
+	// Default to showing pending tasks only
+	if opts.Status == "" {
+		opts.Status = "pending"
+	}
+
+	tasks, err := h.repos.Tasks.List(ctx, opts)
+	if err != nil {
+		return fmt.Errorf("failed to list tasks: %w", err)
+	}
+
+	if len(tasks) == 0 {
+		fmt.Printf("No tasks found matching criteria\n")
+		return nil
+	}
+
+	fmt.Printf("Found %d task(s):\n\n", len(tasks))
+	for _, task := range tasks {
+		h.printTask(task)
+	}
+
+	return nil
+}
+
+// UpdateTask updates an existing task
+func UpdateTask(ctx context.Context, args []string) error {
+	handler, err := NewTaskHandler()
+	if err != nil {
+		return fmt.Errorf("failed to initialize task handler: %w", err)
+	}
+	defer handler.Close()
+
+	return handler.updateTask(ctx, args)
+}
+
+func (h *TaskHandler) updateTask(ctx context.Context, args []string) error {
+	if len(args) < 1 {
+		return fmt.Errorf("task ID required")
+	}
+
+	// Parse task ID (could be numeric ID or UUID)
+	taskID := args[0]
+	var task *models.Task
+	var err error
+
+	if id, parseErr := strconv.ParseInt(taskID, 10, 64); parseErr == nil {
+		// Numeric ID
+		task, err = h.repos.Tasks.Get(ctx, id)
+	} else {
+		// Assume UUID
+		task, err = h.repos.Tasks.GetByUUID(ctx, taskID)
+	}
+
+	if err != nil {
+		return fmt.Errorf("failed to find task: %w", err)
+	}
+
+	// Parse update arguments
+	for i := 1; i < len(args); i++ {
+		arg := args[i]
+		switch {
+		case arg == "--description" && i+1 < len(args):
+			task.Description = args[i+1]
+			i++
+		case arg == "--status" && i+1 < len(args):
+			task.Status = args[i+1]
+			i++
+		case arg == "--priority" && i+1 < len(args):
+			task.Priority = args[i+1]
+			i++
+		case arg == "--project" && i+1 < len(args):
+			task.Project = args[i+1]
+			i++
+		case arg == "--due" && i+1 < len(args):
+			if dueTime, err := time.Parse("2006-01-02", args[i+1]); err == nil {
+				task.Due = &dueTime
+			}
+			i++
+		case strings.HasPrefix(arg, "--add-tag="):
+			tag := strings.TrimPrefix(arg, "--add-tag=")
+			if !contains(task.Tags, tag) {
+				task.Tags = append(task.Tags, tag)
+			}
+		case strings.HasPrefix(arg, "--remove-tag="):
+			tag := strings.TrimPrefix(arg, "--remove-tag=")
+			task.Tags = removeString(task.Tags, tag)
+		}
+	}
+
+	err = h.repos.Tasks.Update(ctx, task)
+	if err != nil {
+		return fmt.Errorf("failed to update task: %w", err)
+	}
+
+	fmt.Printf("Task updated (ID: %d): %s\n", task.ID, task.Description)
+	return nil
+}
+
+// DeleteTask deletes a task
+func DeleteTask(ctx context.Context, args []string) error {
+	handler, err := NewTaskHandler()
+	if err != nil {
+		return fmt.Errorf("failed to initialize task handler: %w", err)
+	}
+	defer handler.Close()
+
+	return handler.deleteTask(ctx, args)
+}
+
+func (h *TaskHandler) deleteTask(ctx context.Context, args []string) error {
+	if len(args) < 1 {
+		return fmt.Errorf("task ID required")
+	}
+
+	taskID := args[0]
+	var task *models.Task
+	var err error
+
+	if id, parseErr := strconv.ParseInt(taskID, 10, 64); parseErr == nil {
+		// Get task first to show what's being deleted
+		task, err = h.repos.Tasks.Get(ctx, id)
+		if err != nil {
+			return fmt.Errorf("failed to find task: %w", err)
+		}
+		
+		err = h.repos.Tasks.Delete(ctx, id)
+	} else {
+		// Get by UUID first
+		task, err = h.repos.Tasks.GetByUUID(ctx, taskID)
+		if err != nil {
+			return fmt.Errorf("failed to find task: %w", err)
+		}
+		
+		err = h.repos.Tasks.Delete(ctx, task.ID)
+	}
+
+	if err != nil {
+		return fmt.Errorf("failed to delete task: %w", err)
+	}
+
+	fmt.Printf("Task deleted (ID: %d): %s\n", task.ID, task.Description)
+	return nil
+}
+
+// ViewTask displays a single task
+func ViewTask(ctx context.Context, args []string) error {
+	handler, err := NewTaskHandler()
+	if err != nil {
+		return fmt.Errorf("failed to initialize task handler: %w", err)
+	}
+	defer handler.Close()
+
+	return handler.viewTask(ctx, args)
+}
+
+func (h *TaskHandler) viewTask(ctx context.Context, args []string) error {
+	if len(args) < 1 {
+		return fmt.Errorf("task ID required")
+	}
+
+	taskID := args[0]
+	var task *models.Task
+	var err error
+
+	if id, parseErr := strconv.ParseInt(taskID, 10, 64); parseErr == nil {
+		task, err = h.repos.Tasks.Get(ctx, id)
+	} else {
+		task, err = h.repos.Tasks.GetByUUID(ctx, taskID)
+	}
+
+	if err != nil {
+		return fmt.Errorf("failed to find task: %w", err)
+	}
+
+	h.printTaskDetail(task)
+	return nil
+}
+
+// DoneTask marks a task as completed
+func DoneTask(ctx context.Context, args []string) error {
+	handler, err := NewTaskHandler()
+	if err != nil {
+		return fmt.Errorf("failed to initialize task handler: %w", err)
+	}
+	defer handler.Close()
+
+	return handler.doneTask(ctx, args)
+}
+
+func (h *TaskHandler) doneTask(ctx context.Context, args []string) error {
+	if len(args) < 1 {
+		return fmt.Errorf("task ID required")
+	}
+
+	taskID := args[0]
+	var task *models.Task
+	var err error
+
+	if id, parseErr := strconv.ParseInt(taskID, 10, 64); parseErr == nil {
+		task, err = h.repos.Tasks.Get(ctx, id)
+	} else {
+		task, err = h.repos.Tasks.GetByUUID(ctx, taskID)
+	}
+
+	if err != nil {
+		return fmt.Errorf("failed to find task: %w", err)
+	}
+
+	if task.Status == "completed" {
+		fmt.Printf("Task already completed: %s\n", task.Description)
+		return nil
+	}
+
+	now := time.Now()
+	task.Status = "completed"
+	task.End = &now
+
+	err = h.repos.Tasks.Update(ctx, task)
+	if err != nil {
+		return fmt.Errorf("failed to update task: %w", err)
+	}
+
+	fmt.Printf("Task completed (ID: %d): %s\n", task.ID, task.Description)
+	return nil
+}
+
+// Helper functions
+func (h *TaskHandler) printTask(task *models.Task) {
+	fmt.Printf("[%d] %s", task.ID, task.Description)
+	
+	if task.Status != "pending" {
+		fmt.Printf(" (%s)", task.Status)
+	}
+	
+	if task.Priority != "" {
+		fmt.Printf(" [%s]", task.Priority)
+	}
+	
+	if task.Project != "" {
+		fmt.Printf(" +%s", task.Project)
+	}
+	
+	if len(task.Tags) > 0 {
+		fmt.Printf(" @%s", strings.Join(task.Tags, " @"))
+	}
+	
+	if task.Due != nil {
+		fmt.Printf(" (due: %s)", task.Due.Format("2006-01-02"))
+	}
+	
+	fmt.Println()
+}
+
+func (h *TaskHandler) printTaskDetail(task *models.Task) {
+	fmt.Printf("Task ID: %d\n", task.ID)
+	fmt.Printf("UUID: %s\n", task.UUID)
+	fmt.Printf("Description: %s\n", task.Description)
+	fmt.Printf("Status: %s\n", task.Status)
+	
+	if task.Priority != "" {
+		fmt.Printf("Priority: %s\n", task.Priority)
+	}
+	
+	if task.Project != "" {
+		fmt.Printf("Project: %s\n", task.Project)
+	}
+	
+	if len(task.Tags) > 0 {
+		fmt.Printf("Tags: %s\n", strings.Join(task.Tags, ", "))
+	}
+	
+	if task.Due != nil {
+		fmt.Printf("Due: %s\n", task.Due.Format("2006-01-02 15:04"))
+	}
+	
+	fmt.Printf("Created: %s\n", task.Entry.Format("2006-01-02 15:04"))
+	fmt.Printf("Modified: %s\n", task.Modified.Format("2006-01-02 15:04"))
+	
+	if task.Start != nil {
+		fmt.Printf("Started: %s\n", task.Start.Format("2006-01-02 15:04"))
+	}
+	
+	if task.End != nil {
+		fmt.Printf("Completed: %s\n", task.End.Format("2006-01-02 15:04"))
+	}
+	
+	if len(task.Annotations) > 0 {
+		fmt.Printf("Annotations:\n")
+		for _, annotation := range task.Annotations {
+			fmt.Printf("  - %s\n", annotation)
+		}
+	}
+}
+
+func contains(slice []string, item string) bool {
+	for _, s := range slice {
+		if s == item {
+			return true
+		}
+	}
+	return false
+}
+
+func removeString(slice []string, item string) []string {
+	var result []string
+	for _, s := range slice {
+		if s != item {
+			result = append(result, s)
+		}
+	}
+	return result
+}

cmd/handlers/tasks_test.go

···
+package handlers
+
+import (
+	"context"
+	"os"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/stormlightlabs/noteleaf/internal/models"
+)
+
+func setupTaskTest(t *testing.T) (string, func()) {
+	tempDir, err := os.MkdirTemp("", "noteleaf-task-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)
+
+	cleanup := func() {
+		os.Setenv("XDG_CONFIG_HOME", oldConfigHome)
+		os.RemoveAll(tempDir)
+	}
+
+	ctx := context.Background()
+	err = Setup(ctx, []string{})
+	if err != nil {
+		cleanup()
+		t.Fatalf("Failed to setup database: %v", err)
+	}
+
+	return tempDir, cleanup
+}
+
+func TestTaskHandler_NewTaskHandler(t *testing.T) {
+	t.Run("creates handler successfully", func(t *testing.T) {
+		_, cleanup := setupTaskTest(t)
+		defer cleanup()
+
+		handler, err := NewTaskHandler()
+		if err != nil {
+			t.Errorf("NewTaskHandler failed: %v", err)
+		}
+		if handler == nil {
+			t.Error("Handler should not be nil")
+		}
+		defer handler.Close()
+
+		if handler.db == nil {
+			t.Error("Handler database should not be nil")
+		}
+		if handler.config == nil {
+			t.Error("Handler config should not be nil")
+		}
+		if handler.repos == nil {
+			t.Error("Handler repos should not be nil")
+		}
+	})
+
+	t.Run("handles database initialization error", func(t *testing.T) {
+		originalXDG := os.Getenv("XDG_CONFIG_HOME")
+		originalHome := os.Getenv("HOME")
+
+		if runtime.GOOS == "windows" {
+			originalAppData := os.Getenv("APPDATA")
+			os.Unsetenv("APPDATA")
+			defer os.Setenv("APPDATA", originalAppData)
+		} else {
+			os.Unsetenv("XDG_CONFIG_HOME")
+			os.Unsetenv("HOME")
+			defer os.Setenv("XDG_CONFIG_HOME", originalXDG)
+			defer os.Setenv("HOME", originalHome)
+		}
+
+		handler, err := NewTaskHandler()
+		if err == nil {
+			if handler != nil {
+				handler.Close()
+			}
+			t.Error("Expected error when database initialization fails")
+		}
+	})
+}
+
+func TestCreateTask(t *testing.T) {
+	_, cleanup := setupTaskTest(t)
+	defer cleanup()
+
+	t.Run("creates task successfully", func(t *testing.T) {
+		ctx := context.Background()
+		args := []string{"Buy groceries", "and", "cook dinner"}
+
+		err := CreateTask(ctx, args)
+		if err != nil {
+			t.Errorf("CreateTask failed: %v", err)
+		}
+
+		// Verify task was created by listing tasks
+		handler, err := NewTaskHandler()
+		if err != nil {
+			t.Fatalf("Failed to create handler: %v", err)
+		}
+		defer handler.Close()
+
+		tasks, err := handler.repos.Tasks.GetPending(ctx)
+		if err != nil {
+			t.Fatalf("Failed to get pending tasks: %v", err)
+		}
+
+		if len(tasks) != 1 {
+			t.Errorf("Expected 1 task, got %d", len(tasks))
+		}
+
+		task := tasks[0]
+		expectedDesc := "Buy groceries and cook dinner"
+		if task.Description != expectedDesc {
+			t.Errorf("Expected description '%s', got '%s'", expectedDesc, task.Description)
+		}
+
+		if task.Status != "pending" {
+			t.Errorf("Expected status 'pending', got '%s'", task.Status)
+		}
+
+		if task.UUID == "" {
+			t.Error("Task should have a UUID")
+		}
+	})
+
+	t.Run("fails with empty description", func(t *testing.T) {
+		ctx := context.Background()
+		args := []string{}
+
+		err := CreateTask(ctx, args)
+		if err == nil {
+			t.Error("Expected error for empty description")
+		}
+
+		if !strings.Contains(err.Error(), "task description required") {
+			t.Errorf("Expected error about required description, got: %v", err)
+		}
+	})
+}
+
+func TestListTasks(t *testing.T) {
+	_, cleanup := setupTaskTest(t)
+	defer cleanup()
+
+	ctx := context.Background()
+
+	// Create test tasks
+	handler, err := NewTaskHandler()
+	if err != nil {
+		t.Fatalf("Failed to create handler: %v", err)
+	}
+	defer handler.Close()
+
+	// Create a pending task
+	task1 := &models.Task{
+		UUID:        uuid.New().String(),
+		Description: "Task 1",
+		Status:      "pending",
+		Priority:    "A",
+		Project:     "work",
+	}
+	_, err = handler.repos.Tasks.Create(ctx, task1)
+	if err != nil {
+		t.Fatalf("Failed to create task1: %v", err)
+	}
+
+	// Create a completed task
+	task2 := &models.Task{
+		UUID:        uuid.New().String(),
+		Description: "Task 2",
+		Status:      "completed",
+	}
+	_, err = handler.repos.Tasks.Create(ctx, task2)
+	if err != nil {
+		t.Fatalf("Failed to create task2: %v", err)
+	}
+
+	t.Run("lists pending tasks by default", func(t *testing.T) {
+		args := []string{}
+
+		err := ListTasks(ctx, args)
+		if err != nil {
+			t.Errorf("ListTasks failed: %v", err)
+		}
+	})
+
+	t.Run("filters by status", func(t *testing.T) {
+		args := []string{"--status", "completed"}
+
+		err := ListTasks(ctx, args)
+		if err != nil {
+			t.Errorf("ListTasks with status filter failed: %v", err)
+		}
+	})
+
+	t.Run("filters by priority", func(t *testing.T) {
+		args := []string{"--priority", "A"}
+
+		err := ListTasks(ctx, args)
+		if err != nil {
+			t.Errorf("ListTasks with priority filter failed: %v", err)
+		}
+	})
+
+	t.Run("filters by project", func(t *testing.T) {
+		args := []string{"--project", "work"}
+
+		err := ListTasks(ctx, args)
+		if err != nil {
+			t.Errorf("ListTasks with project filter failed: %v", err)
+		}
+	})
+
+	t.Run("searches tasks", func(t *testing.T) {
+		args := []string{"--search", "Task"}
+
+		err := ListTasks(ctx, args)
+		if err != nil {
+			t.Errorf("ListTasks with search failed: %v", err)
+		}
+	})
+
+	t.Run("limits results", func(t *testing.T) {
+		args := []string{"--limit", "1"}
+
+		err := ListTasks(ctx, args)
+		if err != nil {
+			t.Errorf("ListTasks with limit failed: %v", err)
+		}
+	})
+}
+
+func TestUpdateTask(t *testing.T) {
+	_, cleanup := setupTaskTest(t)
+	defer cleanup()
+
+	ctx := context.Background()
+
+	// Create test task
+	handler, err := NewTaskHandler()
+	if err != nil {
+		t.Fatalf("Failed to create handler: %v", err)
+	}
+	defer handler.Close()
+
+	task := &models.Task{
+		UUID:        uuid.New().String(),
+		Description: "Original description",
+		Status:      "pending",
+	}
+	id, err := handler.repos.Tasks.Create(ctx, task)
+	if err != nil {
+		t.Fatalf("Failed to create task: %v", err)
+	}
+
+	t.Run("updates task by ID", func(t *testing.T) {
+		args := []string{strconv.FormatInt(id, 10), "--description", "Updated description"}
+
+		err := UpdateTask(ctx, args)
+		if err != nil {
+			t.Errorf("UpdateTask failed: %v", err)
+		}
+
+		// Verify update
+		updatedTask, err := handler.repos.Tasks.Get(ctx, id)
+		if err != nil {
+			t.Fatalf("Failed to get updated task: %v", err)
+		}
+
+		if updatedTask.Description != "Updated description" {
+			t.Errorf("Expected description 'Updated description', got '%s'", updatedTask.Description)
+		}
+	})
+
+	t.Run("updates task by UUID", func(t *testing.T) {
+		args := []string{task.UUID, "--status", "completed"}
+
+		err := UpdateTask(ctx, args)
+		if err != nil {
+			t.Errorf("UpdateTask by UUID failed: %v", err)
+		}
+
+		// Verify update
+		updatedTask, err := handler.repos.Tasks.GetByUUID(ctx, task.UUID)
+		if err != nil {
+			t.Fatalf("Failed to get updated task by UUID: %v", err)
+		}
+
+		if updatedTask.Status != "completed" {
+			t.Errorf("Expected status 'completed', got '%s'", updatedTask.Status)
+		}
+	})
+
+	t.Run("updates multiple fields", func(t *testing.T) {
+		args := []string{
+			strconv.FormatInt(id, 10),
+			"--description", "Multiple updates",
+			"--priority", "B",
+			"--project", "test",
+			"--due", "2024-12-31",
+		}
+
+		err := UpdateTask(ctx, args)
+		if err != nil {
+			t.Errorf("UpdateTask with multiple fields failed: %v", err)
+		}
+
+		// Verify all updates
+		updatedTask, err := handler.repos.Tasks.Get(ctx, id)
+		if err != nil {
+			t.Fatalf("Failed to get updated task: %v", err)
+		}
+
+		if updatedTask.Description != "Multiple updates" {
+			t.Errorf("Expected description 'Multiple updates', got '%s'", updatedTask.Description)
+		}
+		if updatedTask.Priority != "B" {
+			t.Errorf("Expected priority 'B', got '%s'", updatedTask.Priority)
+		}
+		if updatedTask.Project != "test" {
+			t.Errorf("Expected project 'test', got '%s'", updatedTask.Project)
+		}
+		if updatedTask.Due == nil {
+			t.Error("Expected due date to be set")
+		}
+	})
+
+	t.Run("adds and removes tags", func(t *testing.T) {
+		args := []string{
+			strconv.FormatInt(id, 10),
+			"--add-tag=work",
+			"--add-tag=urgent",
+		}
+
+		err := UpdateTask(ctx, args)
+		if err != nil {
+			t.Errorf("UpdateTask with add tags failed: %v", err)
+		}
+
+		// Verify tags added
+		updatedTask, err := handler.repos.Tasks.Get(ctx, id)
+		if err != nil {
+			t.Fatalf("Failed to get updated task: %v", err)
+		}
+
+		if len(updatedTask.Tags) != 2 {
+			t.Errorf("Expected 2 tags, got %d", len(updatedTask.Tags))
+		}
+
+		// Remove a tag
+		args = []string{
+			strconv.FormatInt(id, 10),
+			"--remove-tag=urgent",
+		}
+
+		err = UpdateTask(ctx, args)
+		if err != nil {
+			t.Errorf("UpdateTask with remove tag failed: %v", err)
+		}
+
+		// Verify tag removed
+		updatedTask, err = handler.repos.Tasks.Get(ctx, id)
+		if err != nil {
+			t.Fatalf("Failed to get updated task: %v", err)
+		}
+
+		if len(updatedTask.Tags) != 1 {
+			t.Errorf("Expected 1 tag after removal, got %d", len(updatedTask.Tags))
+		}
+
+		if updatedTask.Tags[0] != "work" {
+			t.Errorf("Expected remaining tag 'work', got '%s'", updatedTask.Tags[0])
+		}
+	})
+
+	t.Run("fails with missing task ID", func(t *testing.T) {
+		args := []string{}
+
+		err := UpdateTask(ctx, args)
+		if err == nil {
+			t.Error("Expected error for missing task ID")
+		}
+
+		if !strings.Contains(err.Error(), "task ID required") {
+			t.Errorf("Expected error about required task ID, got: %v", err)
+		}
+	})
+
+	t.Run("fails with invalid task ID", func(t *testing.T) {
+		args := []string{"99999", "--description", "test"}
+
+		err := UpdateTask(ctx, args)
+		if err == nil {
+			t.Error("Expected error for invalid task ID")
+		}
+
+		if !strings.Contains(err.Error(), "failed to find task") {
+			t.Errorf("Expected error about task not found, got: %v", err)
+		}
+	})
+}
+
+func TestDeleteTask(t *testing.T) {
+	_, cleanup := setupTaskTest(t)
+	defer cleanup()
+
+	ctx := context.Background()
+
+	// Create test task
+	handler, err := NewTaskHandler()
+	if err != nil {
+		t.Fatalf("Failed to create handler: %v", err)
+	}
+	defer handler.Close()
+
+	task := &models.Task{
+		UUID:        uuid.New().String(),
+		Description: "Task to delete",
+		Status:      "pending",
+	}
+	id, err := handler.repos.Tasks.Create(ctx, task)
+	if err != nil {
+		t.Fatalf("Failed to create task: %v", err)
+	}
+
+	t.Run("deletes task by ID", func(t *testing.T) {
+		args := []string{strconv.FormatInt(id, 10)}
+
+		err := DeleteTask(ctx, args)
+		if err != nil {
+			t.Errorf("DeleteTask failed: %v", err)
+		}
+
+		// Verify task was deleted
+		_, err = handler.repos.Tasks.Get(ctx, id)
+		if err == nil {
+			t.Error("Expected error when getting deleted task")
+		}
+	})
+
+	t.Run("deletes task by UUID", func(t *testing.T) {
+		// Create another task to delete by UUID
+		task2 := &models.Task{
+			UUID:        uuid.New().String(),
+			Description: "Task to delete by UUID",
+			Status:      "pending",
+		}
+		_, err := handler.repos.Tasks.Create(ctx, task2)
+		if err != nil {
+			t.Fatalf("Failed to create task2: %v", err)
+		}
+
+		args := []string{task2.UUID}
+
+		err = DeleteTask(ctx, args)
+		if err != nil {
+			t.Errorf("DeleteTask by UUID failed: %v", err)
+		}
+
+		// Verify task was deleted
+		_, err = handler.repos.Tasks.GetByUUID(ctx, task2.UUID)
+		if err == nil {
+			t.Error("Expected error when getting deleted task by UUID")
+		}
+	})
+
+	t.Run("fails with missing task ID", func(t *testing.T) {
+		args := []string{}
+
+		err := DeleteTask(ctx, args)
+		if err == nil {
+			t.Error("Expected error for missing task ID")
+		}
+
+		if !strings.Contains(err.Error(), "task ID required") {
+			t.Errorf("Expected error about required task ID, got: %v", err)
+		}
+	})
+
+	t.Run("fails with invalid task ID", func(t *testing.T) {
+		args := []string{"99999"}
+
+		err := DeleteTask(ctx, args)
+		if err == nil {
+			t.Error("Expected error for invalid task ID")
+		}
+
+		if !strings.Contains(err.Error(), "failed to find task") {
+			t.Errorf("Expected error about task not found, got: %v", err)
+		}
+	})
+}
+
+func TestViewTask(t *testing.T) {
+	_, cleanup := setupTaskTest(t)
+	defer cleanup()
+
+	ctx := context.Background()
+
+	// Create test task
+	handler, err := NewTaskHandler()
+	if err != nil {
+		t.Fatalf("Failed to create handler: %v", err)
+	}
+	defer handler.Close()
+
+	now := time.Now()
+	task := &models.Task{
+		UUID:        uuid.New().String(),
+		Description: "Task to view",
+		Status:      "pending",
+		Priority:    "A",
+		Project:     "test",
+		Tags:        []string{"work", "important"},
+		Entry:       now,
+		Modified:    now,
+	}
+	id, err := handler.repos.Tasks.Create(ctx, task)
+	if err != nil {
+		t.Fatalf("Failed to create task: %v", err)
+	}
+
+	t.Run("views task by ID", func(t *testing.T) {
+		args := []string{strconv.FormatInt(id, 10)}
+
+		err := ViewTask(ctx, args)
+		if err != nil {
+			t.Errorf("ViewTask failed: %v", err)
+		}
+	})
+
+	t.Run("views task by UUID", func(t *testing.T) {
+		args := []string{task.UUID}
+
+		err := ViewTask(ctx, args)
+		if err != nil {
+			t.Errorf("ViewTask by UUID failed: %v", err)
+		}
+	})
+
+	t.Run("fails with missing task ID", func(t *testing.T) {
+		args := []string{}
+
+		err := ViewTask(ctx, args)
+		if err == nil {
+			t.Error("Expected error for missing task ID")
+		}
+
+		if !strings.Contains(err.Error(), "task ID required") {
+			t.Errorf("Expected error about required task ID, got: %v", err)
+		}
+	})
+
+	t.Run("fails with invalid task ID", func(t *testing.T) {
+		args := []string{"99999"}
+
+		err := ViewTask(ctx, args)
+		if err == nil {
+			t.Error("Expected error for invalid task ID")
+		}
+
+		if !strings.Contains(err.Error(), "failed to find task") {
+			t.Errorf("Expected error about task not found, got: %v", err)
+		}
+	})
+}
+
+func TestDoneTask(t *testing.T) {
+	_, cleanup := setupTaskTest(t)
+	defer cleanup()
+
+	ctx := context.Background()
+
+	// Create test task
+	handler, err := NewTaskHandler()
+	if err != nil {
+		t.Fatalf("Failed to create handler: %v", err)
+	}
+	defer handler.Close()
+
+	task := &models.Task{
+		UUID:        uuid.New().String(),
+		Description: "Task to complete",
+		Status:      "pending",
+	}
+	id, err := handler.repos.Tasks.Create(ctx, task)
+	if err != nil {
+		t.Fatalf("Failed to create task: %v", err)
+	}
+
+	t.Run("marks task as done by ID", func(t *testing.T) {
+		args := []string{strconv.FormatInt(id, 10)}
+
+		err := DoneTask(ctx, args)
+		if err != nil {
+			t.Errorf("DoneTask failed: %v", err)
+		}
+
+		// Verify task was marked as completed
+		completedTask, err := handler.repos.Tasks.Get(ctx, id)
+		if err != nil {
+			t.Fatalf("Failed to get completed task: %v", err)
+		}
+
+		if completedTask.Status != "completed" {
+			t.Errorf("Expected status 'completed', got '%s'", completedTask.Status)
+		}
+
+		if completedTask.End == nil {
+			t.Error("Expected end time to be set")
+		}
+	})
+
+	t.Run("handles already completed task", func(t *testing.T) {
+		// Create another task and complete it first
+		task2 := &models.Task{
+			UUID:        uuid.New().String(),
+			Description: "Already completed task",
+			Status:      "completed",
+		}
+		id2, err := handler.repos.Tasks.Create(ctx, task2)
+		if err != nil {
+			t.Fatalf("Failed to create task2: %v", err)
+		}
+
+		args := []string{strconv.FormatInt(id2, 10)}
+
+		err = DoneTask(ctx, args)
+		if err != nil {
+			t.Errorf("DoneTask on completed task failed: %v", err)
+		}
+	})
+
+	t.Run("marks task as done by UUID", func(t *testing.T) {
+		// Create another pending task
+		task3 := &models.Task{
+			UUID:        uuid.New().String(),
+			Description: "Task to complete by UUID",
+			Status:      "pending",
+		}
+		_, err := handler.repos.Tasks.Create(ctx, task3)
+		if err != nil {
+			t.Fatalf("Failed to create task3: %v", err)
+		}
+
+		args := []string{task3.UUID}
+
+		err = DoneTask(ctx, args)
+		if err != nil {
+			t.Errorf("DoneTask by UUID failed: %v", err)
+		}
+
+		// Verify task was marked as completed
+		completedTask, err := handler.repos.Tasks.GetByUUID(ctx, task3.UUID)
+		if err != nil {
+			t.Fatalf("Failed to get completed task by UUID: %v", err)
+		}
+
+		if completedTask.Status != "completed" {
+			t.Errorf("Expected status 'completed', got '%s'", completedTask.Status)
+		}
+
+		if completedTask.End == nil {
+			t.Error("Expected end time to be set")
+		}
+	})
+
+	t.Run("fails with missing task ID", func(t *testing.T) {
+		args := []string{}
+
+		err := DoneTask(ctx, args)
+		if err == nil {
+			t.Error("Expected error for missing task ID")
+		}
+
+		if !strings.Contains(err.Error(), "task ID required") {
+			t.Errorf("Expected error about required task ID, got: %v", err)
+		}
+	})
+
+	t.Run("fails with invalid task ID", func(t *testing.T) {
+		args := []string{"99999"}
+
+		err := DoneTask(ctx, args)
+		if err == nil {
+			t.Error("Expected error for invalid task ID")
+		}
+
+		if !strings.Contains(err.Error(), "failed to find task") {
+			t.Errorf("Expected error about task not found, got: %v", err)
+		}
+	})
+}
+
+func TestHelperFunctions(t *testing.T) {
+	t.Run("contains function", func(t *testing.T) {
+		slice := []string{"a", "b", "c"}
+
+		if !contains(slice, "b") {
+			t.Error("Expected contains to return true for existing item")
+		}
+
+		if contains(slice, "d") {
+			t.Error("Expected contains to return false for non-existing item")
+		}
+	})
+
+	t.Run("removeString function", func(t *testing.T) {
+		slice := []string{"a", "b", "c", "b"}
+		result := removeString(slice, "b")
+
+		if len(result) != 2 {
+			t.Errorf("Expected 2 items after removing 'b', got %d", len(result))
+		}
+
+		if contains(result, "b") {
+			t.Error("Expected 'b' to be removed from slice")
+		}
+
+		if !contains(result, "a") || !contains(result, "c") {
+			t.Error("Expected 'a' and 'c' to remain in slice")
+		}
+	})
+}
+
+func TestPrintFunctions(t *testing.T) {
+	_, cleanup := setupTaskTest(t)
+	defer cleanup()
+
+	handler, err := NewTaskHandler()
+	if err != nil {
+		t.Fatalf("Failed to create handler: %v", err)
+	}
+	defer handler.Close()
+
+	now := time.Now()
+	due := now.Add(24 * time.Hour)
+
+	task := &models.Task{
+		ID:          1,
+		UUID:        uuid.New().String(),
+		Description: "Test task",
+		Status:      "pending",
+		Priority:    "A",
+		Project:     "test",
+		Tags:        []string{"work", "urgent"},
+		Due:         &due,
+		Entry:       now,
+		Modified:    now,
+	}
+
+	// Test that print functions don't panic
+	t.Run("printTask doesn't panic", func(t *testing.T) {
+		defer func() {
+			if r := recover(); r != nil {
+				t.Errorf("printTask panicked: %v", r)
+			}
+		}()
+
+		handler.printTask(task)
+	})
+
+	t.Run("printTaskDetail doesn't panic", func(t *testing.T) {
+		defer func() {
+			if r := recover(); r != nil {
+				t.Errorf("printTaskDetail panicked: %v", r)
+			}
+		}()
+
+		handler.printTaskDetail(task)
+	})
+}

internal/models/models.go

···
 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)
 }
···
 	Created  time.Time `json:"created"`
 	Modified time.Time `json:"modified"`
 	FilePath string    `json:"file_path,omitempty"`
+}
+
+// Album represents a music album
+type Album struct {
+	ID              int64     `json:"id"`
+	Title           string    `json:"title"`
+	Artist          string    `json:"artist"`
+	Genre           string    `json:"genre,omitempty"`
+	ReleaseYear     int       `json:"release_year,omitempty"`
+	Tracks          []string  `json:"tracks,omitempty"`
+	DurationSeconds int       `json:"duration_seconds,omitempty"`
+	AlbumArtPath    string    `json:"album_art_path,omitempty"`
+	Rating          int       `json:"rating,omitempty"`
+	Created         time.Time `json:"created"`
+	Modified        time.Time `json:"modified"`
 }
 
 // MarshalTags converts tags slice to JSON string for database storage
···
 func (n *Note) SetCreatedAt(time time.Time) { n.Created = time }
 func (n *Note) GetUpdatedAt() time.Time     { return n.Modified }
 func (n *Note) SetUpdatedAt(time time.Time) { n.Modified = time }
+
+// MarshalTracks converts tracks slice to JSON string for database storage
+func (a *Album) MarshalTracks() (string, error) {
+	if len(a.Tracks) == 0 {
+		return "", nil
+	}
+	data, err := json.Marshal(a.Tracks)
+	return string(data), err
+}
+
+// UnmarshalTracks converts JSON string from database to tracks slice
+func (a *Album) UnmarshalTracks(data string) error {
+	if data == "" {
+		a.Tracks = nil
+		return nil
+	}
+	return json.Unmarshal([]byte(data), &a.Tracks)
+}
+
+// HasRating returns true if the album has a rating set
+func (a *Album) HasRating() bool {
+	return a.Rating > 0
+}
+
+// IsValidRating returns true if the rating is between 1 and 5
+func (a *Album) IsValidRating() bool {
+	return a.Rating >= 1 && a.Rating <= 5
+}
+
+func (a *Album) GetID() int64                { return a.ID }
+func (a *Album) SetID(id int64)              { a.ID = id }
+func (a *Album) GetTableName() string        { return "albums" }
+func (a *Album) GetCreatedAt() time.Time     { return a.Created }
+func (a *Album) SetCreatedAt(time time.Time) { a.Created = time }
+func (a *Album) GetUpdatedAt() time.Time     { return a.Modified }
+func (a *Album) SetUpdatedAt(time time.Time) { a.Modified = time }

internal/models/models_test.go

···
 		})
 	})
 
+	t.Run("Album Model", func(t *testing.T) {
+		t.Run("Model Interface Implementation", func(t *testing.T) {
+			album := &Album{
+				ID:      1,
+				Title:   "Test Album",
+				Artist:  "Test Artist",
+				Created: time.Now(),
+			}
+
+			if album.GetID() != 1 {
+				t.Errorf("Expected ID 1, got %d", album.GetID())
+			}
+
+			album.SetID(2)
+			if album.GetID() != 2 {
+				t.Errorf("Expected ID 2 after SetID, got %d", album.GetID())
+			}
+
+			if album.GetTableName() != "albums" {
+				t.Errorf("Expected table name 'albums', got '%s'", album.GetTableName())
+			}
+
+			createdAt := time.Now()
+			album.SetCreatedAt(createdAt)
+			if !album.GetCreatedAt().Equal(createdAt) {
+				t.Errorf("Expected created at %v, got %v", createdAt, album.GetCreatedAt())
+			}
+
+			updatedAt := time.Now().Add(time.Hour)
+			album.SetUpdatedAt(updatedAt)
+			if !album.GetUpdatedAt().Equal(updatedAt) {
+				t.Errorf("Expected updated at %v, got %v", updatedAt, album.GetUpdatedAt())
+			}
+		})
+
+		t.Run("Rating Methods", func(t *testing.T) {
+			album := &Album{}
+
+			if album.HasRating() {
+				t.Error("Album with zero rating should return false for HasRating")
+			}
+
+			if album.IsValidRating() {
+				t.Error("Album with zero rating should return false for IsValidRating")
+			}
+
+			album.Rating = 3
+			if !album.HasRating() {
+				t.Error("Album with rating should return true for HasRating")
+			}
+
+			if !album.IsValidRating() {
+				t.Error("Album with valid rating should return true for IsValidRating")
+			}
+
+			testCases := []struct {
+				rating  int
+				isValid bool
+			}{
+				{0, false},
+				{1, true},
+				{3, true},
+				{5, true},
+				{6, false},
+				{-1, false},
+			}
+
+			for _, tc := range testCases {
+				album.Rating = tc.rating
+				if album.IsValidRating() != tc.isValid {
+					t.Errorf("Rating %d: expected IsValidRating %v, got %v", tc.rating, tc.isValid, album.IsValidRating())
+				}
+			}
+		})
+
+		t.Run("Tracks Marshaling", func(t *testing.T) {
+			album := &Album{}
+
+			result, err := album.MarshalTracks()
+			if err != nil {
+				t.Fatalf("MarshalTracks failed: %v", err)
+			}
+			if result != "" {
+				t.Errorf("Expected empty string for empty tracks, got '%s'", result)
+			}
+
+			album.Tracks = []string{"Track 1", "Track 2", "Interlude"}
+			result, err = album.MarshalTracks()
+			if err != nil {
+				t.Fatalf("MarshalTracks failed: %v", err)
+			}
+
+			expected := `["Track 1","Track 2","Interlude"]`
+			if result != expected {
+				t.Errorf("Expected %s, got %s", expected, result)
+			}
+
+			newAlbum := &Album{}
+			err = newAlbum.UnmarshalTracks(result)
+			if err != nil {
+				t.Fatalf("UnmarshalTracks failed: %v", err)
+			}
+
+			if len(newAlbum.Tracks) != 3 {
+				t.Errorf("Expected 3 tracks, got %d", len(newAlbum.Tracks))
+			}
+			if newAlbum.Tracks[0] != "Track 1" || newAlbum.Tracks[1] != "Track 2" || newAlbum.Tracks[2] != "Interlude" {
+				t.Errorf("Tracks not unmarshaled correctly: %v", newAlbum.Tracks)
+			}
+
+			emptyAlbum := &Album{}
+			err = emptyAlbum.UnmarshalTracks("")
+			if err != nil {
+				t.Fatalf("UnmarshalTracks with empty string failed: %v", err)
+			}
+			if emptyAlbum.Tracks != nil {
+				t.Error("Expected nil tracks for empty string")
+			}
+		})
+
+		t.Run("JSON Marshaling", func(t *testing.T) {
+			now := time.Now()
+			modified := now.Add(time.Hour)
+			album := &Album{
+				ID:              1,
+				Title:           "Test Album",
+				Artist:          "Test Artist",
+				Genre:           "Rock",
+				ReleaseYear:     2023,
+				Tracks:          []string{"Track 1", "Track 2"},
+				DurationSeconds: 3600,
+				AlbumArtPath:    "/path/to/art.jpg",
+				Rating:          4,
+				Created:         now,
+				Modified:        modified,
+			}
+
+			data, err := json.Marshal(album)
+			if err != nil {
+				t.Fatalf("JSON marshal failed: %v", err)
+			}
+
+			var unmarshaled Album
+			err = json.Unmarshal(data, &unmarshaled)
+			if err != nil {
+				t.Fatalf("JSON unmarshal failed: %v", err)
+			}
+
+			if unmarshaled.ID != album.ID {
+				t.Errorf("Expected ID %d, got %d", album.ID, unmarshaled.ID)
+			}
+			if unmarshaled.Title != album.Title {
+				t.Errorf("Expected title %s, got %s", album.Title, unmarshaled.Title)
+			}
+			if unmarshaled.Artist != album.Artist {
+				t.Errorf("Expected artist %s, got %s", album.Artist, unmarshaled.Artist)
+			}
+			if unmarshaled.Genre != album.Genre {
+				t.Errorf("Expected genre %s, got %s", album.Genre, unmarshaled.Genre)
+			}
+			if unmarshaled.ReleaseYear != album.ReleaseYear {
+				t.Errorf("Expected release year %d, got %d", album.ReleaseYear, unmarshaled.ReleaseYear)
+			}
+			if unmarshaled.DurationSeconds != album.DurationSeconds {
+				t.Errorf("Expected duration %d, got %d", album.DurationSeconds, unmarshaled.DurationSeconds)
+			}
+			if unmarshaled.Rating != album.Rating {
+				t.Errorf("Expected rating %d, got %d", album.Rating, unmarshaled.Rating)
+			}
+		})
+	})
+
 	t.Run("Interface Implementations", func(t *testing.T) {
 		t.Run("All models implement Model interface", func(t *testing.T) {
 			var models []Model
···
 			tvShow := &TVShow{}
 			book := &Book{}
 			note := &Note{}
+			album := &Album{}
 
-			models = append(models, task, movie, tvShow, book, note)
+			models = append(models, task, movie, tvShow, book, note, album)
 
-			if len(models) != 5 {
-				t.Errorf("Expected 5 models, got %d", len(models))
+			if len(models) != 6 {
+				t.Errorf("Expected 6 models, got %d", len(models))
 			}
 
 			// Test that all models have the required methods

internal/services/services.go

···
+// Movies & TV: Rotten Tomatoes with colly
+//
+// Music: Album of the Year with chromedp
+//
+// Books: OpenLibrary API
+package services
+
+import (
+	"context"
+
+	"github.com/stormlightlabs/noteleaf/internal/models"
+)
+
+// APIService defines the contract for API interactions
+type APIService interface {
+	Get(ctx context.Context, id string) (*models.Model, error)
+	Search(ctx context.Context, page, limit int) ([]*models.Model, error)
+	Check(ctx context.Context) error
+	Close() error
+}

internal/services/services_test.go

···
+package services

internal/store/sql/migrations/0003_create_albums_table_down.sql

···
+DROP TRIGGER IF EXISTS update_albums_modified;
+DROP TABLE IF EXISTS albums;

internal/store/sql/migrations/0003_create_albums_table_up.sql

···
+CREATE TABLE IF NOT EXISTS albums (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    title TEXT NOT NULL,
+    artist TEXT NOT NULL,
+    genre TEXT,
+    release_year INTEGER,
+    tracks TEXT, -- JSON array of track names
+    duration_seconds INTEGER,
+    album_art_path TEXT,
+    rating INTEGER CHECK (rating >= 1 AND rating <= 5),
+    created DATETIME DEFAULT CURRENT_TIMESTAMP,
+    modified DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TRIGGER update_albums_modified
+    AFTER UPDATE ON albums
+    FOR EACH ROW
+    BEGIN
+        UPDATE albums SET modified = CURRENT_TIMESTAMP WHERE id = NEW.id;
+    END;