feat: movie & tv handlers

internal/handlers/movies.go

···
+package handlers
+
+import (
+	"context"
+	"fmt"
+	"slices"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+	"github.com/stormlightlabs/noteleaf/internal/services"
+	"github.com/stormlightlabs/noteleaf/internal/store"
+)
+
+// MovieHandler handles all movie-related commands
+type MovieHandler struct {
+	db      *store.Database
+	config  *store.Config
+	repos   *repo.Repositories
+	service *services.MovieService
+}
+
+// NewMovieHandler creates a new movie handler
+func NewMovieHandler() (*MovieHandler, 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)
+	service := services.NewMovieService()
+
+	return &MovieHandler{
+		db:      db,
+		config:  config,
+		repos:   repos,
+		service: service,
+	}, nil
+}
+
+// Close cleans up resources
+func (h *MovieHandler) Close() error {
+	if err := h.service.Close(); err != nil {
+		return fmt.Errorf("failed to close service: %w", err)
+	}
+	return h.db.Close()
+}
+
+// SearchAndAdd searches for movies and allows user to select and add to queue
+func (h *MovieHandler) SearchAndAdd(ctx context.Context, query string, interactive bool) error {
+	if query == "" {
+		return fmt.Errorf("search query cannot be empty")
+	}
+
+	fmt.Printf("Searching for movies: %s\n", query)
+	fmt.Print("Loading...")
+
+	results, err := h.service.Search(ctx, query, 1, 5)
+	if err != nil {
+		fmt.Println(" failed!")
+		return fmt.Errorf("search failed: %w", err)
+	}
+
+	fmt.Println(" done!")
+	fmt.Println()
+
+	if len(results) == 0 {
+		fmt.Println("No movies found.")
+		return nil
+	}
+
+	fmt.Printf("Found %d result(s):\n\n", len(results))
+	for i, result := range results {
+		if movie, ok := (*result).(*models.Movie); ok {
+			fmt.Printf("[%d] %s", i+1, movie.Title)
+			if movie.Year > 0 {
+				fmt.Printf(" (%d)", movie.Year)
+			}
+			if movie.Rating > 0 {
+				fmt.Printf(" ★%.1f", movie.Rating)
+			}
+			if movie.Notes != "" {
+				notes := movie.Notes
+				if len(notes) > 80 {
+					notes = notes[:77] + "..."
+				}
+				fmt.Printf("\n    %s", notes)
+			}
+			fmt.Println()
+		}
+	}
+
+	fmt.Print("\nEnter number to add (1-", len(results), "), or 0 to cancel: ")
+
+	var choice int
+	if _, err := fmt.Scanf("%d", &choice); err != nil {
+		return fmt.Errorf("invalid input")
+	}
+
+	if choice == 0 {
+		fmt.Println("Cancelled.")
+		return nil
+	}
+
+	if choice < 1 || choice > len(results) {
+		return fmt.Errorf("invalid choice: %d", choice)
+	}
+
+	selectedMovie, ok := (*results[choice-1]).(*models.Movie)
+	if !ok {
+		return fmt.Errorf("error processing selected movie")
+	}
+
+	if _, err := h.repos.Movies.Create(ctx, selectedMovie); err != nil {
+		return fmt.Errorf("failed to add movie: %w", err)
+	}
+
+	fmt.Printf("✓ Added movie: %s", selectedMovie.Title)
+	if selectedMovie.Year > 0 {
+		fmt.Printf(" (%d)", selectedMovie.Year)
+	}
+	fmt.Println()
+
+	return nil
+}
+
+// List movies with status filtering
+func (h *MovieHandler) List(ctx context.Context, status string) error {
+	var movies []*models.Movie
+	var err error
+
+	switch status {
+	case "":
+		movies, err = h.repos.Movies.List(ctx, repo.MovieListOptions{})
+		if err != nil {
+			return fmt.Errorf("failed to list movies: %w", err)
+		}
+	case "queued":
+		movies, err = h.repos.Movies.GetQueued(ctx)
+		if err != nil {
+			return fmt.Errorf("failed to get queued movies: %w", err)
+		}
+	case "watched":
+		movies, err = h.repos.Movies.GetWatched(ctx)
+		if err != nil {
+			return fmt.Errorf("failed to get watched movies: %w", err)
+		}
+	default:
+		return fmt.Errorf("invalid status: %s (use: queued, watched, or leave empty for all)", status)
+	}
+
+	if len(movies) == 0 {
+		if status == "" {
+			fmt.Println("No movies found")
+		} else {
+			fmt.Printf("No %s movies found\n", status)
+		}
+		return nil
+	}
+
+	fmt.Printf("Found %d movie(s):\n\n", len(movies))
+	for _, movie := range movies {
+		h.printMovie(movie)
+	}
+
+	return nil
+}
+
+// View displays detailed information about a specific movie
+func (h *MovieHandler) View(ctx context.Context, movieID int64) error {
+	movie, err := h.repos.Movies.Get(ctx, movieID)
+	if err != nil {
+		return fmt.Errorf("failed to get movie %d: %w", movieID, err)
+	}
+
+	fmt.Printf("Movie: %s", movie.Title)
+	if movie.Year > 0 {
+		fmt.Printf(" (%d)", movie.Year)
+	}
+	fmt.Printf("\nID: %d\n", movie.ID)
+	fmt.Printf("Status: %s\n", movie.Status)
+
+	if movie.Rating > 0 {
+		fmt.Printf("Rating: ★%.1f\n", movie.Rating)
+	}
+
+	fmt.Printf("Added: %s\n", movie.Added.Format("2006-01-02 15:04:05"))
+
+	if movie.Watched != nil {
+		fmt.Printf("Watched: %s\n", movie.Watched.Format("2006-01-02 15:04:05"))
+	}
+
+	if movie.Notes != "" {
+		fmt.Printf("Notes: %s\n", movie.Notes)
+	}
+
+	return nil
+}
+
+// UpdateStatus changes the status of a movie
+func (h *MovieHandler) UpdateStatus(ctx context.Context, movieID int64, status string) error {
+	validStatuses := []string{"queued", "watched", "removed"}
+	if !slices.Contains(validStatuses, status) {
+		return fmt.Errorf("invalid status: %s (valid: %s)", status, strings.Join(validStatuses, ", "))
+	}
+
+	movie, err := h.repos.Movies.Get(ctx, movieID)
+	if err != nil {
+		return fmt.Errorf("movie %d not found: %w", movieID, err)
+	}
+
+	movie.Status = status
+	if status == "watched" && movie.Watched == nil {
+		now := time.Now()
+		movie.Watched = &now
+	}
+
+	if err := h.repos.Movies.Update(ctx, movie); err != nil {
+		return fmt.Errorf("failed to update movie status: %w", err)
+	}
+
+	fmt.Printf("✓ Movie '%s' marked as %s\n", movie.Title, status)
+	return nil
+}
+
+// MarkWatched marks a movie as watched
+func (h *MovieHandler) MarkWatched(ctx context.Context, movieID int64) error {
+	return h.UpdateStatus(ctx, movieID, "watched")
+}
+
+// Remove removes a movie from the queue
+func (h *MovieHandler) Remove(ctx context.Context, movieID int64) error {
+	movie, err := h.repos.Movies.Get(ctx, movieID)
+	if err != nil {
+		return fmt.Errorf("movie %d not found: %w", movieID, err)
+	}
+
+	if err := h.repos.Movies.Delete(ctx, movieID); err != nil {
+		return fmt.Errorf("failed to remove movie: %w", err)
+	}
+
+	fmt.Printf("✓ Removed movie: %s", movie.Title)
+	if movie.Year > 0 {
+		fmt.Printf(" (%d)", movie.Year)
+	}
+	fmt.Println()
+
+	return nil
+}
+
+func (h *MovieHandler) printMovie(movie *models.Movie) {
+	fmt.Printf("[%d] %s", movie.ID, movie.Title)
+	if movie.Year > 0 {
+		fmt.Printf(" (%d)", movie.Year)
+	}
+	if movie.Status != "queued" {
+		fmt.Printf(" (%s)", movie.Status)
+	}
+	if movie.Rating > 0 {
+		fmt.Printf(" ★%.1f", movie.Rating)
+	}
+	fmt.Println()
+}
+
+// SearchAndAddMovie searches for movies and allows user to select and add to queue
+func (h *MovieHandler) SearchAndAddMovie(ctx context.Context, query string, interactive bool) error {
+	return h.SearchAndAdd(ctx, query, interactive)
+}
+
+// ListMovies lists all movies in the queue with status filtering
+func (h *MovieHandler) ListMovies(ctx context.Context, status string) error {
+	return h.List(ctx, status)
+}
+
+// ViewMovie displays detailed information about a specific movie
+func (h *MovieHandler) ViewMovie(ctx context.Context, id string) error {
+	movieID, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		return fmt.Errorf("invalid movie ID: %s", id)
+	}
+	return h.View(ctx, movieID)
+}
+
+// UpdateMovieStatus changes the status of a movie
+func (h *MovieHandler) UpdateMovieStatus(ctx context.Context, id, status string) error {
+	movieID, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		return fmt.Errorf("invalid movie ID: %s", id)
+	}
+	return h.UpdateStatus(ctx, movieID, status)
+}
+
+// MarkMovieWatched marks a movie as watched
+func (h *MovieHandler) MarkMovieWatched(ctx context.Context, id string) error {
+	movieID, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		return fmt.Errorf("invalid movie ID: %s", id)
+	}
+	return h.MarkWatched(ctx, movieID)
+}
+
+// RemoveMovie removes a movie from the queue
+func (h *MovieHandler) RemoveMovie(ctx context.Context, id string) error {
+	movieID, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		return fmt.Errorf("invalid movie ID: %s", id)
+	}
+
+	return h.Remove(ctx, movieID)
+}

internal/handlers/movies_test.go

···
+package handlers
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stormlightlabs/noteleaf/internal/models"
+)
+
+func createTestMovieHandler(t *testing.T) *MovieHandler {
+	handler, err := NewMovieHandler()
+	if err != nil {
+		t.Fatalf("Failed to create test movie handler: %v", err)
+	}
+	return handler
+}
+
+func createTestMovie() *models.Movie {
+	now := time.Now()
+	return &models.Movie{
+		ID:     1,
+		Title:  "Test Movie",
+		Year:   2023,
+		Status: "queued",
+		Rating: 4.5,
+		Notes:  "Test notes",
+		Added:  now,
+	}
+}
+
+func TestMovieHandler(t *testing.T) {
+	t.Run("New", func(t *testing.T) {
+		handler := createTestMovieHandler(t)
+		defer handler.Close()
+
+		if handler.db == nil {
+			t.Error("Expected database to be initialized")
+		}
+		if handler.config == nil {
+			t.Error("Expected config to be initialized")
+		}
+		if handler.repos == nil {
+			t.Error("Expected repositories to be initialized")
+		}
+		if handler.service == nil {
+			t.Error("Expected service to be initialized")
+		}
+	})
+
+	t.Run("Close", func(t *testing.T) {
+		handler := createTestMovieHandler(t)
+
+		err := handler.Close()
+		if err != nil {
+			t.Errorf("Expected no error when closing handler, got: %v", err)
+		}
+	})
+
+	t.Run("Search and Add", func(t *testing.T) {
+		t.Run("Empty Query", func(t *testing.T) {
+			handler := createTestMovieHandler(t)
+			defer handler.Close()
+
+			err := handler.SearchAndAdd(context.Background(), "", false)
+			if err == nil {
+				t.Error("Expected error for empty query")
+			}
+			if err.Error() != "search query cannot be empty" {
+				t.Errorf("Expected 'search query cannot be empty', got: %v", err)
+			}
+		})
+
+		t.Run("Search Error", func(t *testing.T) {
+			handler := createTestMovieHandler(t)
+			defer handler.Close()
+
+			// Test with malformed search that should cause network error
+			err := handler.SearchAndAdd(context.Background(), "test movie", false)
+			// We expect this to work with the actual service, so we test for successful completion
+			// or a specific network error - this tests the error handling path in the code
+			if err != nil {
+				// This is expected - the search might fail due to network issues in test environment
+				if err.Error() != "search query cannot be empty" {
+					// We got a search error, which tests our error handling path
+					t.Logf("Search failed as expected in test environment: %v", err)
+				}
+			}
+		})
+
+		t.Run("Network Error", func(t *testing.T) {
+			handler := createTestMovieHandler(t)
+			defer handler.Close()
+
+			// Test search with a query that will likely fail due to network issues in test env
+			// This tests the error handling path
+			err := handler.SearchAndAdd(context.Background(), "unlikely_to_find_this_movie_12345", false)
+			// We don't expect a specific error, but this tests the error handling path
+			if err != nil {
+				t.Logf("Network error encountered (expected in test environment): %v", err)
+			}
+		})
+
+	})
+
+	t.Run("List", func(t *testing.T) {
+		t.Run("Invalid Status", func(t *testing.T) {
+			handler := createTestMovieHandler(t)
+			defer handler.Close()
+
+			err := handler.List(context.Background(), "invalid_status")
+			if err == nil {
+				t.Error("Expected error for invalid status")
+			}
+			if err.Error() != "invalid status: invalid_status (use: queued, watched, or leave empty for all)" {
+				t.Errorf("Expected invalid status error, got: %v", err)
+			}
+		})
+
+		t.Run("All Movies", func(t *testing.T) {
+			handler := createTestMovieHandler(t)
+			defer handler.Close()
+
+			// Test with empty status (all movies)
+			err := handler.List(context.Background(), "")
+			if err != nil {
+				t.Errorf("Expected no error for listing all movies, got: %v", err)
+			}
+		})
+
+		t.Run("Queued Movies", func(t *testing.T) {
+			handler := createTestMovieHandler(t)
+			defer handler.Close()
+
+			err := handler.List(context.Background(), "queued")
+			if err != nil {
+				t.Errorf("Expected no error for listing queued movies, got: %v", err)
+			}
+		})
+
+		t.Run("Watched Movies", func(t *testing.T) {
+			handler := createTestMovieHandler(t)
+			defer handler.Close()
+
+			err := handler.List(context.Background(), "watched")
+			if err != nil {
+				t.Errorf("Expected no error for listing watched movies, got: %v", err)
+			}
+		})
+
+	})
+
+	t.Run("View", func(t *testing.T) {
+		t.Run("Movie Not Found", func(t *testing.T) {
+			handler := createTestMovieHandler(t)
+			defer handler.Close()
+
+			err := handler.View(context.Background(), 999)
+			if err == nil {
+				t.Error("Expected error for non-existent movie")
+			}
+		})
+
+		t.Run("Invalid ID", func(t *testing.T) {
+			handler := createTestMovieHandler(t)
+			defer handler.Close()
+
+			err := handler.ViewMovie(context.Background(), "invalid")
+			if err == nil {
+				t.Error("Expected error for invalid movie ID")
+			}
+			if err.Error() != "invalid movie ID: invalid" {
+				t.Errorf("Expected 'invalid movie ID: invalid', got: %v", err)
+			}
+		})
+	})
+
+	t.Run("Update", func(t *testing.T) {
+		t.Run("Update Status", func(t *testing.T) {
+			t.Run("Invalid", func(t *testing.T) {
+				handler := createTestMovieHandler(t)
+				defer handler.Close()
+
+				err := handler.UpdateStatus(context.Background(), 1, "invalid")
+				if err == nil {
+					t.Error("Expected error for invalid status")
+				}
+				if err.Error() != "invalid status: invalid (valid: queued, watched, removed)" {
+					t.Errorf("Expected invalid status error, got: %v", err)
+				}
+			})
+
+			t.Run("Movie Not Found", func(t *testing.T) {
+				handler := createTestMovieHandler(t)
+				defer handler.Close()
+
+				err := handler.UpdateStatus(context.Background(), 999, "watched")
+				if err == nil {
+					t.Error("Expected error for non-existent movie")
+				}
+			})
+		})
+	})
+
+	t.Run("MarkWatched_MovieNotFound", func(t *testing.T) {
+		handler := createTestMovieHandler(t)
+		defer handler.Close()
+
+		err := handler.MarkWatched(context.Background(), 999)
+		if err == nil {
+			t.Error("Expected error for non-existent movie")
+		}
+	})
+
+	t.Run("Remove_MovieNotFound", func(t *testing.T) {
+		handler := createTestMovieHandler(t)
+		defer handler.Close()
+
+		err := handler.Remove(context.Background(), 999)
+		if err == nil {
+			t.Error("Expected error for non-existent movie")
+		}
+	})
+
+	t.Run("UpdateMovieStatus_InvalidID", func(t *testing.T) {
+		handler := createTestMovieHandler(t)
+		defer handler.Close()
+
+		err := handler.UpdateMovieStatus(context.Background(), "invalid", "watched")
+		if err == nil {
+			t.Error("Expected error for invalid movie ID")
+		}
+		if err.Error() != "invalid movie ID: invalid" {
+			t.Errorf("Expected 'invalid movie ID: invalid', got: %v", err)
+		}
+	})
+
+	t.Run("MarkMovieWatched_InvalidID", func(t *testing.T) {
+		handler := createTestMovieHandler(t)
+		defer handler.Close()
+
+		err := handler.MarkMovieWatched(context.Background(), "invalid")
+		if err == nil {
+			t.Error("Expected error for invalid movie ID")
+		}
+		if err.Error() != "invalid movie ID: invalid" {
+			t.Errorf("Expected 'invalid movie ID: invalid', got: %v", err)
+		}
+	})
+
+	t.Run("RemoveMovie_InvalidID", func(t *testing.T) {
+		handler := createTestMovieHandler(t)
+		defer handler.Close()
+
+		err := handler.RemoveMovie(context.Background(), "invalid")
+		if err == nil {
+			t.Error("Expected error for invalid movie ID")
+		}
+		if err.Error() != "invalid movie ID: invalid" {
+			t.Errorf("Expected 'invalid movie ID: invalid', got: %v", err)
+		}
+	})
+
+	t.Run("printMovie", func(t *testing.T) {
+		handler := createTestMovieHandler(t)
+		defer handler.Close()
+
+		movie := createTestMovie()
+
+		handler.printMovie(movie)
+
+		minimalMovie := &models.Movie{
+			ID:    2,
+			Title: "Minimal Movie",
+		}
+		handler.printMovie(minimalMovie)
+
+		watchedMovie := &models.Movie{
+			ID:     3,
+			Title:  "Watched Movie",
+			Year:   2022,
+			Status: "watched",
+			Rating: 3.5,
+		}
+		handler.printMovie(watchedMovie)
+	})
+
+	t.Run("SearchAndAddMovie", func(t *testing.T) {
+		handler := createTestMovieHandler(t)
+		defer handler.Close()
+
+		err := handler.SearchAndAddMovie(context.Background(), "", false)
+		if err == nil {
+			t.Error("Expected error for empty query")
+		}
+	})
+
+	t.Run("List Movies", func(t *testing.T) {
+		handler := createTestMovieHandler(t)
+		defer handler.Close()
+
+		err := handler.ListMovies(context.Background(), "")
+		if err != nil {
+			t.Errorf("Expected no error for listing all movies, got: %v", err)
+		}
+
+		err = handler.ListMovies(context.Background(), "invalid")
+		if err == nil {
+			t.Error("Expected error for invalid status")
+		}
+	})
+
+	t.Run("Integration", func(t *testing.T) {
+		t.Run("CreateAndRetrieve", func(t *testing.T) {
+			handler := createTestMovieHandler(t)
+			defer handler.Close()
+
+			movie := createTestMovie()
+			movie.ID = 0
+
+			id, err := handler.repos.Movies.Create(context.Background(), movie)
+			if err != nil {
+				t.Errorf("Failed to create movie: %v", err)
+				return
+			}
+
+			err = handler.View(context.Background(), id)
+			if err != nil {
+				t.Errorf("Failed to view created movie: %v", err)
+			}
+
+			err = handler.UpdateStatus(context.Background(), id, "watched")
+			if err != nil {
+				t.Errorf("Failed to update movie status: %v", err)
+			}
+
+			err = handler.MarkWatched(context.Background(), id)
+			if err != nil {
+				t.Errorf("Failed to mark movie as watched: %v", err)
+			}
+
+			err = handler.Remove(context.Background(), id)
+			if err != nil {
+				t.Errorf("Failed to remove movie: %v", err)
+			}
+		})
+
+		t.Run("StatusFiltering", func(t *testing.T) {
+			handler := createTestMovieHandler(t)
+			defer handler.Close()
+
+			queuedMovie := &models.Movie{
+				Title:  "Queued Movie",
+				Status: "queued",
+				Added:  time.Now(),
+			}
+			watchedMovie := &models.Movie{
+				Title:  "Watched Movie",
+				Status: "watched",
+				Added:  time.Now(),
+			}
+
+			id1, err := handler.repos.Movies.Create(context.Background(), queuedMovie)
+			if err != nil {
+				t.Errorf("Failed to create queued movie: %v", err)
+				return
+			}
+			defer handler.repos.Movies.Delete(context.Background(), id1)
+
+			id2, err := handler.repos.Movies.Create(context.Background(), watchedMovie)
+			if err != nil {
+				t.Errorf("Failed to create watched movie: %v", err)
+				return
+			}
+			defer handler.repos.Movies.Delete(context.Background(), id2)
+
+			testCases := []string{"", "queued", "watched"}
+			for _, status := range testCases {
+				err = handler.List(context.Background(), status)
+				if err != nil {
+					t.Errorf("Failed to list movies with status '%s': %v", status, err)
+				}
+			}
+		})
+	})
+
+	t.Run("ErrorPaths", func(t *testing.T) {
+		handler := createTestMovieHandler(t)
+		defer handler.Close()
+
+		ctx := context.Background()
+		nonExistentID := int64(999999)
+
+		testCases := []struct {
+			name string
+			fn   func() error
+		}{
+			{
+				name: "View non-existent movie",
+				fn:   func() error { return handler.View(ctx, nonExistentID) },
+			},
+			{
+				name: "Update status of non-existent movie",
+				fn:   func() error { return handler.UpdateStatus(ctx, nonExistentID, "watched") },
+			},
+			{
+				name: "Mark non-existent movie as watched",
+				fn:   func() error { return handler.MarkWatched(ctx, nonExistentID) },
+			},
+			{
+				name: "Remove non-existent movie",
+				fn:   func() error { return handler.Remove(ctx, nonExistentID) },
+			},
+		}
+
+		for _, tc := range testCases {
+			t.Run(tc.name, func(t *testing.T) {
+				err := tc.fn()
+				if err == nil {
+					t.Errorf("Expected error for %s", tc.name)
+				}
+			})
+		}
+	})
+
+	t.Run("ValidStatusValues", func(t *testing.T) {
+		handler := createTestMovieHandler(t)
+		defer handler.Close()
+
+		valid := []string{"queued", "watched", "removed"}
+		invalid := []string{"invalid", "pending", "completed", ""}
+
+		for _, status := range valid {
+			if err := handler.UpdateStatus(context.Background(), 999, status); err != nil &&
+				err.Error() == fmt.Sprintf("invalid status: %s (valid: queued, watched, removed)", status) {
+				t.Errorf("Status '%s' should be valid but was rejected", status)
+			}
+		}
+
+		for _, status := range invalid {
+			err := handler.UpdateStatus(context.Background(), 1, status)
+			if err == nil {
+				t.Errorf("Status '%s' should be invalid but was accepted", status)
+			}
+			got := fmt.Sprintf("invalid status: %s (valid: queued, watched, removed)", status)
+			if err.Error() != got {
+				t.Errorf("Expected '%s', got: %v", got, err)
+			}
+		}
+	})
+}

internal/handlers/tasks.go

···
 	return nil
 }
 
-func (h *TaskHandler) listTasksInteractive(ctx context.Context, showAll bool, status, priority, project, context string) error {
+// TODO: include context field
+func (h *TaskHandler) listTasksInteractive(ctx context.Context, showAll bool, status, priority, project, _ string) error {
 	taskTable := ui.NewTaskListFromTable(h.repos.Tasks, os.Stdout, os.Stdin, false, showAll, status, priority, project)
 	return taskTable.Browse(ctx)
 }

internal/handlers/tv.go

···
+package handlers
+
+import (
+	"context"
+	"fmt"
+	"slices"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+	"github.com/stormlightlabs/noteleaf/internal/services"
+	"github.com/stormlightlabs/noteleaf/internal/store"
+)
+
+// TVHandler handles all TV show-related commands
+type TVHandler struct {
+	db      *store.Database
+	config  *store.Config
+	repos   *repo.Repositories
+	service *services.TVService
+}
+
+// NewTVHandler creates a new TV handler
+func NewTVHandler() (*TVHandler, 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)
+	service := services.NewTVService()
+
+	return &TVHandler{
+		db:      db,
+		config:  config,
+		repos:   repos,
+		service: service,
+	}, nil
+}
+
+// Close cleans up resources
+func (h *TVHandler) Close() error {
+	if err := h.service.Close(); err != nil {
+		return fmt.Errorf("failed to close service: %w", err)
+	}
+	return h.db.Close()
+}
+
+// SearchAndAdd searches for TV shows and allows user to select and add to queue
+func (h *TVHandler) SearchAndAdd(ctx context.Context, query string, interactive bool) error {
+	if query == "" {
+		return fmt.Errorf("search query cannot be empty")
+	}
+
+	fmt.Printf("Searching for TV shows: %s\n", query)
+	fmt.Print("Loading...")
+
+	results, err := h.service.Search(ctx, query, 1, 5)
+	if err != nil {
+		fmt.Println(" failed!")
+		return fmt.Errorf("search failed: %w", err)
+	}
+
+	fmt.Println(" done!")
+	fmt.Println()
+
+	if len(results) == 0 {
+		fmt.Println("No TV shows found.")
+		return nil
+	}
+
+	fmt.Printf("Found %d result(s):\n\n", len(results))
+	for i, result := range results {
+		if show, ok := (*result).(*models.TVShow); ok {
+			fmt.Printf("[%d] %s", i+1, show.Title)
+			if show.Season > 0 {
+				fmt.Printf(" (Season %d)", show.Season)
+			}
+			if show.Rating > 0 {
+				fmt.Printf(" ★%.1f", show.Rating)
+			}
+			if show.Notes != "" {
+				notes := show.Notes
+				if len(notes) > 80 {
+					notes = notes[:77] + "..."
+				}
+				fmt.Printf("\n    %s", notes)
+			}
+			fmt.Println()
+		}
+	}
+
+	fmt.Print("\nEnter number to add (1-", len(results), "), or 0 to cancel: ")
+
+	var choice int
+	if _, err := fmt.Scanf("%d", &choice); err != nil {
+		return fmt.Errorf("invalid input")
+	}
+
+	if choice == 0 {
+		fmt.Println("Cancelled.")
+		return nil
+	}
+
+	if choice < 1 || choice > len(results) {
+		return fmt.Errorf("invalid choice: %d", choice)
+	}
+
+	selectedShow, ok := (*results[choice-1]).(*models.TVShow)
+	if !ok {
+		return fmt.Errorf("error processing selected TV show")
+	}
+
+	if _, err := h.repos.TV.Create(ctx, selectedShow); err != nil {
+		return fmt.Errorf("failed to add TV show: %w", err)
+	}
+
+	fmt.Printf("✓ Added TV show: %s", selectedShow.Title)
+	if selectedShow.Season > 0 {
+		fmt.Printf(" (Season %d)", selectedShow.Season)
+	}
+	fmt.Println()
+
+	return nil
+}
+
+// List TV shows with status filtering
+func (h *TVHandler) List(ctx context.Context, status string) error {
+	var shows []*models.TVShow
+	var err error
+
+	switch status {
+	case "":
+		shows, err = h.repos.TV.List(ctx, repo.TVListOptions{})
+		if err != nil {
+			return fmt.Errorf("failed to list TV shows: %w", err)
+		}
+	case "queued":
+		shows, err = h.repos.TV.GetQueued(ctx)
+		if err != nil {
+			return fmt.Errorf("failed to get queued TV shows: %w", err)
+		}
+	case "watching":
+		shows, err = h.repos.TV.GetWatching(ctx)
+		if err != nil {
+			return fmt.Errorf("failed to get watching TV shows: %w", err)
+		}
+	case "watched":
+		shows, err = h.repos.TV.GetWatched(ctx)
+		if err != nil {
+			return fmt.Errorf("failed to get watched TV shows: %w", err)
+		}
+	default:
+		return fmt.Errorf("invalid status: %s (use: queued, watching, watched, or leave empty for all)", status)
+	}
+
+	if len(shows) == 0 {
+		if status == "" {
+			fmt.Println("No TV shows found")
+		} else {
+			fmt.Printf("No %s TV shows found\n", status)
+		}
+		return nil
+	}
+
+	fmt.Printf("Found %d TV show(s):\n\n", len(shows))
+	for _, show := range shows {
+		h.printTVShow(show)
+	}
+
+	return nil
+}
+
+// View displays detailed information about a specific TV show
+func (h *TVHandler) View(ctx context.Context, showID int64) error {
+	show, err := h.repos.TV.Get(ctx, showID)
+	if err != nil {
+		return fmt.Errorf("failed to get TV show %d: %w", showID, err)
+	}
+
+	fmt.Printf("TV Show: %s", show.Title)
+	if show.Season > 0 {
+		fmt.Printf(" (Season %d", show.Season)
+		if show.Episode > 0 {
+			fmt.Printf(", Episode %d", show.Episode)
+		}
+		fmt.Print(")")
+	}
+	fmt.Printf("\nID: %d\n", show.ID)
+	fmt.Printf("Status: %s\n", show.Status)
+
+	if show.Rating > 0 {
+		fmt.Printf("Rating: ★%.1f\n", show.Rating)
+	}
+
+	fmt.Printf("Added: %s\n", show.Added.Format("2006-01-02 15:04:05"))
+
+	if show.LastWatched != nil {
+		fmt.Printf("Last Watched: %s\n", show.LastWatched.Format("2006-01-02 15:04:05"))
+	}
+
+	if show.Notes != "" {
+		fmt.Printf("Notes: %s\n", show.Notes)
+	}
+
+	return nil
+}
+
+// UpdateStatus changes the status of a TV show
+func (h *TVHandler) UpdateStatus(ctx context.Context, showID int64, status string) error {
+	validStatuses := []string{"queued", "watching", "watched", "removed"}
+	if !slices.Contains(validStatuses, status) {
+		return fmt.Errorf("invalid status: %s (valid: %s)", status, strings.Join(validStatuses, ", "))
+	}
+
+	show, err := h.repos.TV.Get(ctx, showID)
+	if err != nil {
+		return fmt.Errorf("TV show %d not found: %w", showID, err)
+	}
+
+	show.Status = status
+	if (status == "watching" || status == "watched") && show.LastWatched == nil {
+		now := time.Now()
+		show.LastWatched = &now
+	}
+
+	if err := h.repos.TV.Update(ctx, show); err != nil {
+		return fmt.Errorf("failed to update TV show status: %w", err)
+	}
+
+	fmt.Printf("✓ TV show '%s' marked as %s\n", show.Title, status)
+	return nil
+}
+
+// MarkWatching marks a TV show as currently watching
+func (h *TVHandler) MarkWatching(ctx context.Context, showID int64) error {
+	return h.UpdateStatus(ctx, showID, "watching")
+}
+
+// MarkWatched marks a TV show as watched
+func (h *TVHandler) MarkWatched(ctx context.Context, showID int64) error {
+	return h.UpdateStatus(ctx, showID, "watched")
+}
+
+// Remove removes a TV show from the queue
+func (h *TVHandler) Remove(ctx context.Context, showID int64) error {
+	show, err := h.repos.TV.Get(ctx, showID)
+	if err != nil {
+		return fmt.Errorf("TV show %d not found: %w", showID, err)
+	}
+
+	if err := h.repos.TV.Delete(ctx, showID); err != nil {
+		return fmt.Errorf("failed to remove TV show: %w", err)
+	}
+
+	fmt.Printf("✓ Removed TV show: %s", show.Title)
+	if show.Season > 0 {
+		fmt.Printf(" (Season %d)", show.Season)
+	}
+	fmt.Println()
+
+	return nil
+}
+
+func (h *TVHandler) printTVShow(show *models.TVShow) {
+	fmt.Printf("[%d] %s", show.ID, show.Title)
+	if show.Season > 0 {
+		fmt.Printf(" (Season %d", show.Season)
+		if show.Episode > 0 {
+			fmt.Printf(", Ep %d", show.Episode)
+		}
+		fmt.Print(")")
+	}
+	if show.Status != "queued" {
+		fmt.Printf(" (%s)", show.Status)
+	}
+	if show.Rating > 0 {
+		fmt.Printf(" ★%.1f", show.Rating)
+	}
+	fmt.Println()
+}
+
+// SearchAndAddTV searches for TV shows and allows user to select and add to queue
+func (h *TVHandler) SearchAndAddTV(ctx context.Context, query string, interactive bool) error {
+	return h.SearchAndAdd(ctx, query, interactive)
+}
+
+// ListTVShows lists all TV shows in the queue with status filtering
+func (h *TVHandler) ListTVShows(ctx context.Context, status string) error {
+	return h.List(ctx, status)
+}
+
+// ViewTVShow displays detailed information about a specific TV show
+func (h *TVHandler) ViewTVShow(ctx context.Context, id string) error {
+	showID, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		return fmt.Errorf("invalid TV show ID: %s", id)
+	}
+	return h.View(ctx, showID)
+}
+
+// UpdateTVShowStatus changes the status of a TV show
+func (h *TVHandler) UpdateTVShowStatus(ctx context.Context, id, status string) error {
+	showID, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		return fmt.Errorf("invalid TV show ID: %s", id)
+	}
+	return h.UpdateStatus(ctx, showID, status)
+}
+
+// MarkTVShowWatching marks a TV show as currently watching
+func (h *TVHandler) MarkTVShowWatching(ctx context.Context, id string) error {
+	showID, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		return fmt.Errorf("invalid TV show ID: %s", id)
+	}
+	return h.MarkWatching(ctx, showID)
+}
+
+// MarkTVShowWatched marks a TV show as watched
+func (h *TVHandler) MarkTVShowWatched(ctx context.Context, id string) error {
+	showID, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		return fmt.Errorf("invalid TV show ID: %s", id)
+	}
+	return h.MarkWatched(ctx, showID)
+}
+
+// RemoveTVShow removes a TV show from the queue
+func (h *TVHandler) RemoveTVShow(ctx context.Context, id string) error {
+	showID, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		return fmt.Errorf("invalid TV show ID: %s", id)
+	}
+	return h.Remove(ctx, showID)
+}

internal/handlers/tv_test.go

···
+package handlers
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stormlightlabs/noteleaf/internal/models"
+)
+
+func createTestTVHandler(t *testing.T) *TVHandler {
+	handler, err := NewTVHandler()
+	if err != nil {
+		t.Fatalf("Failed to create test TV handler: %v", err)
+	}
+	return handler
+}
+
+func createTestTVShow() *models.TVShow {
+	now := time.Now()
+	return &models.TVShow{
+		ID:     1,
+		Title:  "Test TV Show",
+		Season: 1,
+		Status: "queued",
+		Rating: 4.5,
+		Notes:  "Test notes",
+		Added:  now,
+	}
+}
+
+func TestTVHandler(t *testing.T) {
+	t.Run("New", func(t *testing.T) {
+		handler := createTestTVHandler(t)
+		defer handler.Close()
+
+		if handler.db == nil {
+			t.Error("Expected database to be initialized")
+		}
+		if handler.config == nil {
+			t.Error("Expected config to be initialized")
+		}
+		if handler.repos == nil {
+			t.Error("Expected repositories to be initialized")
+		}
+		if handler.service == nil {
+			t.Error("Expected service to be initialized")
+		}
+	})
+
+	t.Run("Close", func(t *testing.T) {
+		handler := createTestTVHandler(t)
+
+		err := handler.Close()
+		if err != nil {
+			t.Errorf("Expected no error when closing handler, got: %v", err)
+		}
+	})
+
+	t.Run("Search and Add", func(t *testing.T) {
+		t.Run("Empty Query", func(t *testing.T) {
+			handler := createTestTVHandler(t)
+			defer handler.Close()
+
+			err := handler.SearchAndAdd(context.Background(), "", false)
+			if err == nil {
+				t.Error("Expected error for empty query")
+			}
+			if err.Error() != "search query cannot be empty" {
+				t.Errorf("Expected 'search query cannot be empty', got: %v", err)
+			}
+		})
+
+		t.Run("Search Error", func(t *testing.T) {
+			handler := createTestTVHandler(t)
+			defer handler.Close()
+
+			err := handler.SearchAndAdd(context.Background(), "test show", false)
+			if err != nil {
+				t.Logf("Search failed as expected in test environment: %v", err)
+			}
+		})
+
+		t.Run("Network Error", func(t *testing.T) {
+			handler := createTestTVHandler(t)
+			defer handler.Close()
+
+			err := handler.SearchAndAdd(context.Background(), "unlikely_to_find_this_show_12345", false)
+			if err != nil {
+				t.Logf("Network error encountered (expected in test environment): %v", err)
+			}
+		})
+	})
+
+	t.Run("List", func(t *testing.T) {
+		t.Run("Invalid Status", func(t *testing.T) {
+			handler := createTestTVHandler(t)
+			defer handler.Close()
+
+			err := handler.List(context.Background(), "invalid_status")
+			if err == nil {
+				t.Error("Expected error for invalid status")
+			}
+			if err.Error() != "invalid status: invalid_status (use: queued, watching, watched, or leave empty for all)" {
+				t.Errorf("Expected invalid status error, got: %v", err)
+			}
+		})
+
+		t.Run("All Shows", func(t *testing.T) {
+			handler := createTestTVHandler(t)
+			defer handler.Close()
+
+			err := handler.List(context.Background(), "")
+			if err != nil {
+				t.Errorf("Expected no error for listing all TV shows, got: %v", err)
+			}
+		})
+
+		t.Run("Queued Shows", func(t *testing.T) {
+			handler := createTestTVHandler(t)
+			defer handler.Close()
+
+			err := handler.List(context.Background(), "queued")
+			if err != nil {
+				t.Errorf("Expected no error for listing queued TV shows, got: %v", err)
+			}
+		})
+
+		t.Run("Watching Shows", func(t *testing.T) {
+			handler := createTestTVHandler(t)
+			defer handler.Close()
+
+			err := handler.List(context.Background(), "watching")
+			if err != nil {
+				t.Errorf("Expected no error for listing watching TV shows, got: %v", err)
+			}
+		})
+
+		t.Run("Watched Shows", func(t *testing.T) {
+			handler := createTestTVHandler(t)
+			defer handler.Close()
+
+			err := handler.List(context.Background(), "watched")
+			if err != nil {
+				t.Errorf("Expected no error for listing watched TV shows, got: %v", err)
+			}
+		})
+	})
+
+	t.Run("View", func(t *testing.T) {
+		t.Run("Show Not Found", func(t *testing.T) {
+			handler := createTestTVHandler(t)
+			defer handler.Close()
+
+			err := handler.View(context.Background(), 999)
+			if err == nil {
+				t.Error("Expected error for non-existent TV show")
+			}
+		})
+
+		t.Run("Invalid ID", func(t *testing.T) {
+			handler := createTestTVHandler(t)
+			defer handler.Close()
+
+			err := handler.ViewTVShow(context.Background(), "invalid")
+			if err == nil {
+				t.Error("Expected error for invalid TV show ID")
+			}
+			if err.Error() != "invalid TV show ID: invalid" {
+				t.Errorf("Expected 'invalid TV show ID: invalid', got: %v", err)
+			}
+		})
+	})
+
+	t.Run("Update", func(t *testing.T) {
+		t.Run("Update Status", func(t *testing.T) {
+			t.Run("Invalid", func(t *testing.T) {
+				handler := createTestTVHandler(t)
+				defer handler.Close()
+
+				err := handler.UpdateStatus(context.Background(), 1, "invalid")
+				if err == nil {
+					t.Error("Expected error for invalid status")
+				}
+				if err.Error() != "invalid status: invalid (valid: queued, watching, watched, removed)" {
+					t.Errorf("Expected invalid status error, got: %v", err)
+				}
+			})
+
+			t.Run("Show Not Found", func(t *testing.T) {
+				handler := createTestTVHandler(t)
+				defer handler.Close()
+
+				err := handler.UpdateStatus(context.Background(), 999, "watched")
+				if err == nil {
+					t.Error("Expected error for non-existent TV show")
+				}
+			})
+		})
+	})
+
+	t.Run("MarkWatching_ShowNotFound", func(t *testing.T) {
+		handler := createTestTVHandler(t)
+		defer handler.Close()
+
+		err := handler.MarkWatching(context.Background(), 999)
+		if err == nil {
+			t.Error("Expected error for non-existent TV show")
+		}
+	})
+
+	t.Run("MarkWatched_ShowNotFound", func(t *testing.T) {
+		handler := createTestTVHandler(t)
+		defer handler.Close()
+
+		err := handler.MarkWatched(context.Background(), 999)
+		if err == nil {
+			t.Error("Expected error for non-existent TV show")
+		}
+	})
+
+	t.Run("Remove_ShowNotFound", func(t *testing.T) {
+		handler := createTestTVHandler(t)
+		defer handler.Close()
+
+		err := handler.Remove(context.Background(), 999)
+		if err == nil {
+			t.Error("Expected error for non-existent TV show")
+		}
+	})
+
+	t.Run("UpdateTVShowStatus_InvalidID", func(t *testing.T) {
+		handler := createTestTVHandler(t)
+		defer handler.Close()
+
+		err := handler.UpdateTVShowStatus(context.Background(), "invalid", "watched")
+		if err == nil {
+			t.Error("Expected error for invalid TV show ID")
+		}
+		if err.Error() != "invalid TV show ID: invalid" {
+			t.Errorf("Expected 'invalid TV show ID: invalid', got: %v", err)
+		}
+	})
+
+	t.Run("MarkTVShowWatching_InvalidID", func(t *testing.T) {
+		handler := createTestTVHandler(t)
+		defer handler.Close()
+
+		err := handler.MarkTVShowWatching(context.Background(), "invalid")
+		if err == nil {
+			t.Error("Expected error for invalid TV show ID")
+		}
+		if err.Error() != "invalid TV show ID: invalid" {
+			t.Errorf("Expected 'invalid TV show ID: invalid', got: %v", err)
+		}
+	})
+
+	t.Run("MarkTVShowWatched_InvalidID", func(t *testing.T) {
+		handler := createTestTVHandler(t)
+		defer handler.Close()
+
+		err := handler.MarkTVShowWatched(context.Background(), "invalid")
+		if err == nil {
+			t.Error("Expected error for invalid TV show ID")
+		}
+		if err.Error() != "invalid TV show ID: invalid" {
+			t.Errorf("Expected 'invalid TV show ID: invalid', got: %v", err)
+		}
+	})
+
+	t.Run("RemoveTVShow_InvalidID", func(t *testing.T) {
+		handler := createTestTVHandler(t)
+		defer handler.Close()
+
+		err := handler.RemoveTVShow(context.Background(), "invalid")
+		if err == nil {
+			t.Error("Expected error for invalid TV show ID")
+		}
+		if err.Error() != "invalid TV show ID: invalid" {
+			t.Errorf("Expected 'invalid TV show ID: invalid', got: %v", err)
+		}
+	})
+
+	t.Run("printTVShow", func(t *testing.T) {
+		handler := createTestTVHandler(t)
+		defer handler.Close()
+
+		show := createTestTVShow()
+
+		handler.printTVShow(show)
+
+		minimalShow := &models.TVShow{
+			ID:    2,
+			Title: "Minimal Show",
+		}
+		handler.printTVShow(minimalShow)
+
+		watchedShow := &models.TVShow{
+			ID:      3,
+			Title:   "Watched Show",
+			Season:  2,
+			Episode: 5,
+			Status:  "watched",
+			Rating:  3.5,
+		}
+		handler.printTVShow(watchedShow)
+	})
+
+	t.Run("SearchAndAddTV", func(t *testing.T) {
+		handler := createTestTVHandler(t)
+		defer handler.Close()
+
+		err := handler.SearchAndAddTV(context.Background(), "", false)
+		if err == nil {
+			t.Error("Expected error for empty query")
+		}
+	})
+
+	t.Run("List TV Shows", func(t *testing.T) {
+		handler := createTestTVHandler(t)
+		defer handler.Close()
+
+		err := handler.ListTVShows(context.Background(), "")
+		if err != nil {
+			t.Errorf("Expected no error for listing all TV shows, got: %v", err)
+		}
+
+		err = handler.ListTVShows(context.Background(), "invalid")
+		if err == nil {
+			t.Error("Expected error for invalid status")
+		}
+	})
+
+	t.Run("Integration", func(t *testing.T) {
+		t.Run("CreateAndRetrieve", func(t *testing.T) {
+			handler := createTestTVHandler(t)
+			defer handler.Close()
+
+			show := createTestTVShow()
+			show.ID = 0
+
+			id, err := handler.repos.TV.Create(context.Background(), show)
+			if err != nil {
+				t.Errorf("Failed to create TV show: %v", err)
+				return
+			}
+
+			err = handler.View(context.Background(), id)
+			if err != nil {
+				t.Errorf("Failed to view created TV show: %v", err)
+			}
+
+			err = handler.UpdateStatus(context.Background(), id, "watching")
+			if err != nil {
+				t.Errorf("Failed to update TV show status: %v", err)
+			}
+
+			err = handler.MarkWatched(context.Background(), id)
+			if err != nil {
+				t.Errorf("Failed to mark TV show as watched: %v", err)
+			}
+
+			err = handler.MarkWatching(context.Background(), id)
+			if err != nil {
+				t.Errorf("Failed to mark TV show as watching: %v", err)
+			}
+
+			err = handler.Remove(context.Background(), id)
+			if err != nil {
+				t.Errorf("Failed to remove TV show: %v", err)
+			}
+		})
+
+		t.Run("StatusFiltering", func(t *testing.T) {
+			handler := createTestTVHandler(t)
+			defer handler.Close()
+
+			queuedShow := &models.TVShow{
+				Title:  "Queued Show",
+				Status: "queued",
+				Added:  time.Now(),
+			}
+			watchingShow := &models.TVShow{
+				Title:  "Watching Show",
+				Status: "watching",
+				Added:  time.Now(),
+			}
+			watchedShow := &models.TVShow{
+				Title:  "Watched Show",
+				Status: "watched",
+				Added:  time.Now(),
+			}
+
+			id1, err := handler.repos.TV.Create(context.Background(), queuedShow)
+			if err != nil {
+				t.Errorf("Failed to create queued show: %v", err)
+				return
+			}
+			defer handler.repos.TV.Delete(context.Background(), id1)
+
+			id2, err := handler.repos.TV.Create(context.Background(), watchingShow)
+			if err != nil {
+				t.Errorf("Failed to create watching show: %v", err)
+				return
+			}
+			defer handler.repos.TV.Delete(context.Background(), id2)
+
+			id3, err := handler.repos.TV.Create(context.Background(), watchedShow)
+			if err != nil {
+				t.Errorf("Failed to create watched show: %v", err)
+				return
+			}
+			defer handler.repos.TV.Delete(context.Background(), id3)
+
+			testCases := []string{"", "queued", "watching", "watched"}
+			for _, status := range testCases {
+				err = handler.List(context.Background(), status)
+				if err != nil {
+					t.Errorf("Failed to list TV shows with status '%s': %v", status, err)
+				}
+			}
+		})
+	})
+
+	t.Run("ErrorPaths", func(t *testing.T) {
+		handler := createTestTVHandler(t)
+		defer handler.Close()
+
+		ctx := context.Background()
+		nonExistentID := int64(999999)
+
+		testCases := []struct {
+			name string
+			fn   func() error
+		}{
+			{
+				name: "View non-existent show",
+				fn:   func() error { return handler.View(ctx, nonExistentID) },
+			},
+			{
+				name: "Update status of non-existent show",
+				fn:   func() error { return handler.UpdateStatus(ctx, nonExistentID, "watched") },
+			},
+			{
+				name: "Mark non-existent show as watching",
+				fn:   func() error { return handler.MarkWatching(ctx, nonExistentID) },
+			},
+			{
+				name: "Mark non-existent show as watched",
+				fn:   func() error { return handler.MarkWatched(ctx, nonExistentID) },
+			},
+			{
+				name: "Remove non-existent show",
+				fn:   func() error { return handler.Remove(ctx, nonExistentID) },
+			},
+		}
+
+		for _, tc := range testCases {
+			t.Run(tc.name, func(t *testing.T) {
+				err := tc.fn()
+				if err == nil {
+					t.Errorf("Expected error for %s", tc.name)
+				}
+			})
+		}
+	})
+
+	t.Run("ValidStatusValues", func(t *testing.T) {
+		handler := createTestTVHandler(t)
+		defer handler.Close()
+
+		valid := []string{"queued", "watching", "watched", "removed"}
+		invalid := []string{"invalid", "pending", "completed", ""}
+
+		for _, status := range valid {
+			if err := handler.UpdateStatus(context.Background(), 999, status); err != nil &&
+				err.Error() == fmt.Sprintf("invalid status: %s (valid: queued, watching, watched, removed)", status) {
+				t.Errorf("Status '%s' should be valid but was rejected", status)
+			}
+		}
+
+		for _, status := range invalid {
+			err := handler.UpdateStatus(context.Background(), 1, status)
+			if err == nil {
+				t.Errorf("Status '%s' should be invalid but was accepted", status)
+			}
+			got := fmt.Sprintf("invalid status: %s (valid: queued, watching, watched, removed)", status)
+			if err.Error() != got {
+				t.Errorf("Expected '%s', got: %v", got, err)
+			}
+		}
+	})
+}

internal/services/media.go

···
 	CertifiedFresh bool
 }
 
+type Person struct {
+	Name   string `json:"name"`
+	SameAs string `json:"sameAs"`
+	Image  string `json:"image"`
+}
+
+type AggregateRating struct {
+	RatingValue string `json:"ratingValue"`
+	RatingCount int    `json:"ratingCount"`
+	ReviewCount int    `json:"reviewCount"`
+}
+
+type Season struct {
+	Name string `json:"name"`
+	URL  string `json:"url"`
+}
+
+type PartOfSeries struct {
+	Name string `json:"name"`
+	URL  string `json:"url"`
+}
+
+type TVSeries struct {
+	Context         string          `json:"@context"`
+	Type            string          `json:"@type"`
+	Name            string          `json:"name"`
+	URL             string          `json:"url"`
+	Description     string          `json:"description"`
+	Image           string          `json:"image"`
+	Genre           []string        `json:"genre"`
+	ContentRating   string          `json:"contentRating"`
+	DateCreated     string          `json:"dateCreated"`
+	NumberOfSeasons int             `json:"numberOfSeasons"`
+	Actors          []Person        `json:"actor"`
+	Producers       []Person        `json:"producer"`
+	AggregateRating AggregateRating `json:"aggregateRating"`
+	Seasons         []Season        `json:"containsSeason"`
+}
+
+type Movie struct {
+	Context         string          `json:"@context"`
+	Type            string          `json:"@type"`
+	Name            string          `json:"name"`
+	URL             string          `json:"url"`
+	Description     string          `json:"description"`
+	Image           string          `json:"image"`
+	Genre           []string        `json:"genre"`
+	ContentRating   string          `json:"contentRating"`
+	DateCreated     string          `json:"dateCreated"`
+	Actors          []Person        `json:"actor"`
+	Directors       []Person        `json:"director"`
+	Producers       []Person        `json:"producer"`
+	AggregateRating AggregateRating `json:"aggregateRating"`
+}
+
+type TVSeason struct {
+	Context         string          `json:"@context"`
+	Type            string          `json:"@type"`
+	Name            string          `json:"name"`
+	URL             string          `json:"url"`
+	Description     string          `json:"description"`
+	Image           string          `json:"image"`
+	SeasonNumber    int             `json:"seasonNumber"`
+	DatePublished   string          `json:"datePublished"`
+	PartOfSeries    PartOfSeries    `json:"partOfSeries"`
+	AggregateRating AggregateRating `json:"aggregateRating"`
+}
+
+type MovieService struct {
+	client  *http.Client
+	limiter *rate.Limiter
+}
+
+type TVService struct {
+	client  *http.Client
+	limiter *rate.Limiter
+}
+
 // ParseSearch parses Rotten Tomatoes search results HTML into Media entries.
 func ParseSearch(r io.Reader) ([]Media, error) {
 	doc, err := goquery.NewDocumentFromReader(r)
···
 	return ParseSearch(strings.NewReader(html))
 }
 
-type Person struct {
-	Name   string `json:"name"`
-	SameAs string `json:"sameAs"`
-	Image  string `json:"image"`
-}
-
-type AggregateRating struct {
-	RatingValue string `json:"ratingValue"`
-	RatingCount int    `json:"ratingCount"`
-	ReviewCount int    `json:"reviewCount"`
-}
-
-type Season struct {
-	Name string `json:"name"`
-	URL  string `json:"url"`
-}
-
-type PartOfSeries struct {
-	Name string `json:"name"`
-	URL  string `json:"url"`
-}
-
-type TVSeries struct {
-	Context         string          `json:"@context"`
-	Type            string          `json:"@type"`
-	Name            string          `json:"name"`
-	URL             string          `json:"url"`
-	Description     string          `json:"description"`
-	Image           string          `json:"image"`
-	Genre           []string        `json:"genre"`
-	ContentRating   string          `json:"contentRating"`
-	DateCreated     string          `json:"dateCreated"`
-	NumberOfSeasons int             `json:"numberOfSeasons"`
-	Actors          []Person        `json:"actor"`
-	Producers       []Person        `json:"producer"`
-	AggregateRating AggregateRating `json:"aggregateRating"`
-	Seasons         []Season        `json:"containsSeason"`
-}
-
-type Movie struct {
-	Context         string          `json:"@context"`
-	Type            string          `json:"@type"`
-	Name            string          `json:"name"`
-	URL             string          `json:"url"`
-	Description     string          `json:"description"`
-	Image           string          `json:"image"`
-	Genre           []string        `json:"genre"`
-	ContentRating   string          `json:"contentRating"`
-	DateCreated     string          `json:"dateCreated"`
-	Actors          []Person        `json:"actor"`
-	Directors       []Person        `json:"director"`
-	Producers       []Person        `json:"producer"`
-	AggregateRating AggregateRating `json:"aggregateRating"`
-}
-
-type TVSeason struct {
-	Context         string          `json:"@context"`
-	Type            string          `json:"@type"`
-	Name            string          `json:"name"`
-	URL             string          `json:"url"`
-	Description     string          `json:"description"`
-	Image           string          `json:"image"`
-	SeasonNumber    int             `json:"seasonNumber"`
-	DatePublished   string          `json:"datePublished"`
-	PartOfSeries    PartOfSeries    `json:"partOfSeries"`
-	AggregateRating AggregateRating `json:"aggregateRating"`
-}
-
 func ExtractTVSeriesMetadata(r io.Reader) (*TVSeries, error) {
 	doc, err := goquery.NewDocumentFromReader(r)
 	if err != nil {
···
 	return ExtractTVSeasonMetadata(strings.NewReader(html))
 }
 
-type MovieService struct {
-	client  *http.Client
-	limiter *rate.Limiter
-}
-
 // NewMovieService creates a new movie service with rate limiting
 func NewMovieService() *MovieService {
 	return &MovieService{
···
 // Close cleans up the service resources
 func (s *MovieService) Close() error {
 	return nil
-}
-
-// TVService implements APIService for Rotten Tomatoes TV shows
-type TVService struct {
-	client  *http.Client
-	limiter *rate.Limiter
 }
 
 // NewTVService creates a new TV service with rate limiting

media.md

···
 
 ## Media Service Refactor
 
-### Create MovieService that implement APIService
+### Create MovieService that implement APIService (✓)
 
 ```go
 // MovieService implements APIService for Rotten Tomatoes movies
···
 }
 ```
 
-### Create TVService that implement APIService
+### Create TVService that implement APIService (✓)
 
 ```go
 // TVService implements APIService for Rotten Tomatoes TV shows
···
 }
 ```
 
-### Implement APIService
+### Implement APIService (✓)
 
 - `Search(ctx, query, page, limit)` - Use existing SearchRottenTomatoes() and convert results to []*models.Model
 - `Get(ctx, id)` - Use existing FetchMovie() / FetchTVSeries() with Rotten Tomatoes URLs
 - `Check(ctx)` - Simple connectivity test to Rotten Tomatoes
 - `Close()` - Cleanup resources
 
-### Result Conversion
+### Result Conversion (✓)
 
 - Convert services.Media search results to models.Movie / models.TVShow
 - Convert detailed metadata structs to models with proper status defaults
 - Extract key information (title, year, rating, description) into notes field
 
-## Handler Implementation
+## Handler Implementation (✓)
 
 ### Create MovieHandler similar to BookHandler
 
 ```go
 type MovieHandler struct {
     db      *store.Database
-    config*store.Config
+    config  *store.Config
     repos   *repo.Repositories
-    service*services.MovieService
+    service *services.MovieService
 }
 ```
 
-### Implement search
-
 - `SearchAndAddMovie(ctx, args, interactive)` - Mirror book search UX
 - `SearchAndAddTV(ctx, args, interactive)` - Same pattern for TV shows
 - Number-based selection interface identical to books
-
-### Database Integration
-
 - Add movie/TV repositories if not already present
 - Ensure proper CRUD operations for queue management