feat: concrete repository implementations

ROADMAP.md

···
 
 ## Core Task Management (TaskWarrior-inspired)
 
-- `add` - Add new task with description and optional metadata
 - `list` - Display tasks with filtering and sorting options
+- `projects` - List all project names
+- `tags` - List all tag names
+
+- `create` - Add new task with description and optional metadata
+
+- `view` - View task by ID
 - `done` - Mark task as completed
-- `delete` - Remove task permanently
-- `modify` - Edit task properties (description, priority, project, tags)
+- `update` - Edit task properties (description, priority, project, tags)
 - `start/stop` - Track active time on tasks
 - `annotate` - Add notes/comments to existing tasks
-- `projects` - List all project names
-- `tags` - List all tag names
+
+- `delete` - Remove task permanently
+
 - `calendar` - Display tasks in calendar view
 - `timesheet` - Show time tracking summaries
 
 ## Todo.txt Compatibility
 
 - `archive` - Move completed tasks to done.txt
-- `listcon` - List all contexts (@context)
-- `listproj` - List all projects (+project)
-- `pri` - Set task priority (A-Z)
-- `depri` - Remove priority from task
-- `replace` - Replace task text entirely
+- `[con]texts` - List all contexts (@context)
+- `[proj]ects` - List all projects (+project)
+- `[pri]ority` - Set task priority (A-Z)
+- `[depri]oritize` - Remove priority from task
+- `[re]place` - Replace task text entirely
 - `prepend/append` - Add text to beginning/end of task
 
 ## Media Queue Management
 
 - `movie add` - Add movie to watch queue
 - `movie list` - Show movie queue with ratings/metadata
-- `movie watched` - Mark movie as watched
-- `movie remove` - Remove from queue
+- `movie watched|seen` - Mark movie as watched
+- `movie remove|rm` - Remove from queue
+
 - `tv add` - Add TV show/season to queue
 - `tv list` - Show TV queue with episode tracking
-- `tv watched` - Mark episodes/seasons as watched
-- `tv remove` - Remove from TV queue
+- `tv watched|seen` - Mark episodes/seasons as watched
+- `tv remove|rm` - Remove from TV queue
 
 ## Reading List Management
 
 - `book add` - Add book to reading list
 - `book list` - Show reading queue with progress
 - `book reading` - Mark book as currently reading
-- `book finished` - Mark book as completed
-- `book remove` - Remove from reading list
+- `book finished|read` - Mark book as completed
+- `book remove|rm` - Remove from reading list
 - `book progress` - Update reading progress percentage
 
 ## Data Management
 
 - `sync` - Synchronize with remote storage
+- `sync setup` - Setup remote storage
+
 - `backup` - Create local backup
+
 - `import` - Import from various formats (CSV, JSON, todo.txt)
 - `export` - Export to various formats
+
 - `config` - Manage configuration settings
+
 - `undo` - Reverse last operation

go.mod

···
 	github.com/spf13/cobra v1.9.1
 )
 
+require github.com/google/uuid v1.6.0
+
 require (
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
 	github.com/charmbracelet/colorprofile v0.3.1 // indirect

go.sum

···
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/go-logfmt/logfmt v0.6.0 h1:wGYYu3uicYdqXVgoYbvnkrPVXkuLM1p1ifugDMEdRi4=
 github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=

internal/repo/book_repository.go

···
+package repo
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+	"time"
+
+	"stormlightlabs.org/noteleaf/internal/models"
+)
+
+// BookRepository provides database operations for books
+type BookRepository struct {
+	db *sql.DB
+}
+
+// NewBookRepository creates a new book repository
+func NewBookRepository(db *sql.DB) *BookRepository {
+	return &BookRepository{db: db}
+}
+
+// Create stores a new book and returns its assigned ID
+func (r *BookRepository) Create(ctx context.Context, book *models.Book) (int64, error) {
+	now := time.Now()
+	book.Added = now
+
+	query := `
+		INSERT INTO books (title, author, status, progress, pages, rating, notes, added, started, finished)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+
+	result, err := r.db.ExecContext(ctx, query,
+		book.Title, book.Author, book.Status, book.Progress, book.Pages, book.Rating,
+		book.Notes, book.Added, book.Started, book.Finished)
+	if err != nil {
+		return 0, fmt.Errorf("failed to insert book: %w", err)
+	}
+
+	id, err := result.LastInsertId()
+	if err != nil {
+		return 0, fmt.Errorf("failed to get last insert id: %w", err)
+	}
+
+	book.ID = id
+	return id, nil
+}
+
+// Get retrieves a book by ID
+func (r *BookRepository) Get(ctx context.Context, id int64) (*models.Book, error) {
+	query := `
+		SELECT id, title, author, status, progress, pages, rating, notes, added, started, finished
+		FROM books WHERE id = ?`
+
+	book := &models.Book{}
+	err := r.db.QueryRowContext(ctx, query, id).Scan(
+		&book.ID, &book.Title, &book.Author, &book.Status, &book.Progress, &book.Pages,
+		&book.Rating, &book.Notes, &book.Added, &book.Started, &book.Finished)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get book: %w", err)
+	}
+
+	return book, nil
+}
+
+// Update modifies an existing book
+func (r *BookRepository) Update(ctx context.Context, book *models.Book) error {
+	query := `
+		UPDATE books SET title = ?, author = ?, status = ?, progress = ?, pages = ?,
+		rating = ?, notes = ?, started = ?, finished = ?
+		WHERE id = ?`
+
+	_, err := r.db.ExecContext(ctx, query,
+		book.Title, book.Author, book.Status, book.Progress, book.Pages, book.Rating,
+		book.Notes, book.Started, book.Finished, book.ID)
+	if err != nil {
+		return fmt.Errorf("failed to update book: %w", err)
+	}
+
+	return nil
+}
+
+// Delete removes a book by ID
+func (r *BookRepository) Delete(ctx context.Context, id int64) error {
+	query := "DELETE FROM books WHERE id = ?"
+	_, err := r.db.ExecContext(ctx, query, id)
+	if err != nil {
+		return fmt.Errorf("failed to delete book: %w", err)
+	}
+	return nil
+}
+
+// List retrieves books with optional filtering and sorting
+func (r *BookRepository) List(ctx context.Context, opts BookListOptions) ([]*models.Book, error) {
+	query := r.buildListQuery(opts)
+	args := r.buildListArgs(opts)
+
+	rows, err := r.db.QueryContext(ctx, query, args...)
+	if err != nil {
+		return nil, fmt.Errorf("failed to list books: %w", err)
+	}
+	defer rows.Close()
+
+	var books []*models.Book
+	for rows.Next() {
+		book := &models.Book{}
+		if err := r.scanBookRow(rows, book); err != nil {
+			return nil, err
+		}
+		books = append(books, book)
+	}
+
+	return books, rows.Err()
+}
+
+func (r *BookRepository) buildListQuery(opts BookListOptions) string {
+	query := "SELECT id, title, author, status, progress, pages, rating, notes, added, started, finished FROM books"
+
+	var conditions []string
+
+	if opts.Status != "" {
+		conditions = append(conditions, "status = ?")
+	}
+	if opts.Author != "" {
+		conditions = append(conditions, "author = ?")
+	}
+	if opts.MinProgress > 0 {
+		conditions = append(conditions, "progress >= ?")
+	}
+	if opts.MinRating > 0 {
+		conditions = append(conditions, "rating >= ?")
+	}
+
+	if opts.Search != "" {
+		searchConditions := []string{
+			"title LIKE ?",
+			"author LIKE ?",
+			"notes LIKE ?",
+		}
+		conditions = append(conditions, fmt.Sprintf("(%s)", strings.Join(searchConditions, " OR ")))
+	}
+
+	if len(conditions) > 0 {
+		query += " WHERE " + strings.Join(conditions, " AND ")
+	}
+
+	if opts.SortBy != "" {
+		order := "ASC"
+		if strings.ToUpper(opts.SortOrder) == "DESC" {
+			order = "DESC"
+		}
+		query += fmt.Sprintf(" ORDER BY %s %s", opts.SortBy, order)
+	} else {
+		query += " ORDER BY added DESC"
+	}
+
+	if opts.Limit > 0 {
+		query += fmt.Sprintf(" LIMIT %d", opts.Limit)
+		if opts.Offset > 0 {
+			query += fmt.Sprintf(" OFFSET %d", opts.Offset)
+		}
+	}
+
+	return query
+}
+
+func (r *BookRepository) buildListArgs(opts BookListOptions) []any {
+	var args []any
+
+	if opts.Status != "" {
+		args = append(args, opts.Status)
+	}
+	if opts.Author != "" {
+		args = append(args, opts.Author)
+	}
+	if opts.MinProgress > 0 {
+		args = append(args, opts.MinProgress)
+	}
+	if opts.MinRating > 0 {
+		args = append(args, opts.MinRating)
+	}
+
+	if opts.Search != "" {
+		searchPattern := "%" + opts.Search + "%"
+		args = append(args, searchPattern, searchPattern, searchPattern)
+	}
+
+	return args
+}
+
+func (r *BookRepository) scanBookRow(rows *sql.Rows, book *models.Book) error {
+	return rows.Scan(&book.ID, &book.Title, &book.Author, &book.Status, &book.Progress, &book.Pages,
+		&book.Rating, &book.Notes, &book.Added, &book.Started, &book.Finished)
+}
+
+// Find retrieves books matching specific conditions
+func (r *BookRepository) Find(ctx context.Context, conditions BookListOptions) ([]*models.Book, error) {
+	return r.List(ctx, conditions)
+}
+
+// Count returns the number of books matching conditions
+func (r *BookRepository) Count(ctx context.Context, opts BookListOptions) (int64, error) {
+	query := "SELECT COUNT(*) FROM books"
+	args := []any{}
+
+	var conditions []string
+
+	if opts.Status != "" {
+		conditions = append(conditions, "status = ?")
+		args = append(args, opts.Status)
+	}
+	if opts.Author != "" {
+		conditions = append(conditions, "author = ?")
+		args = append(args, opts.Author)
+	}
+	if opts.MinProgress > 0 {
+		conditions = append(conditions, "progress >= ?")
+		args = append(args, opts.MinProgress)
+	}
+	if opts.MinRating > 0 {
+		conditions = append(conditions, "rating >= ?")
+		args = append(args, opts.MinRating)
+	}
+
+	if opts.Search != "" {
+		searchConditions := []string{
+			"title LIKE ?",
+			"author LIKE ?",
+			"notes LIKE ?",
+		}
+		conditions = append(conditions, fmt.Sprintf("(%s)", strings.Join(searchConditions, " OR ")))
+		searchPattern := "%" + opts.Search + "%"
+		args = append(args, searchPattern, searchPattern, searchPattern)
+	}
+
+	if len(conditions) > 0 {
+		query += " WHERE " + strings.Join(conditions, " AND ")
+	}
+
+	var count int64
+	err := r.db.QueryRowContext(ctx, query, args...).Scan(&count)
+	if err != nil {
+		return 0, fmt.Errorf("failed to count books: %w", err)
+	}
+
+	return count, nil
+}
+
+// GetQueued retrieves all books in the queue
+func (r *BookRepository) GetQueued(ctx context.Context) ([]*models.Book, error) {
+	return r.List(ctx, BookListOptions{Status: "queued"})
+}
+
+// GetReading retrieves all books currently being read
+func (r *BookRepository) GetReading(ctx context.Context) ([]*models.Book, error) {
+	return r.List(ctx, BookListOptions{Status: "reading"})
+}
+
+// GetFinished retrieves all finished books
+func (r *BookRepository) GetFinished(ctx context.Context) ([]*models.Book, error) {
+	return r.List(ctx, BookListOptions{Status: "finished"})
+}
+
+// GetByAuthor retrieves all books by a specific author
+func (r *BookRepository) GetByAuthor(ctx context.Context, author string) ([]*models.Book, error) {
+	return r.List(ctx, BookListOptions{Author: author})
+}
+
+// StartReading marks a book as started
+func (r *BookRepository) StartReading(ctx context.Context, id int64) error {
+	book, err := r.Get(ctx, id)
+	if err != nil {
+		return err
+	}
+
+	now := time.Now()
+	book.Status = "reading"
+	book.Started = &now
+
+	return r.Update(ctx, book)
+}
+
+// FinishReading marks a book as finished
+func (r *BookRepository) FinishReading(ctx context.Context, id int64) error {
+	book, err := r.Get(ctx, id)
+	if err != nil {
+		return err
+	}
+
+	now := time.Now()
+	book.Status = "finished"
+	book.Progress = 100
+	book.Finished = &now
+
+	return r.Update(ctx, book)
+}
+
+// UpdateProgress updates the reading progress of a book
+func (r *BookRepository) UpdateProgress(ctx context.Context, id int64, progress int) error {
+	book, err := r.Get(ctx, id)
+	if err != nil {
+		return err
+	}
+
+	book.Progress = progress
+
+	if progress >= 100 {
+		book.Status = "finished"
+		now := time.Now()
+		book.Finished = &now
+	} else if progress > 0 && book.Status == "queued" {
+		book.Status = "reading"
+		if book.Started == nil {
+			now := time.Now()
+			book.Started = &now
+		}
+	}
+
+	return r.Update(ctx, book)
+}
+
+// BookListOptions defines options for listing books
+type BookListOptions struct {
+	Status      string
+	Author      string
+	MinProgress int
+	MinRating   float64
+	Search      string
+	SortBy      string
+	SortOrder   string
+	Limit       int
+	Offset      int
+}

internal/repo/book_repository_test.go

···
+package repo
+
+import (
+	"context"
+	"database/sql"
+	"testing"
+	"time"
+
+	_ "github.com/mattn/go-sqlite3"
+	"stormlightlabs.org/noteleaf/internal/models"
+)
+
+func createBookTestDB(t *testing.T) *sql.DB {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to create in-memory database: %v", err)
+	}
+
+	if _, err := db.Exec("PRAGMA foreign_keys = ON"); err != nil {
+		t.Fatalf("Failed to enable foreign keys: %v", err)
+	}
+
+	schema := `
+		CREATE TABLE IF NOT EXISTS books (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			title TEXT NOT NULL,
+			author TEXT,
+			status TEXT DEFAULT 'queued',
+			progress INTEGER DEFAULT 0,
+			pages INTEGER,
+			rating REAL,
+			notes TEXT,
+			added DATETIME DEFAULT CURRENT_TIMESTAMP,
+			started DATETIME,
+			finished DATETIME
+		);
+	`
+
+	if _, err := db.Exec(schema); err != nil {
+		t.Fatalf("Failed to create schema: %v", err)
+	}
+
+	t.Cleanup(func() {
+		db.Close()
+	})
+
+	return db
+}
+
+func createSampleBook() *models.Book {
+	return &models.Book{
+		Title:    "Test Book",
+		Author:   "Test Author",
+		Status:   "queued",
+		Progress: 25,
+		Pages:    300,
+		Rating:   4.5,
+		Notes:    "Interesting read",
+	}
+}
+
+func TestBookRepository(t *testing.T) {
+	t.Run("CRUD Operations", func(t *testing.T) {
+		db := createBookTestDB(t)
+		repo := NewBookRepository(db)
+		ctx := context.Background()
+
+		t.Run("Create Book", func(t *testing.T) {
+			book := createSampleBook()
+
+			id, err := repo.Create(ctx, book)
+			if err != nil {
+				t.Errorf("Failed to create book: %v", err)
+			}
+
+			if id == 0 {
+				t.Error("Expected non-zero ID")
+			}
+
+			if book.ID != id {
+				t.Errorf("Expected book ID to be set to %d, got %d", id, book.ID)
+			}
+
+			if book.Added.IsZero() {
+				t.Error("Expected Added timestamp to be set")
+			}
+		})
+
+		t.Run("Get Book", func(t *testing.T) {
+			original := createSampleBook()
+			id, err := repo.Create(ctx, original)
+			if err != nil {
+				t.Fatalf("Failed to create book: %v", err)
+			}
+
+			retrieved, err := repo.Get(ctx, id)
+			if err != nil {
+				t.Errorf("Failed to get book: %v", err)
+			}
+
+			if retrieved.Title != original.Title {
+				t.Errorf("Expected title %s, got %s", original.Title, retrieved.Title)
+			}
+			if retrieved.Author != original.Author {
+				t.Errorf("Expected author %s, got %s", original.Author, retrieved.Author)
+			}
+			if retrieved.Status != original.Status {
+				t.Errorf("Expected status %s, got %s", original.Status, retrieved.Status)
+			}
+			if retrieved.Progress != original.Progress {
+				t.Errorf("Expected progress %d, got %d", original.Progress, retrieved.Progress)
+			}
+			if retrieved.Pages != original.Pages {
+				t.Errorf("Expected pages %d, got %d", original.Pages, retrieved.Pages)
+			}
+			if retrieved.Rating != original.Rating {
+				t.Errorf("Expected rating %f, got %f", original.Rating, retrieved.Rating)
+			}
+			if retrieved.Notes != original.Notes {
+				t.Errorf("Expected notes %s, got %s", original.Notes, retrieved.Notes)
+			}
+		})
+
+		t.Run("Update Book", func(t *testing.T) {
+			book := createSampleBook()
+			id, err := repo.Create(ctx, book)
+			if err != nil {
+				t.Fatalf("Failed to create book: %v", err)
+			}
+
+			book.Title = "Updated Book"
+			book.Status = "reading"
+			book.Progress = 50
+			book.Rating = 5.0
+			now := time.Now()
+			book.Started = &now
+
+			err = repo.Update(ctx, book)
+			if err != nil {
+				t.Errorf("Failed to update book: %v", err)
+			}
+
+			updated, err := repo.Get(ctx, id)
+			if err != nil {
+				t.Fatalf("Failed to get updated book: %v", err)
+			}
+
+			if updated.Title != "Updated Book" {
+				t.Errorf("Expected updated title, got %s", updated.Title)
+			}
+			if updated.Status != "reading" {
+				t.Errorf("Expected status reading, got %s", updated.Status)
+			}
+			if updated.Progress != 50 {
+				t.Errorf("Expected progress 50, got %d", updated.Progress)
+			}
+			if updated.Rating != 5.0 {
+				t.Errorf("Expected rating 5.0, got %f", updated.Rating)
+			}
+			if updated.Started == nil {
+				t.Error("Expected started time to be set")
+			}
+		})
+
+		t.Run("Delete Book", func(t *testing.T) {
+			book := createSampleBook()
+			id, err := repo.Create(ctx, book)
+			if err != nil {
+				t.Fatalf("Failed to create book: %v", err)
+			}
+
+			err = repo.Delete(ctx, id)
+			if err != nil {
+				t.Errorf("Failed to delete book: %v", err)
+			}
+
+			_, err = repo.Get(ctx, id)
+			if err == nil {
+				t.Error("Expected error when getting deleted book")
+			}
+		})
+	})
+
+	t.Run("List", func(t *testing.T) {
+		db := createBookTestDB(t)
+		repo := NewBookRepository(db)
+		ctx := context.Background()
+
+		books := []*models.Book{
+			{Title: "Book 1", Author: "Author A", Status: "queued", Progress: 0, Rating: 4.0},
+			{Title: "Book 2", Author: "Author A", Status: "reading", Progress: 50, Rating: 4.5},
+			{Title: "Book 3", Author: "Author B", Status: "finished", Progress: 100, Rating: 5.0},
+			{Title: "Book 4", Author: "Author C", Status: "queued", Progress: 0, Rating: 3.5},
+		}
+
+		for _, book := range books {
+			_, err := repo.Create(ctx, book)
+			if err != nil {
+				t.Fatalf("Failed to create book: %v", err)
+			}
+		}
+
+		t.Run("List All Books", func(t *testing.T) {
+			results, err := repo.List(ctx, BookListOptions{})
+			if err != nil {
+				t.Errorf("Failed to list books: %v", err)
+			}
+
+			if len(results) != 4 {
+				t.Errorf("Expected 4 books, got %d", len(results))
+			}
+		})
+
+		t.Run("List Books with Status Filter", func(t *testing.T) {
+			results, err := repo.List(ctx, BookListOptions{Status: "queued"})
+			if err != nil {
+				t.Errorf("Failed to list books: %v", err)
+			}
+
+			if len(results) != 2 {
+				t.Errorf("Expected 2 queued books, got %d", len(results))
+			}
+
+			for _, book := range results {
+				if book.Status != "queued" {
+					t.Errorf("Expected queued status, got %s", book.Status)
+				}
+			}
+		})
+
+		t.Run("List Books by Author", func(t *testing.T) {
+			results, err := repo.List(ctx, BookListOptions{Author: "Author A"})
+			if err != nil {
+				t.Errorf("Failed to list books: %v", err)
+			}
+
+			if len(results) != 2 {
+				t.Errorf("Expected 2 books by Author A, got %d", len(results))
+			}
+
+			for _, book := range results {
+				if book.Author != "Author A" {
+					t.Errorf("Expected author 'Author A', got %s", book.Author)
+				}
+			}
+		})
+
+		t.Run("List Books with Progress Filter", func(t *testing.T) {
+			results, err := repo.List(ctx, BookListOptions{MinProgress: 50})
+			if err != nil {
+				t.Errorf("Failed to list books: %v", err)
+			}
+
+			if len(results) != 2 {
+				t.Errorf("Expected 2 books with progress >= 50, got %d", len(results))
+			}
+
+			for _, book := range results {
+				if book.Progress < 50 {
+					t.Errorf("Expected progress >= 50, got %d", book.Progress)
+				}
+			}
+		})
+
+		t.Run("List Books with Rating Filter", func(t *testing.T) {
+			results, err := repo.List(ctx, BookListOptions{MinRating: 4.5})
+			if err != nil {
+				t.Errorf("Failed to list books: %v", err)
+			}
+
+			if len(results) != 2 {
+				t.Errorf("Expected 2 books with rating >= 4.5, got %d", len(results))
+			}
+
+			for _, book := range results {
+				if book.Rating < 4.5 {
+					t.Errorf("Expected rating >= 4.5, got %f", book.Rating)
+				}
+			}
+		})
+
+		t.Run("List Books with Search", func(t *testing.T) {
+			results, err := repo.List(ctx, BookListOptions{Search: "Book 1"})
+			if err != nil {
+				t.Errorf("Failed to list books: %v", err)
+			}
+
+			if len(results) != 1 {
+				t.Errorf("Expected 1 book matching search, got %d", len(results))
+			}
+
+			if len(results) > 0 && results[0].Title != "Book 1" {
+				t.Errorf("Expected 'Book 1', got %s", results[0].Title)
+			}
+		})
+
+		t.Run("List Books with Limit", func(t *testing.T) {
+			results, err := repo.List(ctx, BookListOptions{Limit: 2})
+			if err != nil {
+				t.Errorf("Failed to list books: %v", err)
+			}
+
+			if len(results) != 2 {
+				t.Errorf("Expected 2 books due to limit, got %d", len(results))
+			}
+		})
+	})
+
+	t.Run("Special Methods", func(t *testing.T) {
+		db := createBookTestDB(t)
+		repo := NewBookRepository(db)
+		ctx := context.Background()
+
+		book1 := &models.Book{Title: "Queued Book", Author: "Author A", Status: "queued", Progress: 0}
+		book2 := &models.Book{Title: "Reading Book", Author: "Author B", Status: "reading", Progress: 45}
+		book3 := &models.Book{Title: "Finished Book", Author: "Author C", Status: "finished", Progress: 100}
+		book4 := &models.Book{Title: "Another Book", Author: "Author A", Status: "queued", Progress: 0}
+
+		var book1ID int64
+		for _, book := range []*models.Book{book1, book2, book3, book4} {
+			id, err := repo.Create(ctx, book)
+			if err != nil {
+				t.Fatalf("Failed to create book: %v", err)
+			}
+			if book == book1 {
+				book1ID = id
+			}
+		}
+
+		t.Run("GetQueued", func(t *testing.T) {
+			results, err := repo.GetQueued(ctx)
+			if err != nil {
+				t.Errorf("Failed to get queued books: %v", err)
+			}
+
+			if len(results) != 2 {
+				t.Errorf("Expected 2 queued books, got %d", len(results))
+			}
+
+			for _, book := range results {
+				if book.Status != "queued" {
+					t.Errorf("Expected queued status, got %s", book.Status)
+				}
+			}
+		})
+
+		t.Run("GetReading", func(t *testing.T) {
+			results, err := repo.GetReading(ctx)
+			if err != nil {
+				t.Errorf("Failed to get reading books: %v", err)
+			}
+
+			if len(results) != 1 {
+				t.Errorf("Expected 1 reading book, got %d", len(results))
+			}
+
+			if len(results) > 0 && results[0].Status != "reading" {
+				t.Errorf("Expected reading status, got %s", results[0].Status)
+			}
+		})
+
+		t.Run("GetFinished", func(t *testing.T) {
+			results, err := repo.GetFinished(ctx)
+			if err != nil {
+				t.Errorf("Failed to get finished books: %v", err)
+			}
+
+			if len(results) != 1 {
+				t.Errorf("Expected 1 finished book, got %d", len(results))
+			}
+
+			if len(results) > 0 && results[0].Status != "finished" {
+				t.Errorf("Expected finished status, got %s", results[0].Status)
+			}
+		})
+
+		t.Run("GetByAuthor", func(t *testing.T) {
+			results, err := repo.GetByAuthor(ctx, "Author A")
+			if err != nil {
+				t.Errorf("Failed to get books by author: %v", err)
+			}
+
+			if len(results) != 2 {
+				t.Errorf("Expected 2 books by Author A, got %d", len(results))
+			}
+
+			for _, book := range results {
+				if book.Author != "Author A" {
+					t.Errorf("Expected author 'Author A', got %s", book.Author)
+				}
+			}
+		})
+
+		t.Run("StartReading", func(t *testing.T) {
+			err := repo.StartReading(ctx, book1ID)
+			if err != nil {
+				t.Errorf("Failed to start reading book: %v", err)
+			}
+
+			updated, err := repo.Get(ctx, book1ID)
+			if err != nil {
+				t.Fatalf("Failed to get updated book: %v", err)
+			}
+
+			if updated.Status != "reading" {
+				t.Errorf("Expected status to be reading, got %s", updated.Status)
+			}
+
+			if updated.Started == nil {
+				t.Error("Expected started timestamp to be set")
+			}
+		})
+
+		t.Run("FinishReading", func(t *testing.T) {
+			newBook := &models.Book{Title: "New Book", Status: "reading", Progress: 80}
+			id, err := repo.Create(ctx, newBook)
+			if err != nil {
+				t.Fatalf("Failed to create new book: %v", err)
+			}
+
+			err = repo.FinishReading(ctx, id)
+			if err != nil {
+				t.Errorf("Failed to finish reading book: %v", err)
+			}
+
+			updated, err := repo.Get(ctx, id)
+			if err != nil {
+				t.Fatalf("Failed to get updated book: %v", err)
+			}
+
+			if updated.Status != "finished" {
+				t.Errorf("Expected status to be finished, got %s", updated.Status)
+			}
+
+			if updated.Progress != 100 {
+				t.Errorf("Expected progress to be 100, got %d", updated.Progress)
+			}
+
+			if updated.Finished == nil {
+				t.Error("Expected finished timestamp to be set")
+			}
+		})
+
+		t.Run("UpdateProgress", func(t *testing.T) {
+			newBook := &models.Book{Title: "Progress Book", Status: "queued", Progress: 0}
+			id, err := repo.Create(ctx, newBook)
+			if err != nil {
+				t.Fatalf("Failed to create new book: %v", err)
+			}
+
+			err = repo.UpdateProgress(ctx, id, 25)
+			if err != nil {
+				t.Errorf("Failed to update progress: %v", err)
+			}
+
+			updated, err := repo.Get(ctx, id)
+			if err != nil {
+				t.Fatalf("Failed to get updated book: %v", err)
+			}
+
+			if updated.Status != "reading" {
+				t.Errorf("Expected status to be reading when progress > 0, got %s", updated.Status)
+			}
+
+			if updated.Progress != 25 {
+				t.Errorf("Expected progress 25, got %d", updated.Progress)
+			}
+
+			if updated.Started == nil {
+				t.Error("Expected started timestamp to be set when progress > 0")
+			}
+
+			err = repo.UpdateProgress(ctx, id, 100)
+			if err != nil {
+				t.Errorf("Failed to update progress to 100: %v", err)
+			}
+
+			updated, err = repo.Get(ctx, id)
+			if err != nil {
+				t.Fatalf("Failed to get updated book: %v", err)
+			}
+
+			if updated.Status != "finished" {
+				t.Errorf("Expected status to be finished when progress = 100, got %s", updated.Status)
+			}
+
+			if updated.Progress != 100 {
+				t.Errorf("Expected progress 100, got %d", updated.Progress)
+			}
+
+			if updated.Finished == nil {
+				t.Error("Expected finished timestamp to be set when progress = 100")
+			}
+		})
+	})
+
+	t.Run("Count", func(t *testing.T) {
+		db := createBookTestDB(t)
+		repo := NewBookRepository(db)
+		ctx := context.Background()
+
+		books := []*models.Book{
+			{Title: "Book 1", Status: "queued", Progress: 0, Rating: 4.0},
+			{Title: "Book 2", Status: "reading", Progress: 50, Rating: 3.5},
+			{Title: "Book 3", Status: "finished", Progress: 100, Rating: 5.0},
+			{Title: "Book 4", Status: "queued", Progress: 0, Rating: 4.5},
+		}
+
+		for _, book := range books {
+			_, err := repo.Create(ctx, book)
+			if err != nil {
+				t.Fatalf("Failed to create book: %v", err)
+			}
+		}
+
+		t.Run("Count all books", func(t *testing.T) {
+			count, err := repo.Count(ctx, BookListOptions{})
+			if err != nil {
+				t.Errorf("Failed to count books: %v", err)
+			}
+
+			if count != 4 {
+				t.Errorf("Expected 4 books, got %d", count)
+			}
+		})
+
+		t.Run("Count queued books", func(t *testing.T) {
+			count, err := repo.Count(ctx, BookListOptions{Status: "queued"})
+			if err != nil {
+				t.Errorf("Failed to count queued books: %v", err)
+			}
+
+			if count != 2 {
+				t.Errorf("Expected 2 queued books, got %d", count)
+			}
+		})
+
+		t.Run("Count books by progress", func(t *testing.T) {
+			count, err := repo.Count(ctx, BookListOptions{MinProgress: 50})
+			if err != nil {
+				t.Errorf("Failed to count books with progress >= 50: %v", err)
+			}
+
+			if count != 2 {
+				t.Errorf("Expected 2 books with progress >= 50, got %d", count)
+			}
+		})
+
+		t.Run("Count books by rating", func(t *testing.T) {
+			count, err := repo.Count(ctx, BookListOptions{MinRating: 4.0})
+			if err != nil {
+				t.Errorf("Failed to count high-rated books: %v", err)
+			}
+
+			if count != 3 {
+				t.Errorf("Expected 3 books with rating >= 4.0, got %d", count)
+			}
+		})
+	})
+}

internal/repo/movie_repository.go

···
+package repo
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+	"time"
+
+	"stormlightlabs.org/noteleaf/internal/models"
+)
+
+// MovieRepository provides database operations for movies
+type MovieRepository struct {
+	db *sql.DB
+}
+
+// NewMovieRepository creates a new movie repository
+func NewMovieRepository(db *sql.DB) *MovieRepository {
+	return &MovieRepository{db: db}
+}
+
+// Create stores a new movie and returns its assigned ID
+func (r *MovieRepository) Create(ctx context.Context, movie *models.Movie) (int64, error) {
+	now := time.Now()
+	movie.Added = now
+
+	query := `
+		INSERT INTO movies (title, year, status, rating, notes, added, watched)
+		VALUES (?, ?, ?, ?, ?, ?, ?)`
+
+	result, err := r.db.ExecContext(ctx, query,
+		movie.Title, movie.Year, movie.Status, movie.Rating, movie.Notes, movie.Added, movie.Watched)
+	if err != nil {
+		return 0, fmt.Errorf("failed to insert movie: %w", err)
+	}
+
+	id, err := result.LastInsertId()
+	if err != nil {
+		return 0, fmt.Errorf("failed to get last insert id: %w", err)
+	}
+
+	movie.ID = id
+	return id, nil
+}
+
+// Get retrieves a movie by ID
+func (r *MovieRepository) Get(ctx context.Context, id int64) (*models.Movie, error) {
+	query := `
+		SELECT id, title, year, status, rating, notes, added, watched
+		FROM movies WHERE id = ?`
+
+	movie := &models.Movie{}
+	err := r.db.QueryRowContext(ctx, query, id).Scan(
+		&movie.ID, &movie.Title, &movie.Year, &movie.Status, &movie.Rating,
+		&movie.Notes, &movie.Added, &movie.Watched)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get movie: %w", err)
+	}
+
+	return movie, nil
+}
+
+// Update modifies an existing movie
+func (r *MovieRepository) Update(ctx context.Context, movie *models.Movie) error {
+	query := `
+		UPDATE movies SET title = ?, year = ?, status = ?, rating = ?, notes = ?, watched = ?
+		WHERE id = ?`
+
+	_, err := r.db.ExecContext(ctx, query,
+		movie.Title, movie.Year, movie.Status, movie.Rating, movie.Notes, movie.Watched, movie.ID)
+	if err != nil {
+		return fmt.Errorf("failed to update movie: %w", err)
+	}
+
+	return nil
+}
+
+// Delete removes a movie by ID
+func (r *MovieRepository) Delete(ctx context.Context, id int64) error {
+	query := "DELETE FROM movies WHERE id = ?"
+	_, err := r.db.ExecContext(ctx, query, id)
+	if err != nil {
+		return fmt.Errorf("failed to delete movie: %w", err)
+	}
+	return nil
+}
+
+// List retrieves movies with optional filtering and sorting
+func (r *MovieRepository) List(ctx context.Context, opts MovieListOptions) ([]*models.Movie, error) {
+	query := r.buildListQuery(opts)
+	args := r.buildListArgs(opts)
+
+	rows, err := r.db.QueryContext(ctx, query, args...)
+	if err != nil {
+		return nil, fmt.Errorf("failed to list movies: %w", err)
+	}
+	defer rows.Close()
+
+	var movies []*models.Movie
+	for rows.Next() {
+		movie := &models.Movie{}
+		if err := r.scanMovieRow(rows, movie); err != nil {
+			return nil, err
+		}
+		movies = append(movies, movie)
+	}
+
+	return movies, rows.Err()
+}
+
+func (r *MovieRepository) buildListQuery(opts MovieListOptions) string {
+	query := "SELECT id, title, year, status, rating, notes, added, watched FROM movies"
+
+	var conditions []string
+
+	if opts.Status != "" {
+		conditions = append(conditions, "status = ?")
+	}
+	if opts.Year > 0 {
+		conditions = append(conditions, "year = ?")
+	}
+	if opts.MinRating > 0 {
+		conditions = append(conditions, "rating >= ?")
+	}
+
+	if opts.Search != "" {
+		searchConditions := []string{
+			"title LIKE ?",
+			"notes LIKE ?",
+		}
+		conditions = append(conditions, fmt.Sprintf("(%s)", strings.Join(searchConditions, " OR ")))
+	}
+
+	if len(conditions) > 0 {
+		query += " WHERE " + strings.Join(conditions, " AND ")
+	}
+
+	if opts.SortBy != "" {
+		order := "ASC"
+		if strings.ToUpper(opts.SortOrder) == "DESC" {
+			order = "DESC"
+		}
+		query += fmt.Sprintf(" ORDER BY %s %s", opts.SortBy, order)
+	} else {
+		query += " ORDER BY added DESC"
+	}
+
+	if opts.Limit > 0 {
+		query += fmt.Sprintf(" LIMIT %d", opts.Limit)
+		if opts.Offset > 0 {
+			query += fmt.Sprintf(" OFFSET %d", opts.Offset)
+		}
+	}
+
+	return query
+}
+
+func (r *MovieRepository) buildListArgs(opts MovieListOptions) []any {
+	var args []any
+
+	if opts.Status != "" {
+		args = append(args, opts.Status)
+	}
+	if opts.Year > 0 {
+		args = append(args, opts.Year)
+	}
+	if opts.MinRating > 0 {
+		args = append(args, opts.MinRating)
+	}
+
+	if opts.Search != "" {
+		searchPattern := "%" + opts.Search + "%"
+		args = append(args, searchPattern, searchPattern)
+	}
+
+	return args
+}
+
+func (r *MovieRepository) scanMovieRow(rows *sql.Rows, movie *models.Movie) error {
+	return rows.Scan(&movie.ID, &movie.Title, &movie.Year, &movie.Status, &movie.Rating,
+		&movie.Notes, &movie.Added, &movie.Watched)
+}
+
+// Find retrieves movies matching specific conditions
+func (r *MovieRepository) Find(ctx context.Context, conditions MovieListOptions) ([]*models.Movie, error) {
+	return r.List(ctx, conditions)
+}
+
+// Count returns the number of movies matching conditions
+func (r *MovieRepository) Count(ctx context.Context, opts MovieListOptions) (int64, error) {
+	query := "SELECT COUNT(*) FROM movies"
+	args := []any{}
+
+	var conditions []string
+
+	if opts.Status != "" {
+		conditions = append(conditions, "status = ?")
+		args = append(args, opts.Status)
+	}
+	if opts.Year > 0 {
+		conditions = append(conditions, "year = ?")
+		args = append(args, opts.Year)
+	}
+	if opts.MinRating > 0 {
+		conditions = append(conditions, "rating >= ?")
+		args = append(args, opts.MinRating)
+	}
+
+	if opts.Search != "" {
+		searchConditions := []string{
+			"title LIKE ?",
+			"notes LIKE ?",
+		}
+		conditions = append(conditions, fmt.Sprintf("(%s)", strings.Join(searchConditions, " OR ")))
+		searchPattern := "%" + opts.Search + "%"
+		args = append(args, searchPattern, searchPattern)
+	}
+
+	if len(conditions) > 0 {
+		query += " WHERE " + strings.Join(conditions, " AND ")
+	}
+
+	var count int64
+	err := r.db.QueryRowContext(ctx, query, args...).Scan(&count)
+	if err != nil {
+		return 0, fmt.Errorf("failed to count movies: %w", err)
+	}
+
+	return count, nil
+}
+
+// GetQueued retrieves all movies in the queue
+func (r *MovieRepository) GetQueued(ctx context.Context) ([]*models.Movie, error) {
+	return r.List(ctx, MovieListOptions{Status: "queued"})
+}
+
+// GetWatched retrieves all watched movies
+func (r *MovieRepository) GetWatched(ctx context.Context) ([]*models.Movie, error) {
+	return r.List(ctx, MovieListOptions{Status: "watched"})
+}
+
+// MarkWatched marks a movie as watched
+func (r *MovieRepository) MarkWatched(ctx context.Context, id int64) error {
+	movie, err := r.Get(ctx, id)
+	if err != nil {
+		return err
+	}
+
+	now := time.Now()
+	movie.Status = "watched"
+	movie.Watched = &now
+
+	return r.Update(ctx, movie)
+}
+
+// MovieListOptions defines options for listing movies
+type MovieListOptions struct {
+	Status    string
+	Year      int
+	MinRating float64
+	Search    string
+	SortBy    string
+	SortOrder string
+	Limit     int
+	Offset    int
+}

internal/repo/movie_repository_test.go

···
+package repo
+
+import (
+	"context"
+	"database/sql"
+	"testing"
+	"time"
+
+	_ "github.com/mattn/go-sqlite3"
+	"stormlightlabs.org/noteleaf/internal/models"
+)
+
+func createMovieTestDB(t *testing.T) *sql.DB {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to create in-memory database: %v", err)
+	}
+
+	if _, err := db.Exec("PRAGMA foreign_keys = ON"); err != nil {
+		t.Fatalf("Failed to enable foreign keys: %v", err)
+	}
+
+	schema := `
+		CREATE TABLE IF NOT EXISTS movies (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			title TEXT NOT NULL,
+			year INTEGER,
+			status TEXT DEFAULT 'queued',
+			rating REAL,
+			notes TEXT,
+			added DATETIME DEFAULT CURRENT_TIMESTAMP,
+			watched DATETIME
+		);
+	`
+
+	if _, err := db.Exec(schema); err != nil {
+		t.Fatalf("Failed to create schema: %v", err)
+	}
+
+	t.Cleanup(func() {
+		db.Close()
+	})
+
+	return db
+}
+
+func createSampleMovie() *models.Movie {
+	return &models.Movie{
+		Title:  "Test Movie",
+		Year:   2023,
+		Status: "queued",
+		Rating: 8.5,
+		Notes:  "Great movie to watch",
+	}
+}
+
+func TestMovieRepository(t *testing.T) {
+	t.Run("CRUD Operations", func(t *testing.T) {
+		db := createMovieTestDB(t)
+		repo := NewMovieRepository(db)
+		ctx := context.Background()
+
+		t.Run("Create Movie", func(t *testing.T) {
+			movie := createSampleMovie()
+
+			id, err := repo.Create(ctx, movie)
+			if err != nil {
+				t.Errorf("Failed to create movie: %v", err)
+			}
+
+			if id == 0 {
+				t.Error("Expected non-zero ID")
+			}
+
+			if movie.ID != id {
+				t.Errorf("Expected movie ID to be set to %d, got %d", id, movie.ID)
+			}
+
+			if movie.Added.IsZero() {
+				t.Error("Expected Added timestamp to be set")
+			}
+		})
+
+		t.Run("Get Movie", func(t *testing.T) {
+			original := createSampleMovie()
+			id, err := repo.Create(ctx, original)
+			if err != nil {
+				t.Fatalf("Failed to create movie: %v", err)
+			}
+
+			retrieved, err := repo.Get(ctx, id)
+			if err != nil {
+				t.Errorf("Failed to get movie: %v", err)
+			}
+
+			if retrieved.Title != original.Title {
+				t.Errorf("Expected title %s, got %s", original.Title, retrieved.Title)
+			}
+			if retrieved.Year != original.Year {
+				t.Errorf("Expected year %d, got %d", original.Year, retrieved.Year)
+			}
+			if retrieved.Status != original.Status {
+				t.Errorf("Expected status %s, got %s", original.Status, retrieved.Status)
+			}
+			if retrieved.Rating != original.Rating {
+				t.Errorf("Expected rating %f, got %f", original.Rating, retrieved.Rating)
+			}
+			if retrieved.Notes != original.Notes {
+				t.Errorf("Expected notes %s, got %s", original.Notes, retrieved.Notes)
+			}
+		})
+
+		t.Run("Update Movie", func(t *testing.T) {
+			movie := createSampleMovie()
+			id, err := repo.Create(ctx, movie)
+			if err != nil {
+				t.Fatalf("Failed to create movie: %v", err)
+			}
+
+			movie.Title = "Updated Movie"
+			movie.Status = "watched"
+			movie.Rating = 9.0
+			now := time.Now()
+			movie.Watched = &now
+
+			err = repo.Update(ctx, movie)
+			if err != nil {
+				t.Errorf("Failed to update movie: %v", err)
+			}
+
+			updated, err := repo.Get(ctx, id)
+			if err != nil {
+				t.Fatalf("Failed to get updated movie: %v", err)
+			}
+
+			if updated.Title != "Updated Movie" {
+				t.Errorf("Expected updated title, got %s", updated.Title)
+			}
+			if updated.Status != "watched" {
+				t.Errorf("Expected status watched, got %s", updated.Status)
+			}
+			if updated.Rating != 9.0 {
+				t.Errorf("Expected rating 9.0, got %f", updated.Rating)
+			}
+			if updated.Watched == nil {
+				t.Error("Expected watched time to be set")
+			}
+		})
+
+		t.Run("Delete Movie", func(t *testing.T) {
+			movie := createSampleMovie()
+			id, err := repo.Create(ctx, movie)
+			if err != nil {
+				t.Fatalf("Failed to create movie: %v", err)
+			}
+
+			err = repo.Delete(ctx, id)
+			if err != nil {
+				t.Errorf("Failed to delete movie: %v", err)
+			}
+
+			_, err = repo.Get(ctx, id)
+			if err == nil {
+				t.Error("Expected error when getting deleted movie")
+			}
+		})
+	})
+
+	t.Run("List", func(t *testing.T) {
+		db := createMovieTestDB(t)
+		repo := NewMovieRepository(db)
+		ctx := context.Background()
+
+		movies := []*models.Movie{
+			{Title: "Movie 1", Year: 2020, Status: "queued", Rating: 8.0},
+			{Title: "Movie 2", Year: 2021, Status: "watched", Rating: 7.5},
+			{Title: "Movie 3", Year: 2022, Status: "queued", Rating: 9.0},
+		}
+
+		for _, movie := range movies {
+			_, err := repo.Create(ctx, movie)
+			if err != nil {
+				t.Fatalf("Failed to create movie: %v", err)
+			}
+		}
+
+		t.Run("List All Movies", func(t *testing.T) {
+			results, err := repo.List(ctx, MovieListOptions{})
+			if err != nil {
+				t.Errorf("Failed to list movies: %v", err)
+			}
+
+			if len(results) != 3 {
+				t.Errorf("Expected 3 movies, got %d", len(results))
+			}
+		})
+
+		t.Run("List Movies with Status Filter", func(t *testing.T) {
+			results, err := repo.List(ctx, MovieListOptions{Status: "queued"})
+			if err != nil {
+				t.Errorf("Failed to list movies: %v", err)
+			}
+
+			if len(results) != 2 {
+				t.Errorf("Expected 2 queued movies, got %d", len(results))
+			}
+
+			for _, movie := range results {
+				if movie.Status != "queued" {
+					t.Errorf("Expected queued status, got %s", movie.Status)
+				}
+			}
+		})
+
+		t.Run("List Movies with Year Filter", func(t *testing.T) {
+			results, err := repo.List(ctx, MovieListOptions{Year: 2021})
+			if err != nil {
+				t.Errorf("Failed to list movies: %v", err)
+			}
+
+			if len(results) != 1 {
+				t.Errorf("Expected 1 movie from 2021, got %d", len(results))
+			}
+
+			if len(results) > 0 && results[0].Year != 2021 {
+				t.Errorf("Expected year 2021, got %d", results[0].Year)
+			}
+		})
+
+		t.Run("List Movies with Rating Filter", func(t *testing.T) {
+			results, err := repo.List(ctx, MovieListOptions{MinRating: 8.0})
+			if err != nil {
+				t.Errorf("Failed to list movies: %v", err)
+			}
+
+			if len(results) != 2 {
+				t.Errorf("Expected 2 movies with rating >= 8.0, got %d", len(results))
+			}
+
+			for _, movie := range results {
+				if movie.Rating < 8.0 {
+					t.Errorf("Expected rating >= 8.0, got %f", movie.Rating)
+				}
+			}
+		})
+
+		t.Run("List Movies with Search", func(t *testing.T) {
+			results, err := repo.List(ctx, MovieListOptions{Search: "Movie 1"})
+			if err != nil {
+				t.Errorf("Failed to list movies: %v", err)
+			}
+
+			if len(results) != 1 {
+				t.Errorf("Expected 1 movie matching search, got %d", len(results))
+			}
+
+			if len(results) > 0 && results[0].Title != "Movie 1" {
+				t.Errorf("Expected 'Movie 1', got %s", results[0].Title)
+			}
+		})
+
+		t.Run("List Movies with Limit", func(t *testing.T) {
+			results, err := repo.List(ctx, MovieListOptions{Limit: 2})
+			if err != nil {
+				t.Errorf("Failed to list movies: %v", err)
+			}
+
+			if len(results) != 2 {
+				t.Errorf("Expected 2 movies due to limit, got %d", len(results))
+			}
+		})
+	})
+
+	t.Run("Special Methods", func(t *testing.T) {
+		db := createMovieTestDB(t)
+		repo := NewMovieRepository(db)
+		ctx := context.Background()
+
+		movie1 := &models.Movie{Title: "Queued Movie", Status: "queued", Rating: 8.0}
+		movie2 := &models.Movie{Title: "Watched Movie", Status: "watched", Rating: 9.0}
+		movie3 := &models.Movie{Title: "Another Queued", Status: "queued", Rating: 7.0}
+
+		var movie1ID int64
+		for _, movie := range []*models.Movie{movie1, movie2, movie3} {
+			id, err := repo.Create(ctx, movie)
+			if err != nil {
+				t.Fatalf("Failed to create movie: %v", err)
+			}
+			if movie == movie1 {
+				movie1ID = id
+			}
+		}
+
+		t.Run("GetQueued", func(t *testing.T) {
+			results, err := repo.GetQueued(ctx)
+			if err != nil {
+				t.Errorf("Failed to get queued movies: %v", err)
+			}
+
+			if len(results) != 2 {
+				t.Errorf("Expected 2 queued movies, got %d", len(results))
+			}
+
+			for _, movie := range results {
+				if movie.Status != "queued" {
+					t.Errorf("Expected queued status, got %s", movie.Status)
+				}
+			}
+		})
+
+		t.Run("GetWatched", func(t *testing.T) {
+			results, err := repo.GetWatched(ctx)
+			if err != nil {
+				t.Errorf("Failed to get watched movies: %v", err)
+			}
+
+			if len(results) != 1 {
+				t.Errorf("Expected 1 watched movie, got %d", len(results))
+			}
+
+			if len(results) > 0 && results[0].Status != "watched" {
+				t.Errorf("Expected watched status, got %s", results[0].Status)
+			}
+		})
+
+		t.Run("MarkWatched", func(t *testing.T) {
+			err := repo.MarkWatched(ctx, movie1ID)
+			if err != nil {
+				t.Errorf("Failed to mark movie as watched: %v", err)
+			}
+
+			updated, err := repo.Get(ctx, movie1ID)
+			if err != nil {
+				t.Fatalf("Failed to get updated movie: %v", err)
+			}
+
+			if updated.Status != "watched" {
+				t.Errorf("Expected status to be watched, got %s", updated.Status)
+			}
+
+			if updated.Watched == nil {
+				t.Error("Expected watched timestamp to be set")
+			}
+		})
+	})
+
+	t.Run("Count", func(t *testing.T) {
+		db := createMovieTestDB(t)
+		repo := NewMovieRepository(db)
+		ctx := context.Background()
+
+		movies := []*models.Movie{
+			{Title: "Movie 1", Status: "queued", Rating: 8.0},
+			{Title: "Movie 2", Status: "watched", Rating: 7.0},
+			{Title: "Movie 3", Status: "queued", Rating: 9.0},
+		}
+
+		for _, movie := range movies {
+			_, err := repo.Create(ctx, movie)
+			if err != nil {
+				t.Fatalf("Failed to create movie: %v", err)
+			}
+		}
+
+		t.Run("Count all movies", func(t *testing.T) {
+			count, err := repo.Count(ctx, MovieListOptions{})
+			if err != nil {
+				t.Errorf("Failed to count movies: %v", err)
+			}
+
+			if count != 3 {
+				t.Errorf("Expected 3 movies, got %d", count)
+			}
+		})
+
+		t.Run("Count queued movies", func(t *testing.T) {
+			count, err := repo.Count(ctx, MovieListOptions{Status: "queued"})
+			if err != nil {
+				t.Errorf("Failed to count queued movies: %v", err)
+			}
+
+			if count != 2 {
+				t.Errorf("Expected 2 queued movies, got %d", count)
+			}
+		})
+
+		t.Run("Count movies by rating", func(t *testing.T) {
+			count, err := repo.Count(ctx, MovieListOptions{MinRating: 8.0})
+			if err != nil {
+				t.Errorf("Failed to count high-rated movies: %v", err)
+			}
+
+			if count != 2 {
+				t.Errorf("Expected 2 movies with rating >= 8.0, got %d", count)
+			}
+		})
+	})
+}

internal/repo/repo.go

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

internal/repo/repositories_test.go

···
+package repo
+
+import (
+	"context"
+	"database/sql"
+	"testing"
+
+	"github.com/google/uuid"
+	_ "github.com/mattn/go-sqlite3"
+	"stormlightlabs.org/noteleaf/internal/models"
+)
+
+func createFullTestDB(t *testing.T) *sql.DB {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to create in-memory database: %v", err)
+	}
+
+	if _, err := db.Exec("PRAGMA foreign_keys = ON"); err != nil {
+		t.Fatalf("Failed to enable foreign keys: %v", err)
+	}
+
+	// Create all tables
+	schema := `
+		-- Tasks table
+		CREATE TABLE IF NOT EXISTS tasks (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			uuid TEXT UNIQUE NOT NULL,
+			description TEXT NOT NULL,
+			status TEXT DEFAULT 'pending',
+			priority TEXT,
+			project TEXT,
+			tags TEXT,
+			due DATETIME,
+			entry DATETIME DEFAULT CURRENT_TIMESTAMP,
+			modified DATETIME DEFAULT CURRENT_TIMESTAMP,
+			end DATETIME,
+			start DATETIME,
+			annotations TEXT
+		);
+
+		-- Movies table
+		CREATE TABLE IF NOT EXISTS movies (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			title TEXT NOT NULL,
+			year INTEGER,
+			status TEXT DEFAULT 'queued',
+			rating REAL,
+			notes TEXT,
+			added DATETIME DEFAULT CURRENT_TIMESTAMP,
+			watched DATETIME
+		);
+
+		-- TV Shows table
+		CREATE TABLE IF NOT EXISTS tv_shows (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			title TEXT NOT NULL,
+			season INTEGER,
+			episode INTEGER,
+			status TEXT DEFAULT 'queued',
+			rating REAL,
+			notes TEXT,
+			added DATETIME DEFAULT CURRENT_TIMESTAMP,
+			last_watched DATETIME
+		);
+
+		-- Books table
+		CREATE TABLE IF NOT EXISTS books (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			title TEXT NOT NULL,
+			author TEXT,
+			status TEXT DEFAULT 'queued',
+			progress INTEGER DEFAULT 0,
+			pages INTEGER,
+			rating REAL,
+			notes TEXT,
+			added DATETIME DEFAULT CURRENT_TIMESTAMP,
+			started DATETIME,
+			finished DATETIME
+		);
+	`
+
+	if _, err := db.Exec(schema); err != nil {
+		t.Fatalf("Failed to create schema: %v", err)
+	}
+
+	t.Cleanup(func() {
+		db.Close()
+	})
+
+	return db
+}
+
+func TestRepositories(t *testing.T) {
+	t.Run("Integration", func(t *testing.T) {
+		db := createFullTestDB(t)
+		repos := NewRepositories(db)
+		ctx := context.Background()
+
+		t.Run("Create all resource types", func(t *testing.T) {
+			task := &models.Task{
+				UUID:        uuid.New().String(),
+				Description: "Integration test task",
+				Status:      "pending",
+				Project:     "integration",
+			}
+			taskID, err := repos.Tasks.Create(ctx, task)
+			if err != nil {
+				t.Errorf("Failed to create task: %v", err)
+			}
+			if taskID == 0 {
+				t.Error("Expected non-zero task ID")
+			}
+
+			movie := &models.Movie{
+				Title:  "Integration Movie",
+				Year:   2023,
+				Status: "queued",
+				Rating: 8.5,
+			}
+			movieID, err := repos.Movies.Create(ctx, movie)
+			if err != nil {
+				t.Errorf("Failed to create movie: %v", err)
+			}
+			if movieID == 0 {
+				t.Error("Expected non-zero movie ID")
+			}
+
+			tvShow := &models.TVShow{
+				Title:   "Integration Series",
+				Season:  1,
+				Episode: 1,
+				Status:  "queued",
+				Rating:  9.0,
+			}
+			tvID, err := repos.TV.Create(ctx, tvShow)
+			if err != nil {
+				t.Errorf("Failed to create TV show: %v", err)
+			}
+			if tvID == 0 {
+				t.Error("Expected non-zero TV show ID")
+			}
+
+			book := &models.Book{
+				Title:    "Integration Book",
+				Author:   "Test Author",
+				Status:   "queued",
+				Progress: 0,
+				Pages:    300,
+			}
+			bookID, err := repos.Books.Create(ctx, book)
+			if err != nil {
+				t.Errorf("Failed to create book: %v", err)
+			}
+			if bookID == 0 {
+				t.Error("Expected non-zero book ID")
+			}
+		})
+
+		t.Run("Retrieve all resources", func(t *testing.T) {
+			tasks, err := repos.Tasks.List(ctx, TaskListOptions{})
+			if err != nil {
+				t.Errorf("Failed to list tasks: %v", err)
+			}
+			if len(tasks) != 1 {
+				t.Errorf("Expected 1 task, got %d", len(tasks))
+			}
+
+			movies, err := repos.Movies.List(ctx, MovieListOptions{})
+			if err != nil {
+				t.Errorf("Failed to list movies: %v", err)
+			}
+			if len(movies) != 1 {
+				t.Errorf("Expected 1 movie, got %d", len(movies))
+			}
+
+			tvShows, err := repos.TV.List(ctx, TVListOptions{})
+			if err != nil {
+				t.Errorf("Failed to list TV shows: %v", err)
+			}
+			if len(tvShows) != 1 {
+				t.Errorf("Expected 1 TV show, got %d", len(tvShows))
+			}
+
+			books, err := repos.Books.List(ctx, BookListOptions{})
+			if err != nil {
+				t.Errorf("Failed to list books: %v", err)
+			}
+			if len(books) != 1 {
+				t.Errorf("Expected 1 book, got %d", len(books))
+			}
+		})
+
+		t.Run("Count all resources", func(t *testing.T) {
+			taskCount, err := repos.Tasks.Count(ctx, TaskListOptions{})
+			if err != nil {
+				t.Errorf("Failed to count tasks: %v", err)
+			}
+			if taskCount != 1 {
+				t.Errorf("Expected 1 task, got %d", taskCount)
+			}
+
+			movieCount, err := repos.Movies.Count(ctx, MovieListOptions{})
+			if err != nil {
+				t.Errorf("Failed to count movies: %v", err)
+			}
+			if movieCount != 1 {
+				t.Errorf("Expected 1 movie, got %d", movieCount)
+			}
+
+			tvCount, err := repos.TV.Count(ctx, TVListOptions{})
+			if err != nil {
+				t.Errorf("Failed to count TV shows: %v", err)
+			}
+			if tvCount != 1 {
+				t.Errorf("Expected 1 TV show, got %d", tvCount)
+			}
+
+			bookCount, err := repos.Books.Count(ctx, BookListOptions{})
+			if err != nil {
+				t.Errorf("Failed to count books: %v", err)
+			}
+			if bookCount != 1 {
+				t.Errorf("Expected 1 book, got %d", bookCount)
+			}
+		})
+
+		t.Run("Use specialized methods", func(t *testing.T) {
+			pendingTasks, err := repos.Tasks.GetPending(ctx)
+			if err != nil {
+				t.Errorf("Failed to get pending tasks: %v", err)
+			}
+			if len(pendingTasks) != 1 {
+				t.Errorf("Expected 1 pending task, got %d", len(pendingTasks))
+			}
+
+			queuedMovies, err := repos.Movies.GetQueued(ctx)
+			if err != nil {
+				t.Errorf("Failed to get queued movies: %v", err)
+			}
+			if len(queuedMovies) != 1 {
+				t.Errorf("Expected 1 queued movie, got %d", len(queuedMovies))
+			}
+
+			queuedTV, err := repos.TV.GetQueued(ctx)
+			if err != nil {
+				t.Errorf("Failed to get queued TV shows: %v", err)
+			}
+			if len(queuedTV) != 1 {
+				t.Errorf("Expected 1 queued TV show, got %d", len(queuedTV))
+			}
+
+			queuedBooks, err := repos.Books.GetQueued(ctx)
+			if err != nil {
+				t.Errorf("Failed to get queued books: %v", err)
+			}
+			if len(queuedBooks) != 1 {
+				t.Errorf("Expected 1 queued book, got %d", len(queuedBooks))
+			}
+		})
+	})
+
+	t.Run("New", func(t *testing.T) {
+		db := createFullTestDB(t)
+		repos := NewRepositories(db)
+
+		t.Run("All repositories are initialized", func(t *testing.T) {
+			if repos.Tasks == nil {
+				t.Error("Tasks repository should be initialized")
+			}
+			if repos.Movies == nil {
+				t.Error("Movies repository should be initialized")
+			}
+			if repos.TV == nil {
+				t.Error("TV repository should be initialized")
+			}
+			if repos.Books == nil {
+				t.Error("Books repository should be initialized")
+			}
+		})
+
+	})
+}

internal/repo/task_repository.go

···
+package repo
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+	"time"
+
+	"stormlightlabs.org/noteleaf/internal/models"
+)
+
+// TaskRepository provides database operations for tasks
+type TaskRepository struct {
+	db *sql.DB
+}
+
+// NewTaskRepository creates a new task repository
+func NewTaskRepository(db *sql.DB) *TaskRepository {
+	return &TaskRepository{db: db}
+}
+
+// Create stores a new task and returns its assigned ID
+func (r *TaskRepository) Create(ctx context.Context, task *models.Task) (int64, error) {
+	now := time.Now()
+	task.Entry = now
+	task.Modified = now
+
+	tags, err := task.MarshalTags()
+	if err != nil {
+		return 0, fmt.Errorf("failed to marshal tags: %w", err)
+	}
+
+	annotations, err := task.MarshalAnnotations()
+	if err != nil {
+		return 0, fmt.Errorf("failed to marshal annotations: %w", err)
+	}
+
+	query := `
+		INSERT INTO tasks (uuid, description, status, priority, project, tags, due, entry, modified, end, start, annotations)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+
+	result, err := r.db.ExecContext(ctx, query,
+		task.UUID, task.Description, task.Status, task.Priority, task.Project,
+		tags, task.Due, task.Entry, task.Modified, task.End, task.Start, annotations)
+	if err != nil {
+		return 0, fmt.Errorf("failed to insert task: %w", err)
+	}
+
+	id, err := result.LastInsertId()
+	if err != nil {
+		return 0, fmt.Errorf("failed to get last insert id: %w", err)
+	}
+
+	task.ID = id
+	return id, nil
+}
+
+// Get retrieves a task by ID
+func (r *TaskRepository) Get(ctx context.Context, id int64) (*models.Task, error) {
+	query := `
+		SELECT id, uuid, description, status, priority, project, tags, due, entry, modified, end, start, annotations
+		FROM tasks WHERE id = ?`
+
+	task := &models.Task{}
+	var tags, annotations sql.NullString
+
+	err := r.db.QueryRowContext(ctx, query, id).Scan(
+		&task.ID, &task.UUID, &task.Description, &task.Status, &task.Priority, &task.Project,
+		&tags, &task.Due, &task.Entry, &task.Modified, &task.End, &task.Start, &annotations)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get task: %w", err)
+	}
+
+	if tags.Valid {
+		if err := task.UnmarshalTags(tags.String); err != nil {
+			return nil, fmt.Errorf("failed to unmarshal tags: %w", err)
+		}
+	}
+
+	if annotations.Valid {
+		if err := task.UnmarshalAnnotations(annotations.String); err != nil {
+			return nil, fmt.Errorf("failed to unmarshal annotations: %w", err)
+		}
+	}
+
+	return task, nil
+}
+
+// Update modifies an existing task
+func (r *TaskRepository) Update(ctx context.Context, task *models.Task) error {
+	task.Modified = time.Now()
+
+	tags, err := task.MarshalTags()
+	if err != nil {
+		return fmt.Errorf("failed to marshal tags: %w", err)
+	}
+
+	annotations, err := task.MarshalAnnotations()
+	if err != nil {
+		return fmt.Errorf("failed to marshal annotations: %w", err)
+	}
+
+	query := `
+		UPDATE tasks SET uuid = ?, description = ?, status = ?, priority = ?, project = ?,
+		tags = ?, due = ?, modified = ?, end = ?, start = ?, annotations = ?
+		WHERE id = ?`
+
+	_, err = r.db.ExecContext(ctx, query,
+		task.UUID, task.Description, task.Status, task.Priority, task.Project,
+		tags, task.Due, task.Modified, task.End, task.Start, annotations, task.ID)
+	if err != nil {
+		return fmt.Errorf("failed to update task: %w", err)
+	}
+
+	return nil
+}
+
+// Delete removes a task by ID
+func (r *TaskRepository) Delete(ctx context.Context, id int64) error {
+	query := "DELETE FROM tasks WHERE id = ?"
+	_, err := r.db.ExecContext(ctx, query, id)
+	if err != nil {
+		return fmt.Errorf("failed to delete task: %w", err)
+	}
+	return nil
+}
+
+// List retrieves tasks with optional filtering and sorting
+func (r *TaskRepository) List(ctx context.Context, opts TaskListOptions) ([]*models.Task, error) {
+	query := r.buildListQuery(opts)
+	args := r.buildListArgs(opts)
+
+	rows, err := r.db.QueryContext(ctx, query, args...)
+	if err != nil {
+		return nil, fmt.Errorf("failed to list tasks: %w", err)
+	}
+	defer rows.Close()
+
+	var tasks []*models.Task
+	for rows.Next() {
+		task := &models.Task{}
+		if err := r.scanTaskRow(rows, task); err != nil {
+			return nil, err
+		}
+		tasks = append(tasks, task)
+	}
+
+	return tasks, rows.Err()
+}
+
+func (r *TaskRepository) buildListQuery(opts TaskListOptions) string {
+	query := "SELECT id, uuid, description, status, priority, project, tags, due, entry, modified, end, start, annotations FROM tasks"
+
+	var conditions []string
+
+	if opts.Status != "" {
+		conditions = append(conditions, "status = ?")
+	}
+	if opts.Priority != "" {
+		conditions = append(conditions, "priority = ?")
+	}
+	if opts.Project != "" {
+		conditions = append(conditions, "project = ?")
+	}
+	if !opts.DueAfter.IsZero() {
+		conditions = append(conditions, "due >= ?")
+	}
+	if !opts.DueBefore.IsZero() {
+		conditions = append(conditions, "due <= ?")
+	}
+
+	if opts.Search != "" {
+		searchConditions := []string{
+			"description LIKE ?",
+			"project LIKE ?",
+			"tags LIKE ?",
+		}
+		conditions = append(conditions, fmt.Sprintf("(%s)", strings.Join(searchConditions, " OR ")))
+	}
+
+	if len(conditions) > 0 {
+		query += " WHERE " + strings.Join(conditions, " AND ")
+	}
+
+	if opts.SortBy != "" {
+		order := "ASC"
+		if strings.ToUpper(opts.SortOrder) == "DESC" {
+			order = "DESC"
+		}
+		query += fmt.Sprintf(" ORDER BY %s %s", opts.SortBy, order)
+	} else {
+		query += " ORDER BY modified DESC"
+	}
+
+	if opts.Limit > 0 {
+		query += fmt.Sprintf(" LIMIT %d", opts.Limit)
+		if opts.Offset > 0 {
+			query += fmt.Sprintf(" OFFSET %d", opts.Offset)
+		}
+	}
+
+	return query
+}
+
+func (r *TaskRepository) buildListArgs(opts TaskListOptions) []any {
+	var args []any
+
+	if opts.Status != "" {
+		args = append(args, opts.Status)
+	}
+	if opts.Priority != "" {
+		args = append(args, opts.Priority)
+	}
+	if opts.Project != "" {
+		args = append(args, opts.Project)
+	}
+	if !opts.DueAfter.IsZero() {
+		args = append(args, opts.DueAfter)
+	}
+	if !opts.DueBefore.IsZero() {
+		args = append(args, opts.DueBefore)
+	}
+
+	// Search args
+	if opts.Search != "" {
+		searchPattern := "%" + opts.Search + "%"
+		// Add search pattern for each search field
+		args = append(args, searchPattern, searchPattern, searchPattern)
+	}
+
+	return args
+}
+
+func (r *TaskRepository) scanTaskRow(rows *sql.Rows, task *models.Task) error {
+	var tags, annotations sql.NullString
+
+	err := rows.Scan(&task.ID, &task.UUID, &task.Description, &task.Status, &task.Priority,
+		&task.Project, &tags, &task.Due, &task.Entry, &task.Modified, &task.End, &task.Start, &annotations)
+	if err != nil {
+		return fmt.Errorf("failed to scan task row: %w", err)
+	}
+
+	if tags.Valid {
+		if err := task.UnmarshalTags(tags.String); err != nil {
+			return fmt.Errorf("failed to unmarshal tags: %w", err)
+		}
+	}
+
+	if annotations.Valid {
+		if err := task.UnmarshalAnnotations(annotations.String); err != nil {
+			return fmt.Errorf("failed to unmarshal annotations: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// Find retrieves tasks matching specific conditions
+func (r *TaskRepository) Find(ctx context.Context, conditions TaskListOptions) ([]*models.Task, error) {
+	return r.List(ctx, conditions)
+}
+
+// Count returns the number of tasks matching conditions
+func (r *TaskRepository) Count(ctx context.Context, opts TaskListOptions) (int64, error) {
+	query := "SELECT COUNT(*) FROM tasks"
+	args := []any{}
+
+	var conditions []string
+
+	if opts.Status != "" {
+		conditions = append(conditions, "status = ?")
+		args = append(args, opts.Status)
+	}
+	if opts.Priority != "" {
+		conditions = append(conditions, "priority = ?")
+		args = append(args, opts.Priority)
+	}
+	if opts.Project != "" {
+		conditions = append(conditions, "project = ?")
+		args = append(args, opts.Project)
+	}
+	if !opts.DueAfter.IsZero() {
+		conditions = append(conditions, "due >= ?")
+		args = append(args, opts.DueAfter)
+	}
+	if !opts.DueBefore.IsZero() {
+		conditions = append(conditions, "due <= ?")
+		args = append(args, opts.DueBefore)
+	}
+
+	if opts.Search != "" {
+		searchConditions := []string{
+			"description LIKE ?",
+			"project LIKE ?",
+			"tags LIKE ?",
+		}
+		conditions = append(conditions, fmt.Sprintf("(%s)", strings.Join(searchConditions, " OR ")))
+		searchPattern := "%" + opts.Search + "%"
+		args = append(args, searchPattern, searchPattern, searchPattern)
+	}
+
+	if len(conditions) > 0 {
+		query += " WHERE " + strings.Join(conditions, " AND ")
+	}
+
+	var count int64
+	err := r.db.QueryRowContext(ctx, query, args...).Scan(&count)
+	if err != nil {
+		return 0, fmt.Errorf("failed to count tasks: %w", err)
+	}
+
+	return count, nil
+}
+
+// GetByUUID retrieves a task by UUID
+func (r *TaskRepository) GetByUUID(ctx context.Context, uuid string) (*models.Task, error) {
+	query := `
+		SELECT id, uuid, description, status, priority, project, tags, due, entry, modified, end, start, annotations
+		FROM tasks WHERE uuid = ?`
+
+	task := &models.Task{}
+	var tags, annotations sql.NullString
+
+	err := r.db.QueryRowContext(ctx, query, uuid).Scan(
+		&task.ID, &task.UUID, &task.Description, &task.Status, &task.Priority, &task.Project,
+		&tags, &task.Due, &task.Entry, &task.Modified, &task.End, &task.Start, &annotations)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get task by UUID: %w", err)
+	}
+
+	if tags.Valid {
+		if err := task.UnmarshalTags(tags.String); err != nil {
+			return nil, fmt.Errorf("failed to unmarshal tags: %w", err)
+		}
+	}
+
+	if annotations.Valid {
+		if err := task.UnmarshalAnnotations(annotations.String); err != nil {
+			return nil, fmt.Errorf("failed to unmarshal annotations: %w", err)
+		}
+	}
+
+	return task, nil
+}
+
+// GetPending retrieves all pending tasks
+func (r *TaskRepository) GetPending(ctx context.Context) ([]*models.Task, error) {
+	return r.List(ctx, TaskListOptions{Status: "pending"})
+}
+
+// GetCompleted retrieves all completed tasks
+func (r *TaskRepository) GetCompleted(ctx context.Context) ([]*models.Task, error) {
+	return r.List(ctx, TaskListOptions{Status: "completed"})
+}
+
+// GetByProject retrieves all tasks for a specific project
+func (r *TaskRepository) GetByProject(ctx context.Context, project string) ([]*models.Task, error) {
+	return r.List(ctx, TaskListOptions{Project: project})
+}
+
+// TaskListOptions defines options for listing tasks
+type TaskListOptions struct {
+	Status    string
+	Priority  string
+	Project   string
+	DueAfter  time.Time
+	DueBefore time.Time
+	Search    string
+	SortBy    string
+	SortOrder string
+	Limit     int
+	Offset    int
+}

internal/repo/task_repository_test.go

···
+package repo
+
+import (
+	"context"
+	"database/sql"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	_ "github.com/mattn/go-sqlite3"
+	"stormlightlabs.org/noteleaf/internal/models"
+)
+
+func createTaskTestDB(t *testing.T) *sql.DB {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to create in-memory database: %v", err)
+	}
+
+	if _, err := db.Exec("PRAGMA foreign_keys = ON"); err != nil {
+		t.Fatalf("Failed to enable foreign keys: %v", err)
+	}
+
+	schema := `
+		CREATE TABLE IF NOT EXISTS tasks (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			uuid TEXT UNIQUE NOT NULL,
+			description TEXT NOT NULL,
+			status TEXT DEFAULT 'pending',
+			priority TEXT,
+			project TEXT,
+			tags TEXT,
+			due DATETIME,
+			entry DATETIME DEFAULT CURRENT_TIMESTAMP,
+			modified DATETIME DEFAULT CURRENT_TIMESTAMP,
+			end DATETIME,
+			start DATETIME,
+			annotations TEXT
+		);
+	`
+
+	if _, err := db.Exec(schema); err != nil {
+		t.Fatalf("Failed to create schema: %v", err)
+	}
+
+	t.Cleanup(func() {
+		db.Close()
+	})
+
+	return db
+}
+
+func createSampleTask() *models.Task {
+	return &models.Task{
+		UUID:        uuid.New().String(),
+		Description: "Test task",
+		Status:      "pending",
+		Priority:    "H",
+		Project:     "test-project",
+		Tags:        []string{"test", "important"},
+		Annotations: []string{"This is a test", "Another annotation"},
+	}
+}
+
+func TestTaskRepository_CRUD(t *testing.T) {
+	db := createTaskTestDB(t)
+	repo := NewTaskRepository(db)
+	ctx := context.Background()
+
+	t.Run("Create Task", func(t *testing.T) {
+		task := createSampleTask()
+
+		id, err := repo.Create(ctx, task)
+		if err != nil {
+			t.Errorf("Failed to create task: %v", err)
+		}
+
+		if id == 0 {
+			t.Error("Expected non-zero ID")
+		}
+
+		if task.ID != id {
+			t.Errorf("Expected task ID to be set to %d, got %d", id, task.ID)
+		}
+
+		if task.Entry.IsZero() {
+			t.Error("Expected Entry timestamp to be set")
+		}
+		if task.Modified.IsZero() {
+			t.Error("Expected Modified timestamp to be set")
+		}
+	})
+
+	t.Run("Get Task", func(t *testing.T) {
+		original := createSampleTask()
+		id, err := repo.Create(ctx, original)
+		if err != nil {
+			t.Fatalf("Failed to create task: %v", err)
+		}
+
+		retrieved, err := repo.Get(ctx, id)
+		if err != nil {
+			t.Errorf("Failed to get task: %v", err)
+		}
+
+		if retrieved.UUID != original.UUID {
+			t.Errorf("Expected UUID %s, got %s", original.UUID, retrieved.UUID)
+		}
+		if retrieved.Description != original.Description {
+			t.Errorf("Expected description %s, got %s", original.Description, retrieved.Description)
+		}
+		if retrieved.Status != original.Status {
+			t.Errorf("Expected status %s, got %s", original.Status, retrieved.Status)
+		}
+		if retrieved.Priority != original.Priority {
+			t.Errorf("Expected priority %s, got %s", original.Priority, retrieved.Priority)
+		}
+		if retrieved.Project != original.Project {
+			t.Errorf("Expected project %s, got %s", original.Project, retrieved.Project)
+		}
+
+		if len(retrieved.Tags) != len(original.Tags) {
+			t.Errorf("Expected %d tags, got %d", len(original.Tags), len(retrieved.Tags))
+		}
+		for i, tag := range original.Tags {
+			if i < len(retrieved.Tags) && retrieved.Tags[i] != tag {
+				t.Errorf("Expected tag %s, got %s", tag, retrieved.Tags[i])
+			}
+		}
+
+		if len(retrieved.Annotations) != len(original.Annotations) {
+			t.Errorf("Expected %d annotations, got %d", len(original.Annotations), len(retrieved.Annotations))
+		}
+	})
+
+	t.Run("Update Task", func(t *testing.T) {
+		task := createSampleTask()
+		id, err := repo.Create(ctx, task)
+		if err != nil {
+			t.Fatalf("Failed to create task: %v", err)
+		}
+
+		task.Description = "Updated description"
+		task.Status = "completed"
+		task.Priority = "L"
+		now := time.Now()
+		task.End = &now
+
+		err = repo.Update(ctx, task)
+		if err != nil {
+			t.Errorf("Failed to update task: %v", err)
+		}
+
+		updated, err := repo.Get(ctx, id)
+		if err != nil {
+			t.Fatalf("Failed to get updated task: %v", err)
+		}
+
+		if updated.Description != "Updated description" {
+			t.Errorf("Expected updated description, got %s", updated.Description)
+		}
+		if updated.Status != "completed" {
+			t.Errorf("Expected status completed, got %s", updated.Status)
+		}
+		if updated.Priority != "L" {
+			t.Errorf("Expected priority L, got %s", updated.Priority)
+		}
+		if updated.End == nil {
+			t.Error("Expected end time to be set")
+		}
+	})
+
+	t.Run("Delete Task", func(t *testing.T) {
+		task := createSampleTask()
+		id, err := repo.Create(ctx, task)
+		if err != nil {
+			t.Fatalf("Failed to create task: %v", err)
+		}
+
+		err = repo.Delete(ctx, id)
+		if err != nil {
+			t.Errorf("Failed to delete task: %v", err)
+		}
+
+		_, err = repo.Get(ctx, id)
+		if err == nil {
+			t.Error("Expected error when getting deleted task")
+		}
+	})
+}
+
+func TestTaskRepository_List(t *testing.T) {
+	db := createTaskTestDB(t)
+	repo := NewTaskRepository(db)
+	ctx := context.Background()
+
+	tasks := []*models.Task{
+		{UUID: uuid.New().String(), Description: "Task 1", Status: "pending", Project: "proj1"},
+		{UUID: uuid.New().String(), Description: "Task 2", Status: "completed", Project: "proj1"},
+		{UUID: uuid.New().String(), Description: "Task 3", Status: "pending", Project: "proj2"},
+	}
+
+	for _, task := range tasks {
+		_, err := repo.Create(ctx, task)
+		if err != nil {
+			t.Fatalf("Failed to create task: %v", err)
+		}
+	}
+
+	t.Run("List All Tasks", func(t *testing.T) {
+		results, err := repo.List(ctx, TaskListOptions{})
+		if err != nil {
+			t.Errorf("Failed to list tasks: %v", err)
+		}
+
+		if len(results) != 3 {
+			t.Errorf("Expected 3 tasks, got %d", len(results))
+		}
+	})
+
+	t.Run("List Tasks with Filter", func(t *testing.T) {
+		results, err := repo.List(ctx, TaskListOptions{Status: "pending"})
+		if err != nil {
+			t.Errorf("Failed to list tasks: %v", err)
+		}
+
+		if len(results) != 2 {
+			t.Errorf("Expected 2 pending tasks, got %d", len(results))
+		}
+
+		for _, task := range results {
+			if task.Status != "pending" {
+				t.Errorf("Expected pending status, got %s", task.Status)
+			}
+		}
+	})
+
+	t.Run("List Tasks with Limit", func(t *testing.T) {
+		results, err := repo.List(ctx, TaskListOptions{Limit: 2})
+		if err != nil {
+			t.Errorf("Failed to list tasks: %v", err)
+		}
+
+		if len(results) != 2 {
+			t.Errorf("Expected 2 tasks due to limit, got %d", len(results))
+		}
+	})
+
+	t.Run("List Tasks with Search", func(t *testing.T) {
+		results, err := repo.List(ctx, TaskListOptions{Search: "Task 1"})
+		if err != nil {
+			t.Errorf("Failed to list tasks: %v", err)
+		}
+
+		if len(results) != 1 {
+			t.Errorf("Expected 1 task matching search, got %d", len(results))
+		}
+
+		if len(results) > 0 && results[0].Description != "Task 1" {
+			t.Errorf("Expected 'Task 1', got %s", results[0].Description)
+		}
+	})
+}
+
+func TestTaskRepository_SpecialMethods(t *testing.T) {
+	db := createTaskTestDB(t)
+	repo := NewTaskRepository(db)
+	ctx := context.Background()
+
+	task1 := &models.Task{UUID: uuid.New().String(), Description: "Pending task", Status: "pending", Project: "test"}
+	task2 := &models.Task{UUID: uuid.New().String(), Description: "Completed task", Status: "completed", Project: "test"}
+	task3 := &models.Task{UUID: uuid.New().String(), Description: "Other project", Status: "pending", Project: "other"}
+
+	for _, task := range []*models.Task{task1, task2, task3} {
+		_, err := repo.Create(ctx, task)
+		if err != nil {
+			t.Fatalf("Failed to create task: %v", err)
+		}
+	}
+
+	t.Run("GetPending", func(t *testing.T) {
+		results, err := repo.GetPending(ctx)
+		if err != nil {
+			t.Errorf("Failed to get pending tasks: %v", err)
+		}
+
+		if len(results) != 2 {
+			t.Errorf("Expected 2 pending tasks, got %d", len(results))
+		}
+	})
+
+	t.Run("GetCompleted", func(t *testing.T) {
+		results, err := repo.GetCompleted(ctx)
+		if err != nil {
+			t.Errorf("Failed to get completed tasks: %v", err)
+		}
+
+		if len(results) != 1 {
+			t.Errorf("Expected 1 completed task, got %d", len(results))
+		}
+	})
+
+	t.Run("GetByProject", func(t *testing.T) {
+		results, err := repo.GetByProject(ctx, "test")
+		if err != nil {
+			t.Errorf("Failed to get tasks by project: %v", err)
+		}
+
+		if len(results) != 2 {
+			t.Errorf("Expected 2 tasks in test project, got %d", len(results))
+		}
+
+		for _, task := range results {
+			if task.Project != "test" {
+				t.Errorf("Expected project 'test', got %s", task.Project)
+			}
+		}
+	})
+
+	t.Run("GetByUUID", func(t *testing.T) {
+		result, err := repo.GetByUUID(ctx, task1.UUID)
+		if err != nil {
+			t.Errorf("Failed to get task by UUID: %v", err)
+		}
+
+		if result.UUID != task1.UUID {
+			t.Errorf("Expected UUID %s, got %s", task1.UUID, result.UUID)
+		}
+		if result.Description != task1.Description {
+			t.Errorf("Expected description %s, got %s", task1.Description, result.Description)
+		}
+	})
+}
+
+func TestTaskRepository_Count(t *testing.T) {
+	db := createTaskTestDB(t)
+	repo := NewTaskRepository(db)
+	ctx := context.Background()
+
+	tasks := []*models.Task{
+		{UUID: uuid.New().String(), Description: "Test 1", Status: "pending"},
+		{UUID: uuid.New().String(), Description: "Test 2", Status: "pending"},
+		{UUID: uuid.New().String(), Description: "Test 3", Status: "completed"},
+	}
+
+	for _, task := range tasks {
+		_, err := repo.Create(ctx, task)
+		if err != nil {
+			t.Fatalf("Failed to create task: %v", err)
+		}
+	}
+
+	t.Run("Count all tasks", func(t *testing.T) {
+		count, err := repo.Count(ctx, TaskListOptions{})
+		if err != nil {
+			t.Errorf("Failed to count tasks: %v", err)
+		}
+
+		if count != 3 {
+			t.Errorf("Expected 3 tasks, got %d", count)
+		}
+	})
+
+	t.Run("Count pending tasks", func(t *testing.T) {
+		count, err := repo.Count(ctx, TaskListOptions{Status: "pending"})
+		if err != nil {
+			t.Errorf("Failed to count pending tasks: %v", err)
+		}
+
+		if count != 2 {
+			t.Errorf("Expected 2 pending tasks, got %d", count)
+		}
+	})
+
+	t.Run("Count completed tasks", func(t *testing.T) {
+		count, err := repo.Count(ctx, TaskListOptions{Status: "completed"})
+		if err != nil {
+			t.Errorf("Failed to count completed tasks: %v", err)
+		}
+
+		if count != 1 {
+			t.Errorf("Expected 1 completed task, got %d", count)
+		}
+	})
+}

internal/repo/tv_repository.go

···
+package repo
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+	"time"
+
+	"stormlightlabs.org/noteleaf/internal/models"
+)
+
+// TVRepository provides database operations for TV shows
+type TVRepository struct {
+	db *sql.DB
+}
+
+// NewTVRepository creates a new TV show repository
+func NewTVRepository(db *sql.DB) *TVRepository {
+	return &TVRepository{db: db}
+}
+
+// Create stores a new TV show and returns its assigned ID
+func (r *TVRepository) Create(ctx context.Context, tvShow *models.TVShow) (int64, error) {
+	now := time.Now()
+	tvShow.Added = now
+
+	query := `
+		INSERT INTO tv_shows (title, season, episode, status, rating, notes, added, last_watched)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+
+	result, err := r.db.ExecContext(ctx, query,
+		tvShow.Title, tvShow.Season, tvShow.Episode, tvShow.Status, tvShow.Rating,
+		tvShow.Notes, tvShow.Added, tvShow.LastWatched)
+	if err != nil {
+		return 0, fmt.Errorf("failed to insert TV show: %w", err)
+	}
+
+	id, err := result.LastInsertId()
+	if err != nil {
+		return 0, fmt.Errorf("failed to get last insert id: %w", err)
+	}
+
+	tvShow.ID = id
+	return id, nil
+}
+
+// Get retrieves a TV show by ID
+func (r *TVRepository) Get(ctx context.Context, id int64) (*models.TVShow, error) {
+	query := `
+		SELECT id, title, season, episode, status, rating, notes, added, last_watched
+		FROM tv_shows WHERE id = ?`
+
+	tvShow := &models.TVShow{}
+	err := r.db.QueryRowContext(ctx, query, id).Scan(
+		&tvShow.ID, &tvShow.Title, &tvShow.Season, &tvShow.Episode, &tvShow.Status,
+		&tvShow.Rating, &tvShow.Notes, &tvShow.Added, &tvShow.LastWatched)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get TV show: %w", err)
+	}
+
+	return tvShow, nil
+}
+
+// Update modifies an existing TV show
+func (r *TVRepository) Update(ctx context.Context, tvShow *models.TVShow) error {
+	query := `
+		UPDATE tv_shows SET title = ?, season = ?, episode = ?, status = ?, rating = ?,
+		notes = ?, last_watched = ?
+		WHERE id = ?`
+
+	_, err := r.db.ExecContext(ctx, query,
+		tvShow.Title, tvShow.Season, tvShow.Episode, tvShow.Status, tvShow.Rating,
+		tvShow.Notes, tvShow.LastWatched, tvShow.ID)
+	if err != nil {
+		return fmt.Errorf("failed to update TV show: %w", err)
+	}
+
+	return nil
+}
+
+// Delete removes a TV show by ID
+func (r *TVRepository) Delete(ctx context.Context, id int64) error {
+	query := "DELETE FROM tv_shows WHERE id = ?"
+	_, err := r.db.ExecContext(ctx, query, id)
+	if err != nil {
+		return fmt.Errorf("failed to delete TV show: %w", err)
+	}
+	return nil
+}
+
+// List retrieves TV shows with optional filtering and sorting
+func (r *TVRepository) List(ctx context.Context, opts TVListOptions) ([]*models.TVShow, error) {
+	query := r.buildListQuery(opts)
+	args := r.buildListArgs(opts)
+
+	rows, err := r.db.QueryContext(ctx, query, args...)
+	if err != nil {
+		return nil, fmt.Errorf("failed to list TV shows: %w", err)
+	}
+	defer rows.Close()
+
+	var tvShows []*models.TVShow
+	for rows.Next() {
+		tvShow := &models.TVShow{}
+		if err := r.scanTVShowRow(rows, tvShow); err != nil {
+			return nil, err
+		}
+		tvShows = append(tvShows, tvShow)
+	}
+
+	return tvShows, rows.Err()
+}
+
+func (r *TVRepository) buildListQuery(opts TVListOptions) string {
+	query := "SELECT id, title, season, episode, status, rating, notes, added, last_watched FROM tv_shows"
+
+	var conditions []string
+
+	if opts.Status != "" {
+		conditions = append(conditions, "status = ?")
+	}
+	if opts.Title != "" {
+		conditions = append(conditions, "title = ?")
+	}
+	if opts.Season > 0 {
+		conditions = append(conditions, "season = ?")
+	}
+	if opts.MinRating > 0 {
+		conditions = append(conditions, "rating >= ?")
+	}
+
+	if opts.Search != "" {
+		searchConditions := []string{
+			"title LIKE ?",
+			"notes LIKE ?",
+		}
+		conditions = append(conditions, fmt.Sprintf("(%s)", strings.Join(searchConditions, " OR ")))
+	}
+
+	if len(conditions) > 0 {
+		query += " WHERE " + strings.Join(conditions, " AND ")
+	}
+
+	if opts.SortBy != "" {
+		order := "ASC"
+		if strings.ToUpper(opts.SortOrder) == "DESC" {
+			order = "DESC"
+		}
+		query += fmt.Sprintf(" ORDER BY %s %s", opts.SortBy, order)
+	} else {
+		query += " ORDER BY title, season, episode"
+	}
+
+	if opts.Limit > 0 {
+		query += fmt.Sprintf(" LIMIT %d", opts.Limit)
+		if opts.Offset > 0 {
+			query += fmt.Sprintf(" OFFSET %d", opts.Offset)
+		}
+	}
+
+	return query
+}
+
+func (r *TVRepository) buildListArgs(opts TVListOptions) []any {
+	var args []any
+
+	if opts.Status != "" {
+		args = append(args, opts.Status)
+	}
+	if opts.Title != "" {
+		args = append(args, opts.Title)
+	}
+	if opts.Season > 0 {
+		args = append(args, opts.Season)
+	}
+	if opts.MinRating > 0 {
+		args = append(args, opts.MinRating)
+	}
+
+	if opts.Search != "" {
+		searchPattern := "%" + opts.Search + "%"
+		args = append(args, searchPattern, searchPattern)
+	}
+
+	return args
+}
+
+func (r *TVRepository) scanTVShowRow(rows *sql.Rows, tvShow *models.TVShow) error {
+	return rows.Scan(&tvShow.ID, &tvShow.Title, &tvShow.Season, &tvShow.Episode, &tvShow.Status,
+		&tvShow.Rating, &tvShow.Notes, &tvShow.Added, &tvShow.LastWatched)
+}
+
+// Find retrieves TV shows matching specific conditions
+func (r *TVRepository) Find(ctx context.Context, conditions TVListOptions) ([]*models.TVShow, error) {
+	return r.List(ctx, conditions)
+}
+
+// Count returns the number of TV shows matching conditions
+func (r *TVRepository) Count(ctx context.Context, opts TVListOptions) (int64, error) {
+	query := "SELECT COUNT(*) FROM tv_shows"
+	args := []any{}
+
+	var conditions []string
+
+	if opts.Status != "" {
+		conditions = append(conditions, "status = ?")
+		args = append(args, opts.Status)
+	}
+	if opts.Title != "" {
+		conditions = append(conditions, "title = ?")
+		args = append(args, opts.Title)
+	}
+	if opts.Season > 0 {
+		conditions = append(conditions, "season = ?")
+		args = append(args, opts.Season)
+	}
+	if opts.MinRating > 0 {
+		conditions = append(conditions, "rating >= ?")
+		args = append(args, opts.MinRating)
+	}
+
+	if opts.Search != "" {
+		searchConditions := []string{
+			"title LIKE ?",
+			"notes LIKE ?",
+		}
+		conditions = append(conditions, fmt.Sprintf("(%s)", strings.Join(searchConditions, " OR ")))
+		searchPattern := "%" + opts.Search + "%"
+		args = append(args, searchPattern, searchPattern)
+	}
+
+	if len(conditions) > 0 {
+		query += " WHERE " + strings.Join(conditions, " AND ")
+	}
+
+	var count int64
+	err := r.db.QueryRowContext(ctx, query, args...).Scan(&count)
+	if err != nil {
+		return 0, fmt.Errorf("failed to count TV shows: %w", err)
+	}
+
+	return count, nil
+}
+
+// GetQueued retrieves all TV shows in the queue
+func (r *TVRepository) GetQueued(ctx context.Context) ([]*models.TVShow, error) {
+	return r.List(ctx, TVListOptions{Status: "queued"})
+}
+
+// GetWatching retrieves all TV shows currently being watched
+func (r *TVRepository) GetWatching(ctx context.Context) ([]*models.TVShow, error) {
+	return r.List(ctx, TVListOptions{Status: "watching"})
+}
+
+// GetWatched retrieves all watched TV shows
+func (r *TVRepository) GetWatched(ctx context.Context) ([]*models.TVShow, error) {
+	return r.List(ctx, TVListOptions{Status: "watched"})
+}
+
+// GetByTitle retrieves all episodes for a specific TV show title
+func (r *TVRepository) GetByTitle(ctx context.Context, title string) ([]*models.TVShow, error) {
+	return r.List(ctx, TVListOptions{Title: title})
+}
+
+// GetBySeason retrieves all episodes for a specific season of a show
+func (r *TVRepository) GetBySeason(ctx context.Context, title string, season int) ([]*models.TVShow, error) {
+	return r.List(ctx, TVListOptions{Title: title, Season: season})
+}
+
+// MarkWatched marks a TV show episode as watched
+func (r *TVRepository) MarkWatched(ctx context.Context, id int64) error {
+	tvShow, err := r.Get(ctx, id)
+	if err != nil {
+		return err
+	}
+
+	now := time.Now()
+	tvShow.Status = "watched"
+	tvShow.LastWatched = &now
+
+	return r.Update(ctx, tvShow)
+}
+
+// StartWatching marks a TV show as currently being watched
+func (r *TVRepository) StartWatching(ctx context.Context, id int64) error {
+	tvShow, err := r.Get(ctx, id)
+	if err != nil {
+		return err
+	}
+
+	now := time.Now()
+	tvShow.Status = "watching"
+	tvShow.LastWatched = &now
+
+	return r.Update(ctx, tvShow)
+}
+
+// TVListOptions defines options for listing TV shows
+type TVListOptions struct {
+	Status    string
+	Title     string
+	Season    int
+	MinRating float64
+	Search    string
+	SortBy    string
+	SortOrder string
+	Limit     int
+	Offset    int
+}

internal/repo/tv_repository_test.go

···
+package repo
+
+import (
+	"context"
+	"database/sql"
+	"testing"
+	"time"
+
+	_ "github.com/mattn/go-sqlite3"
+	"stormlightlabs.org/noteleaf/internal/models"
+)
+
+func createTVTestDB(t *testing.T) *sql.DB {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to create in-memory database: %v", err)
+	}
+
+	if _, err := db.Exec("PRAGMA foreign_keys = ON"); err != nil {
+		t.Fatalf("Failed to enable foreign keys: %v", err)
+	}
+
+	schema := `
+		CREATE TABLE IF NOT EXISTS tv_shows (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			title TEXT NOT NULL,
+			season INTEGER,
+			episode INTEGER,
+			status TEXT DEFAULT 'queued',
+			rating REAL,
+			notes TEXT,
+			added DATETIME DEFAULT CURRENT_TIMESTAMP,
+			last_watched DATETIME
+		);
+	`
+
+	if _, err := db.Exec(schema); err != nil {
+		t.Fatalf("Failed to create schema: %v", err)
+	}
+
+	t.Cleanup(func() {
+		db.Close()
+	})
+
+	return db
+}
+
+func createSampleTVShow() *models.TVShow {
+	return &models.TVShow{
+		Title:   "Test Show",
+		Season:  1,
+		Episode: 1,
+		Status:  "queued",
+		Rating:  9.0,
+		Notes:   "Excellent series",
+	}
+}
+
+func TestTVRepository(t *testing.T) {
+	t.Run("CRUD Operations", func(t *testing.T) {
+		db := createTVTestDB(t)
+		repo := NewTVRepository(db)
+		ctx := context.Background()
+
+		t.Run("Create TV Show", func(t *testing.T) {
+			tvShow := createSampleTVShow()
+
+			id, err := repo.Create(ctx, tvShow)
+			if err != nil {
+				t.Errorf("Failed to create TV show: %v", err)
+			}
+
+			if id == 0 {
+				t.Error("Expected non-zero ID")
+			}
+
+			if tvShow.ID != id {
+				t.Errorf("Expected TV show ID to be set to %d, got %d", id, tvShow.ID)
+			}
+
+			if tvShow.Added.IsZero() {
+				t.Error("Expected Added timestamp to be set")
+			}
+		})
+
+		t.Run("Get TV Show", func(t *testing.T) {
+			original := createSampleTVShow()
+			id, err := repo.Create(ctx, original)
+			if err != nil {
+				t.Fatalf("Failed to create TV show: %v", err)
+			}
+
+			retrieved, err := repo.Get(ctx, id)
+			if err != nil {
+				t.Errorf("Failed to get TV show: %v", err)
+			}
+
+			if retrieved.Title != original.Title {
+				t.Errorf("Expected title %s, got %s", original.Title, retrieved.Title)
+			}
+			if retrieved.Season != original.Season {
+				t.Errorf("Expected season %d, got %d", original.Season, retrieved.Season)
+			}
+			if retrieved.Episode != original.Episode {
+				t.Errorf("Expected episode %d, got %d", original.Episode, retrieved.Episode)
+			}
+			if retrieved.Status != original.Status {
+				t.Errorf("Expected status %s, got %s", original.Status, retrieved.Status)
+			}
+			if retrieved.Rating != original.Rating {
+				t.Errorf("Expected rating %f, got %f", original.Rating, retrieved.Rating)
+			}
+			if retrieved.Notes != original.Notes {
+				t.Errorf("Expected notes %s, got %s", original.Notes, retrieved.Notes)
+			}
+		})
+
+		t.Run("Update TV Show", func(t *testing.T) {
+			tvShow := createSampleTVShow()
+			id, err := repo.Create(ctx, tvShow)
+			if err != nil {
+				t.Fatalf("Failed to create TV show: %v", err)
+			}
+
+			tvShow.Title = "Updated Show"
+			tvShow.Season = 2
+			tvShow.Episode = 5
+			tvShow.Status = "watching"
+			tvShow.Rating = 9.5
+			now := time.Now()
+			tvShow.LastWatched = &now
+
+			err = repo.Update(ctx, tvShow)
+			if err != nil {
+				t.Errorf("Failed to update TV show: %v", err)
+			}
+
+			updated, err := repo.Get(ctx, id)
+			if err != nil {
+				t.Fatalf("Failed to get updated TV show: %v", err)
+			}
+
+			if updated.Title != "Updated Show" {
+				t.Errorf("Expected updated title, got %s", updated.Title)
+			}
+			if updated.Season != 2 {
+				t.Errorf("Expected season 2, got %d", updated.Season)
+			}
+			if updated.Episode != 5 {
+				t.Errorf("Expected episode 5, got %d", updated.Episode)
+			}
+			if updated.Status != "watching" {
+				t.Errorf("Expected status watching, got %s", updated.Status)
+			}
+			if updated.Rating != 9.5 {
+				t.Errorf("Expected rating 9.5, got %f", updated.Rating)
+			}
+			if updated.LastWatched == nil {
+				t.Error("Expected last watched time to be set")
+			}
+		})
+
+		t.Run("Delete TV Show", func(t *testing.T) {
+			tvShow := createSampleTVShow()
+			id, err := repo.Create(ctx, tvShow)
+			if err != nil {
+				t.Fatalf("Failed to create TV show: %v", err)
+			}
+
+			err = repo.Delete(ctx, id)
+			if err != nil {
+				t.Errorf("Failed to delete TV show: %v", err)
+			}
+
+			_, err = repo.Get(ctx, id)
+			if err == nil {
+				t.Error("Expected error when getting deleted TV show")
+			}
+		})
+	})
+
+	t.Run("List", func(t *testing.T) {
+		db := createTVTestDB(t)
+		repo := NewTVRepository(db)
+		ctx := context.Background()
+
+		tvShows := []*models.TVShow{
+			{Title: "Show A", Season: 1, Episode: 1, Status: "queued", Rating: 8.0},
+			{Title: "Show A", Season: 1, Episode: 2, Status: "watching", Rating: 8.5},
+			{Title: "Show B", Season: 1, Episode: 1, Status: "queued", Rating: 9.0},
+			{Title: "Show B", Season: 2, Episode: 1, Status: "watched", Rating: 9.2},
+		}
+
+		for _, tvShow := range tvShows {
+			_, err := repo.Create(ctx, tvShow)
+			if err != nil {
+				t.Fatalf("Failed to create TV show: %v", err)
+			}
+		}
+
+		t.Run("List All TV Shows", func(t *testing.T) {
+			results, err := repo.List(ctx, TVListOptions{})
+			if err != nil {
+				t.Errorf("Failed to list TV shows: %v", err)
+			}
+
+			if len(results) != 4 {
+				t.Errorf("Expected 4 TV shows, got %d", len(results))
+			}
+		})
+
+		t.Run("List TV Shows with Status Filter", func(t *testing.T) {
+			results, err := repo.List(ctx, TVListOptions{Status: "queued"})
+			if err != nil {
+				t.Errorf("Failed to list TV shows: %v", err)
+			}
+
+			if len(results) != 2 {
+				t.Errorf("Expected 2 queued TV shows, got %d", len(results))
+			}
+
+			for _, tvShow := range results {
+				if tvShow.Status != "queued" {
+					t.Errorf("Expected queued status, got %s", tvShow.Status)
+				}
+			}
+		})
+
+		t.Run("List TV Shows by Title", func(t *testing.T) {
+			results, err := repo.List(ctx, TVListOptions{Title: "Show A"})
+			if err != nil {
+				t.Errorf("Failed to list TV shows: %v", err)
+			}
+
+			if len(results) != 2 {
+				t.Errorf("Expected 2 episodes of Show A, got %d", len(results))
+			}
+
+			for _, tvShow := range results {
+				if tvShow.Title != "Show A" {
+					t.Errorf("Expected title 'Show A', got %s", tvShow.Title)
+				}
+			}
+		})
+
+		t.Run("List TV Shows by Season", func(t *testing.T) {
+			results, err := repo.List(ctx, TVListOptions{Title: "Show B", Season: 1})
+			if err != nil {
+				t.Errorf("Failed to list TV shows: %v", err)
+			}
+
+			if len(results) != 1 {
+				t.Errorf("Expected 1 episode of Show B season 1, got %d", len(results))
+			}
+
+			if len(results) > 0 {
+				if results[0].Title != "Show B" || results[0].Season != 1 {
+					t.Errorf("Expected Show B season 1, got %s season %d", results[0].Title, results[0].Season)
+				}
+			}
+		})
+
+		t.Run("List TV Shows with Rating Filter", func(t *testing.T) {
+			results, err := repo.List(ctx, TVListOptions{MinRating: 9.0})
+			if err != nil {
+				t.Errorf("Failed to list TV shows: %v", err)
+			}
+
+			if len(results) != 2 {
+				t.Errorf("Expected 2 TV shows with rating >= 9.0, got %d", len(results))
+			}
+
+			for _, tvShow := range results {
+				if tvShow.Rating < 9.0 {
+					t.Errorf("Expected rating >= 9.0, got %f", tvShow.Rating)
+				}
+			}
+		})
+
+		t.Run("List TV Shows with Search", func(t *testing.T) {
+			results, err := repo.List(ctx, TVListOptions{Search: "Show A"})
+			if err != nil {
+				t.Errorf("Failed to list TV shows: %v", err)
+			}
+
+			if len(results) != 2 {
+				t.Errorf("Expected 2 TV shows matching search, got %d", len(results))
+			}
+
+			for _, tvShow := range results {
+				if tvShow.Title != "Show A" {
+					t.Errorf("Expected 'Show A', got %s", tvShow.Title)
+				}
+			}
+		})
+
+		t.Run("List TV Shows with Limit", func(t *testing.T) {
+			results, err := repo.List(ctx, TVListOptions{Limit: 2})
+			if err != nil {
+				t.Errorf("Failed to list TV shows: %v", err)
+			}
+
+			if len(results) != 2 {
+				t.Errorf("Expected 2 TV shows due to limit, got %d", len(results))
+			}
+		})
+	})
+
+	t.Run("Special Methods", func(t *testing.T) {
+		db := createTVTestDB(t)
+		repo := NewTVRepository(db)
+		ctx := context.Background()
+
+		tvShow1 := &models.TVShow{Title: "Queued Show", Status: "queued", Rating: 8.0}
+		tvShow2 := &models.TVShow{Title: "Watching Show", Status: "watching", Rating: 9.0}
+		tvShow3 := &models.TVShow{Title: "Watched Show", Status: "watched", Rating: 8.5}
+		tvShow4 := &models.TVShow{Title: "Test Series", Season: 1, Episode: 1, Status: "queued"}
+		tvShow5 := &models.TVShow{Title: "Test Series", Season: 1, Episode: 2, Status: "queued"}
+		tvShow6 := &models.TVShow{Title: "Test Series", Season: 2, Episode: 1, Status: "queued"}
+
+		var tvShow1ID int64
+		for _, tvShow := range []*models.TVShow{tvShow1, tvShow2, tvShow3, tvShow4, tvShow5, tvShow6} {
+			id, err := repo.Create(ctx, tvShow)
+			if err != nil {
+				t.Fatalf("Failed to create TV show: %v", err)
+			}
+			if tvShow == tvShow1 {
+				tvShow1ID = id
+			}
+		}
+
+		t.Run("GetQueued", func(t *testing.T) {
+			results, err := repo.GetQueued(ctx)
+			if err != nil {
+				t.Errorf("Failed to get queued TV shows: %v", err)
+			}
+
+			if len(results) != 4 {
+				t.Errorf("Expected 4 queued TV shows, got %d", len(results))
+			}
+
+			for _, tvShow := range results {
+				if tvShow.Status != "queued" {
+					t.Errorf("Expected queued status, got %s", tvShow.Status)
+				}
+			}
+		})
+
+		t.Run("GetWatching", func(t *testing.T) {
+			results, err := repo.GetWatching(ctx)
+			if err != nil {
+				t.Errorf("Failed to get watching TV shows: %v", err)
+			}
+
+			if len(results) != 1 {
+				t.Errorf("Expected 1 watching TV show, got %d", len(results))
+			}
+
+			if len(results) > 0 && results[0].Status != "watching" {
+				t.Errorf("Expected watching status, got %s", results[0].Status)
+			}
+		})
+
+		t.Run("GetWatched", func(t *testing.T) {
+			results, err := repo.GetWatched(ctx)
+			if err != nil {
+				t.Errorf("Failed to get watched TV shows: %v", err)
+			}
+
+			if len(results) != 1 {
+				t.Errorf("Expected 1 watched TV show, got %d", len(results))
+			}
+
+			if len(results) > 0 && results[0].Status != "watched" {
+				t.Errorf("Expected watched status, got %s", results[0].Status)
+			}
+		})
+
+		t.Run("GetByTitle", func(t *testing.T) {
+			results, err := repo.GetByTitle(ctx, "Test Series")
+			if err != nil {
+				t.Errorf("Failed to get TV shows by title: %v", err)
+			}
+
+			if len(results) != 3 {
+				t.Errorf("Expected 3 episodes of Test Series, got %d", len(results))
+			}
+
+			for _, tvShow := range results {
+				if tvShow.Title != "Test Series" {
+					t.Errorf("Expected title 'Test Series', got %s", tvShow.Title)
+				}
+			}
+		})
+
+		t.Run("GetBySeason", func(t *testing.T) {
+			results, err := repo.GetBySeason(ctx, "Test Series", 1)
+			if err != nil {
+				t.Errorf("Failed to get TV shows by season: %v", err)
+			}
+
+			if len(results) != 2 {
+				t.Errorf("Expected 2 episodes of Test Series season 1, got %d", len(results))
+			}
+
+			for _, tvShow := range results {
+				if tvShow.Title != "Test Series" || tvShow.Season != 1 {
+					t.Errorf("Expected Test Series season 1, got %s season %d", tvShow.Title, tvShow.Season)
+				}
+			}
+		})
+
+		t.Run("MarkWatched", func(t *testing.T) {
+			err := repo.MarkWatched(ctx, tvShow1ID)
+			if err != nil {
+				t.Errorf("Failed to mark TV show as watched: %v", err)
+			}
+
+			updated, err := repo.Get(ctx, tvShow1ID)
+			if err != nil {
+				t.Fatalf("Failed to get updated TV show: %v", err)
+			}
+
+			if updated.Status != "watched" {
+				t.Errorf("Expected status to be watched, got %s", updated.Status)
+			}
+
+			if updated.LastWatched == nil {
+				t.Error("Expected last watched timestamp to be set")
+			}
+		})
+
+		t.Run("StartWatching", func(t *testing.T) {
+			newShow := &models.TVShow{Title: "New Show", Status: "queued"}
+			id, err := repo.Create(ctx, newShow)
+			if err != nil {
+				t.Fatalf("Failed to create new TV show: %v", err)
+			}
+
+			err = repo.StartWatching(ctx, id)
+			if err != nil {
+				t.Errorf("Failed to start watching TV show: %v", err)
+			}
+
+			updated, err := repo.Get(ctx, id)
+			if err != nil {
+				t.Fatalf("Failed to get updated TV show: %v", err)
+			}
+
+			if updated.Status != "watching" {
+				t.Errorf("Expected status to be watching, got %s", updated.Status)
+			}
+
+			if updated.LastWatched == nil {
+				t.Error("Expected last watched timestamp to be set")
+			}
+		})
+	})
+
+	t.Run("Count", func(t *testing.T) {
+		db := createTVTestDB(t)
+		repo := NewTVRepository(db)
+		ctx := context.Background()
+
+		tvShows := []*models.TVShow{
+			{Title: "Show 1", Status: "queued", Rating: 8.0},
+			{Title: "Show 2", Status: "watching", Rating: 7.0},
+			{Title: "Show 3", Status: "watched", Rating: 9.0},
+			{Title: "Show 4", Status: "queued", Rating: 8.5},
+		}
+
+		for _, tvShow := range tvShows {
+			_, err := repo.Create(ctx, tvShow)
+			if err != nil {
+				t.Fatalf("Failed to create TV show: %v", err)
+			}
+		}
+
+		t.Run("Count all TV shows", func(t *testing.T) {
+			count, err := repo.Count(ctx, TVListOptions{})
+			if err != nil {
+				t.Errorf("Failed to count TV shows: %v", err)
+			}
+
+			if count != 4 {
+				t.Errorf("Expected 4 TV shows, got %d", count)
+			}
+		})
+
+		t.Run("Count queued TV shows", func(t *testing.T) {
+			count, err := repo.Count(ctx, TVListOptions{Status: "queued"})
+			if err != nil {
+				t.Errorf("Failed to count queued TV shows: %v", err)
+			}
+
+			if count != 2 {
+				t.Errorf("Expected 2 queued TV shows, got %d", count)
+			}
+		})
+
+		t.Run("Count TV shows by rating", func(t *testing.T) {
+			count, err := repo.Count(ctx, TVListOptions{MinRating: 8.0})
+			if err != nil {
+				t.Errorf("Failed to count high-rated TV shows: %v", err)
+			}
+
+			if count != 3 {
+				t.Errorf("Expected 3 TV shows with rating >= 8.0, got %d", count)
+			}
+		})
+	})
+}

justfile

···
+# Noteleaf project commands
+
+# Default recipe - show available commands
+default:
+    @just --list
+
+# Run all tests
+test:
+    go test ./... -v
+
+# Run tests with coverage
+coverage:
+    go test ./... -coverprofile=coverage.out
+    go tool cover -html=coverage.out -o coverage.html
+    @echo "Coverage report generated: coverage.html"
+
+# Run tests and show coverage in terminal
+test-coverage:
+    go test ./... -coverprofile=coverage.out
+    go tool cover -func=coverage.out
+
+# Build the binary to /tmp/
+build:
+    mkdir -p /tmp/
+    go build -o /tmp/noteleaf ./cmd/cli/
+    @echo "Binary built: /tmp/noteleaf/noteleaf"
+
+# Clean build artifacts
+clean:
+    rm -f coverage.out coverage.html
+    rm -rf /tmp/noteleaf
+
+# Run linting
+lint:
+    go vet ./...
+    go fmt ./...
+
+# Run all quality checks
+check: lint test-coverage
+
+# Install dependencies
+deps:
+    go mod download
+    go mod tidy
+
+# Run the application (after building)
+run: build
+    /tmp/noteleaf/noteleaf
+
+# Show project status
+status:
+    @echo "Go version:"
+    @go version
+    @echo ""
+    @echo "Module info:"
+    @go list -m
+    @echo ""
+    @echo "Dependencies:"
+    @go list -m all | head -10
+
+# Quick development workflow
+dev: clean lint test build
+    @echo "Development workflow complete!"