feat: notes table database access

internal/repo/note_repository.go

···
+package repo
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"slices"
+	"strings"
+	"time"
+
+	"github.com/stormlightlabs/noteleaf/internal/models"
+)
+
+// NoteRepository provides database operations for notes
+type NoteRepository struct {
+	db *sql.DB
+}
+
+// NewNoteRepository creates a new note repository
+func NewNoteRepository(db *sql.DB) *NoteRepository {
+	return &NoteRepository{db: db}
+}
+
+// NoteListOptions defines filtering options for listing notes
+type NoteListOptions struct {
+	Tags     []string
+	Archived *bool
+	Title    string
+	Content  string
+	Limit    int
+	Offset   int
+}
+
+// Create stores a new note and returns its assigned ID
+func (r *NoteRepository) Create(ctx context.Context, note *models.Note) (int64, error) {
+	now := time.Now()
+	note.Created = now
+	note.Modified = now
+
+	tags, err := note.MarshalTags()
+	if err != nil {
+		return 0, fmt.Errorf("failed to marshal tags: %w", err)
+	}
+
+	query := `
+		INSERT INTO notes (title, content, tags, archived, created, modified, file_path)
+		VALUES (?, ?, ?, ?, ?, ?, ?)`
+
+	result, err := r.db.ExecContext(ctx, query,
+		note.Title, note.Content, tags, note.Archived, note.Created, note.Modified, note.FilePath)
+	if err != nil {
+		return 0, fmt.Errorf("failed to insert note: %w", err)
+	}
+
+	id, err := result.LastInsertId()
+	if err != nil {
+		return 0, fmt.Errorf("failed to get last insert id: %w", err)
+	}
+
+	note.ID = id
+	return id, nil
+}
+
+// Get retrieves a note by its ID
+func (r *NoteRepository) Get(ctx context.Context, id int64) (*models.Note, error) {
+	query := `
+		SELECT id, title, content, tags, archived, created, modified, file_path
+		FROM notes WHERE id = ?`
+
+	row := r.db.QueryRowContext(ctx, query, id)
+
+	var note models.Note
+	var tags string
+	err := row.Scan(&note.ID, &note.Title, &note.Content, &tags, &note.Archived,
+		&note.Created, &note.Modified, &note.FilePath)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return nil, fmt.Errorf("note with id %d not found", id)
+		}
+		return nil, fmt.Errorf("failed to scan note: %w", err)
+	}
+
+	if err := note.UnmarshalTags(tags); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal tags: %w", err)
+	}
+
+	return &note, nil
+}
+
+// Update modifies an existing note
+func (r *NoteRepository) Update(ctx context.Context, note *models.Note) error {
+	note.Modified = time.Now()
+
+	tags, err := note.MarshalTags()
+	if err != nil {
+		return fmt.Errorf("failed to marshal tags: %w", err)
+	}
+
+	query := `
+		UPDATE notes
+		SET title = ?, content = ?, tags = ?, archived = ?, modified = ?, file_path = ?
+		WHERE id = ?`
+
+	result, err := r.db.ExecContext(ctx, query,
+		note.Title, note.Content, tags, note.Archived, note.Modified, note.FilePath, note.ID)
+	if err != nil {
+		return fmt.Errorf("failed to update note: %w", err)
+	}
+
+	rowsAffected, err := result.RowsAffected()
+	if err != nil {
+		return fmt.Errorf("failed to get rows affected: %w", err)
+	}
+
+	if rowsAffected == 0 {
+		return fmt.Errorf("note with id %d not found", note.ID)
+	}
+
+	return nil
+}
+
+// Delete removes a note by its ID
+func (r *NoteRepository) Delete(ctx context.Context, id int64) error {
+	query := `DELETE FROM notes WHERE id = ?`
+
+	result, err := r.db.ExecContext(ctx, query, id)
+	if err != nil {
+		return fmt.Errorf("failed to delete note: %w", err)
+	}
+
+	rowsAffected, err := result.RowsAffected()
+	if err != nil {
+		return fmt.Errorf("failed to get rows affected: %w", err)
+	}
+
+	if rowsAffected == 0 {
+		return fmt.Errorf("note with id %d not found", id)
+	}
+
+	return nil
+}
+
+// List retrieves notes with optional filtering
+func (r *NoteRepository) List(ctx context.Context, options NoteListOptions) ([]*models.Note, error) {
+	query := "SELECT id, title, content, tags, archived, created, modified, file_path FROM notes"
+	args := []any{}
+	conditions := []string{}
+
+	if options.Archived != nil {
+		conditions = append(conditions, "archived = ?")
+		args = append(args, *options.Archived)
+	}
+
+	if options.Title != "" {
+		conditions = append(conditions, "title LIKE ?")
+		args = append(args, "%"+options.Title+"%")
+	}
+
+	if options.Content != "" {
+		conditions = append(conditions, "content LIKE ?")
+		args = append(args, "%"+options.Content+"%")
+	}
+
+	if len(conditions) > 0 {
+		query += " WHERE " + strings.Join(conditions, " AND ")
+	}
+
+	query += " ORDER BY modified DESC"
+
+	if options.Limit > 0 {
+		query += fmt.Sprintf(" LIMIT %d", options.Limit)
+		if options.Offset > 0 {
+			query += fmt.Sprintf(" OFFSET %d", options.Offset)
+		}
+	}
+
+	rows, err := r.db.QueryContext(ctx, query, args...)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query notes: %w", err)
+	}
+	defer rows.Close()
+
+	var notes []*models.Note
+	for rows.Next() {
+		var note models.Note
+		var tags string
+		err := rows.Scan(&note.ID, &note.Title, &note.Content, &tags, &note.Archived,
+			&note.Created, &note.Modified, &note.FilePath)
+		if err != nil {
+			return nil, fmt.Errorf("failed to scan note: %w", err)
+		}
+
+		if err := note.UnmarshalTags(tags); err != nil {
+			return nil, fmt.Errorf("failed to unmarshal tags: %w", err)
+		}
+
+		notes = append(notes, &note)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("error iterating over notes: %w", err)
+	}
+
+	return notes, nil
+}
+
+// GetByTitle searches for notes by title pattern
+func (r *NoteRepository) GetByTitle(ctx context.Context, title string) ([]*models.Note, error) {
+	return r.List(ctx, NoteListOptions{Title: title})
+}
+
+// GetArchived retrieves all archived notes
+func (r *NoteRepository) GetArchived(ctx context.Context) ([]*models.Note, error) {
+	archived := true
+	return r.List(ctx, NoteListOptions{Archived: &archived})
+}
+
+// GetActive retrieves all non-archived notes
+func (r *NoteRepository) GetActive(ctx context.Context) ([]*models.Note, error) {
+	archived := false
+	return r.List(ctx, NoteListOptions{Archived: &archived})
+}
+
+// Archive marks a note as archived
+func (r *NoteRepository) Archive(ctx context.Context, id int64) error {
+	note, err := r.Get(ctx, id)
+	if err != nil {
+		return err
+	}
+
+	note.Archived = true
+	return r.Update(ctx, note)
+}
+
+// Unarchive marks a note as not archived
+func (r *NoteRepository) Unarchive(ctx context.Context, id int64) error {
+	note, err := r.Get(ctx, id)
+	if err != nil {
+		return err
+	}
+
+	note.Archived = false
+	return r.Update(ctx, note)
+}
+
+// SearchContent searches for notes containing the specified text in content
+func (r *NoteRepository) SearchContent(ctx context.Context, searchText string) ([]*models.Note, error) {
+	return r.List(ctx, NoteListOptions{Content: searchText})
+}
+
+// GetRecent retrieves the most recently modified notes
+func (r *NoteRepository) GetRecent(ctx context.Context, limit int) ([]*models.Note, error) {
+	return r.List(ctx, NoteListOptions{Limit: limit})
+}
+
+// AddTag adds a tag to a note
+func (r *NoteRepository) AddTag(ctx context.Context, id int64, tag string) error {
+	note, err := r.Get(ctx, id)
+	if err != nil {
+		return err
+	}
+
+	if slices.Contains(note.Tags, tag) {
+		return nil
+	}
+
+	note.Tags = append(note.Tags, tag)
+	return r.Update(ctx, note)
+}
+
+// RemoveTag removes a tag from a note
+func (r *NoteRepository) RemoveTag(ctx context.Context, id int64, tag string) error {
+	note, err := r.Get(ctx, id)
+	if err != nil {
+		return err
+	}
+
+	for i, existingTag := range note.Tags {
+		if existingTag == tag {
+			note.Tags = append(note.Tags[:i], note.Tags[i+1:]...)
+			break
+		}
+	}
+
+	return r.Update(ctx, note)
+}
+
+// GetByTags retrieves notes that have any of the specified tags
+func (r *NoteRepository) GetByTags(ctx context.Context, tags []string) ([]*models.Note, error) {
+	if len(tags) == 0 {
+		return []*models.Note{}, nil
+	}
+
+	placeholders := make([]string, len(tags))
+	args := make([]any, len(tags))
+	for i, tag := range tags {
+		placeholders[i] = "?"
+		args[i] = "%\"" + tag + "\"%"
+	}
+
+	query := fmt.Sprintf(`
+		SELECT id, title, content, tags, archived, created, modified, file_path
+		FROM notes
+		WHERE %s
+		ORDER BY modified DESC`,
+		strings.Join(func() []string {
+			conditions := make([]string, len(tags))
+			for i := range tags {
+				conditions[i] = "tags LIKE ?"
+			}
+			return conditions
+		}(), " OR "))
+
+	rows, err := r.db.QueryContext(ctx, query, args...)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query notes by tags: %w", err)
+	}
+	defer rows.Close()
+
+	var notes []*models.Note
+	for rows.Next() {
+		var note models.Note
+		var tagsJSON string
+		err := rows.Scan(&note.ID, &note.Title, &note.Content, &tagsJSON, &note.Archived,
+			&note.Created, &note.Modified, &note.FilePath)
+		if err != nil {
+			return nil, fmt.Errorf("failed to scan note: %w", err)
+		}
+
+		if err := note.UnmarshalTags(tagsJSON); err != nil {
+			return nil, fmt.Errorf("failed to unmarshal tags: %w", err)
+		}
+
+		notes = append(notes, &note)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("error iterating over notes: %w", err)
+	}
+
+	return notes, nil
+}

internal/repo/note_repository_test.go

···
+package repo
+
+import (
+	"context"
+	"database/sql"
+	"testing"
+
+	_ "github.com/mattn/go-sqlite3"
+	"github.com/stormlightlabs/noteleaf/internal/models"
+)
+
+func createNoteTestDB(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 notes (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			title TEXT NOT NULL,
+			content TEXT NOT NULL,
+			tags TEXT,
+			archived BOOLEAN DEFAULT FALSE,
+			created DATETIME DEFAULT CURRENT_TIMESTAMP,
+			modified DATETIME DEFAULT CURRENT_TIMESTAMP,
+			file_path TEXT
+		);
+	`
+
+	if _, err := db.Exec(schema); err != nil {
+		t.Fatalf("Failed to create schema: %v", err)
+	}
+
+	t.Cleanup(func() {
+		db.Close()
+	})
+
+	return db
+}
+
+func createSampleNote() *models.Note {
+	return &models.Note{
+		Title:    "Test Note",
+		Content:  "This is test content with **markdown**",
+		Tags:     []string{"personal", "work"},
+		Archived: false,
+		FilePath: "/path/to/note.md",
+	}
+}
+
+func TestNoteRepository_CRUD(t *testing.T) {
+	db := createNoteTestDB(t)
+	repo := NewNoteRepository(db)
+	ctx := context.Background()
+
+	t.Run("Create Note", func(t *testing.T) {
+		note := createSampleNote()
+
+		id, err := repo.Create(ctx, note)
+		if err != nil {
+			t.Errorf("Failed to create note: %v", err)
+		}
+
+		if id == 0 {
+			t.Error("Expected non-zero ID")
+		}
+
+		if note.ID != id {
+			t.Errorf("Expected note ID to be set to %d, got %d", id, note.ID)
+		}
+
+		if note.Created.IsZero() {
+			t.Error("Expected Created timestamp to be set")
+		}
+		if note.Modified.IsZero() {
+			t.Error("Expected Modified timestamp to be set")
+		}
+	})
+
+	t.Run("Get Note", func(t *testing.T) {
+		original := createSampleNote()
+		id, err := repo.Create(ctx, original)
+		if err != nil {
+			t.Fatalf("Failed to create note: %v", err)
+		}
+
+		retrieved, err := repo.Get(ctx, id)
+		if err != nil {
+			t.Fatalf("Failed to get note: %v", err)
+		}
+
+		if retrieved.ID != original.ID {
+			t.Errorf("Expected ID %d, got %d", original.ID, retrieved.ID)
+		}
+		if retrieved.Title != original.Title {
+			t.Errorf("Expected title %s, got %s", original.Title, retrieved.Title)
+		}
+		if retrieved.Content != original.Content {
+			t.Errorf("Expected content %s, got %s", original.Content, retrieved.Content)
+		}
+		if len(retrieved.Tags) != len(original.Tags) {
+			t.Errorf("Expected %d tags, got %d", len(original.Tags), len(retrieved.Tags))
+		}
+		if retrieved.Archived != original.Archived {
+			t.Errorf("Expected archived %v, got %v", original.Archived, retrieved.Archived)
+		}
+		if retrieved.FilePath != original.FilePath {
+			t.Errorf("Expected file path %s, got %s", original.FilePath, retrieved.FilePath)
+		}
+	})
+
+	t.Run("Update Note", func(t *testing.T) {
+		note := createSampleNote()
+		id, err := repo.Create(ctx, note)
+		if err != nil {
+			t.Fatalf("Failed to create note: %v", err)
+		}
+
+		originalModified := note.Modified
+
+		note.Title = "Updated Title"
+		note.Content = "Updated content"
+		note.Tags = []string{"updated", "test"}
+		note.Archived = true
+		note.FilePath = "/new/path/note.md"
+
+		err = repo.Update(ctx, note)
+		if err != nil {
+			t.Errorf("Failed to update note: %v", err)
+		}
+
+		retrieved, err := repo.Get(ctx, id)
+		if err != nil {
+			t.Fatalf("Failed to get updated note: %v", err)
+		}
+
+		if retrieved.Title != "Updated Title" {
+			t.Errorf("Expected updated title, got %s", retrieved.Title)
+		}
+		if retrieved.Content != "Updated content" {
+			t.Errorf("Expected updated content, got %s", retrieved.Content)
+		}
+		if len(retrieved.Tags) != 2 || retrieved.Tags[0] != "updated" || retrieved.Tags[1] != "test" {
+			t.Errorf("Expected updated tags, got %v", retrieved.Tags)
+		}
+		if !retrieved.Archived {
+			t.Error("Expected note to be archived")
+		}
+		if retrieved.FilePath != "/new/path/note.md" {
+			t.Errorf("Expected updated file path, got %s", retrieved.FilePath)
+		}
+		if !retrieved.Modified.After(originalModified) {
+			t.Error("Expected Modified timestamp to be updated")
+		}
+	})
+
+	t.Run("Delete Note", func(t *testing.T) {
+		note := createSampleNote()
+		id, err := repo.Create(ctx, note)
+		if err != nil {
+			t.Fatalf("Failed to create note: %v", err)
+		}
+
+		err = repo.Delete(ctx, id)
+		if err != nil {
+			t.Errorf("Failed to delete note: %v", err)
+		}
+
+		_, err = repo.Get(ctx, id)
+		if err == nil {
+			t.Error("Expected error when getting deleted note")
+		}
+	})
+}
+
+func TestNoteRepository_List(t *testing.T) {
+	db := createNoteTestDB(t)
+	repo := NewNoteRepository(db)
+	ctx := context.Background()
+
+	notes := []*models.Note{
+		{Title: "First Note", Content: "Content 1", Tags: []string{"work"}, Archived: false},
+		{Title: "Second Note", Content: "Content 2", Tags: []string{"personal"}, Archived: true},
+		{Title: "Third Note", Content: "Important content", Tags: []string{"work", "important"}, Archived: false},
+	}
+
+	for _, note := range notes {
+		_, err := repo.Create(ctx, note)
+		if err != nil {
+			t.Fatalf("Failed to create test note: %v", err)
+		}
+	}
+
+	t.Run("List All Notes", func(t *testing.T) {
+		results, err := repo.List(ctx, NoteListOptions{})
+		if err != nil {
+			t.Fatalf("Failed to list notes: %v", err)
+		}
+
+		if len(results) != 3 {
+			t.Errorf("Expected 3 notes, got %d", len(results))
+		}
+	})
+
+	t.Run("List Archived Notes Only", func(t *testing.T) {
+		archived := true
+		results, err := repo.List(ctx, NoteListOptions{Archived: &archived})
+		if err != nil {
+			t.Fatalf("Failed to list archived notes: %v", err)
+		}
+
+		if len(results) != 1 {
+			t.Errorf("Expected 1 archived note, got %d", len(results))
+		}
+		if !results[0].Archived {
+			t.Error("Retrieved note should be archived")
+		}
+	})
+
+	t.Run("List Active Notes Only", func(t *testing.T) {
+		archived := false
+		results, err := repo.List(ctx, NoteListOptions{Archived: &archived})
+		if err != nil {
+			t.Fatalf("Failed to list active notes: %v", err)
+		}
+
+		if len(results) != 2 {
+			t.Errorf("Expected 2 active notes, got %d", len(results))
+		}
+		for _, note := range results {
+			if note.Archived {
+				t.Error("Retrieved note should not be archived")
+			}
+		}
+	})
+
+	t.Run("Search by Title", func(t *testing.T) {
+		results, err := repo.List(ctx, NoteListOptions{Title: "First"})
+		if err != nil {
+			t.Fatalf("Failed to search by title: %v", err)
+		}
+
+		if len(results) != 1 {
+			t.Errorf("Expected 1 note, got %d", len(results))
+		}
+		if results[0].Title != "First Note" {
+			t.Errorf("Expected 'First Note', got %s", results[0].Title)
+		}
+	})
+
+	t.Run("Search by Content", func(t *testing.T) {
+		results, err := repo.List(ctx, NoteListOptions{Content: "Important"})
+		if err != nil {
+			t.Fatalf("Failed to search by content: %v", err)
+		}
+
+		if len(results) != 1 {
+			t.Errorf("Expected 1 note, got %d", len(results))
+		}
+		if results[0].Title != "Third Note" {
+			t.Errorf("Expected 'Third Note', got %s", results[0].Title)
+		}
+	})
+
+	t.Run("Limit and Offset", func(t *testing.T) {
+		results, err := repo.List(ctx, NoteListOptions{Limit: 2})
+		if err != nil {
+			t.Fatalf("Failed to list with limit: %v", err)
+		}
+
+		if len(results) != 2 {
+			t.Errorf("Expected 2 notes, got %d", len(results))
+		}
+
+		results, err = repo.List(ctx, NoteListOptions{Limit: 2, Offset: 1})
+		if err != nil {
+			t.Fatalf("Failed to list with limit and offset: %v", err)
+		}
+
+		if len(results) != 2 {
+			t.Errorf("Expected 2 notes with offset, got %d", len(results))
+		}
+	})
+}
+
+func TestNoteRepository_SpecializedMethods(t *testing.T) {
+	db := createNoteTestDB(t)
+	repo := NewNoteRepository(db)
+	ctx := context.Background()
+
+	notes := []*models.Note{
+		{Title: "Work Note", Content: "Work content", Tags: []string{"work"}, Archived: false},
+		{Title: "Personal Note", Content: "Personal content", Tags: []string{"personal"}, Archived: true},
+		{Title: "Important Note", Content: "Important content", Tags: []string{"work", "important"}, Archived: false},
+	}
+
+	for _, note := range notes {
+		_, err := repo.Create(ctx, note)
+		if err != nil {
+			t.Fatalf("Failed to create test note: %v", err)
+		}
+	}
+
+	t.Run("GetByTitle", func(t *testing.T) {
+		results, err := repo.GetByTitle(ctx, "Work")
+		if err != nil {
+			t.Fatalf("Failed to get by title: %v", err)
+		}
+
+		if len(results) != 1 {
+			t.Errorf("Expected 1 note, got %d", len(results))
+		}
+		if results[0].Title != "Work Note" {
+			t.Errorf("Expected 'Work Note', got %s", results[0].Title)
+		}
+	})
+
+	t.Run("GetArchived", func(t *testing.T) {
+		results, err := repo.GetArchived(ctx)
+		if err != nil {
+			t.Fatalf("Failed to get archived notes: %v", err)
+		}
+
+		if len(results) != 1 {
+			t.Errorf("Expected 1 archived note, got %d", len(results))
+		}
+		if !results[0].Archived {
+			t.Error("Retrieved note should be archived")
+		}
+	})
+
+	t.Run("GetActive", func(t *testing.T) {
+		results, err := repo.GetActive(ctx)
+		if err != nil {
+			t.Fatalf("Failed to get active notes: %v", err)
+		}
+
+		if len(results) != 2 {
+			t.Errorf("Expected 2 active notes, got %d", len(results))
+		}
+		for _, note := range results {
+			if note.Archived {
+				t.Error("Retrieved note should not be archived")
+			}
+		}
+	})
+
+	t.Run("Archive and Unarchive", func(t *testing.T) {
+		note := &models.Note{
+			Title:    "Test Archive",
+			Content:  "Archive test",
+			Archived: false,
+		}
+		id, err := repo.Create(ctx, note)
+		if err != nil {
+			t.Fatalf("Failed to create note: %v", err)
+		}
+
+		err = repo.Archive(ctx, id)
+		if err != nil {
+			t.Fatalf("Failed to archive note: %v", err)
+		}
+
+		retrieved, err := repo.Get(ctx, id)
+		if err != nil {
+			t.Fatalf("Failed to get note: %v", err)
+		}
+		if !retrieved.Archived {
+			t.Error("Note should be archived")
+		}
+
+		err = repo.Unarchive(ctx, id)
+		if err != nil {
+			t.Fatalf("Failed to unarchive note: %v", err)
+		}
+
+		retrieved, err = repo.Get(ctx, id)
+		if err != nil {
+			t.Fatalf("Failed to get note: %v", err)
+		}
+		if retrieved.Archived {
+			t.Error("Note should not be archived")
+		}
+	})
+
+	t.Run("SearchContent", func(t *testing.T) {
+		results, err := repo.SearchContent(ctx, "Important")
+		if err != nil {
+			t.Fatalf("Failed to search content: %v", err)
+		}
+
+		if len(results) != 1 {
+			t.Errorf("Expected 1 note, got %d", len(results))
+		}
+		if results[0].Title != "Important Note" {
+			t.Errorf("Expected 'Important Note', got %s", results[0].Title)
+		}
+	})
+
+	t.Run("GetRecent", func(t *testing.T) {
+		results, err := repo.GetRecent(ctx, 2)
+		if err != nil {
+			t.Fatalf("Failed to get recent notes: %v", err)
+		}
+
+		if len(results) != 2 {
+			t.Errorf("Expected 2 notes, got %d", len(results))
+		}
+	})
+}
+
+func TestNoteRepository_TagMethods(t *testing.T) {
+	db := createNoteTestDB(t)
+	repo := NewNoteRepository(db)
+	ctx := context.Background()
+
+	note := &models.Note{
+		Title:   "Tag Test Note",
+		Content: "Testing tags",
+		Tags:    []string{"initial"},
+	}
+	id, err := repo.Create(ctx, note)
+	if err != nil {
+		t.Fatalf("Failed to create note: %v", err)
+	}
+
+	t.Run("AddTag", func(t *testing.T) {
+		err := repo.AddTag(ctx, id, "new-tag")
+		if err != nil {
+			t.Fatalf("Failed to add tag: %v", err)
+		}
+
+		retrieved, err := repo.Get(ctx, id)
+		if err != nil {
+			t.Fatalf("Failed to get note: %v", err)
+		}
+
+		if len(retrieved.Tags) != 2 {
+			t.Errorf("Expected 2 tags, got %d", len(retrieved.Tags))
+		}
+
+		found := false
+		for _, tag := range retrieved.Tags {
+			if tag == "new-tag" {
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Error("New tag not found in note")
+		}
+	})
+
+	t.Run("AddTag Duplicate", func(t *testing.T) {
+		err := repo.AddTag(ctx, id, "new-tag")
+		if err != nil {
+			t.Fatalf("Failed to add duplicate tag: %v", err)
+		}
+
+		retrieved, err := repo.Get(ctx, id)
+		if err != nil {
+			t.Fatalf("Failed to get note: %v", err)
+		}
+
+		if len(retrieved.Tags) != 2 {
+			t.Errorf("Expected 2 tags (no duplicate), got %d", len(retrieved.Tags))
+		}
+	})
+
+	t.Run("RemoveTag", func(t *testing.T) {
+		err := repo.RemoveTag(ctx, id, "initial")
+		if err != nil {
+			t.Fatalf("Failed to remove tag: %v", err)
+		}
+
+		retrieved, err := repo.Get(ctx, id)
+		if err != nil {
+			t.Fatalf("Failed to get note: %v", err)
+		}
+
+		if len(retrieved.Tags) != 1 {
+			t.Errorf("Expected 1 tag after removal, got %d", len(retrieved.Tags))
+		}
+
+		for _, tag := range retrieved.Tags {
+			if tag == "initial" {
+				t.Error("Removed tag still found in note")
+			}
+		}
+	})
+
+	t.Run("GetByTags", func(t *testing.T) {
+		note1 := &models.Note{
+			Title:   "Note 1",
+			Content: "Content 1",
+			Tags:    []string{"work", "urgent"},
+		}
+		note2 := &models.Note{
+			Title:   "Note 2",
+			Content: "Content 2",
+			Tags:    []string{"personal", "ideas"},
+		}
+		note3 := &models.Note{
+			Title:   "Note 3",
+			Content: "Content 3",
+			Tags:    []string{"work", "planning"},
+		}
+
+		_, err := repo.Create(ctx, note1)
+		if err != nil {
+			t.Fatalf("Failed to create note1: %v", err)
+		}
+		_, err = repo.Create(ctx, note2)
+		if err != nil {
+			t.Fatalf("Failed to create note2: %v", err)
+		}
+		_, err = repo.Create(ctx, note3)
+		if err != nil {
+			t.Fatalf("Failed to create note3: %v", err)
+		}
+
+		results, err := repo.GetByTags(ctx, []string{"work"})
+		if err != nil {
+			t.Fatalf("Failed to get notes by tag: %v", err)
+		}
+
+		if len(results) < 2 {
+			t.Errorf("Expected at least 2 notes with 'work' tag, got %d", len(results))
+		}
+
+		results, err = repo.GetByTags(ctx, []string{"nonexistent"})
+		if err != nil {
+			t.Fatalf("Failed to get notes by nonexistent tag: %v", err)
+		}
+
+		if len(results) != 0 {
+			t.Errorf("Expected 0 notes with nonexistent tag, got %d", len(results))
+		}
+
+		results, err = repo.GetByTags(ctx, []string{})
+		if err != nil {
+			t.Fatalf("Failed to get notes with empty tags: %v", err)
+		}
+
+		if len(results) != 0 {
+			t.Errorf("Expected 0 notes with empty tag list, got %d", len(results))
+		}
+	})
+}
+
+func TestNoteRepository_ErrorCases(t *testing.T) {
+	db := createNoteTestDB(t)
+	repo := NewNoteRepository(db)
+	ctx := context.Background()
+
+	t.Run("Get Nonexistent Note", func(t *testing.T) {
+		_, err := repo.Get(ctx, 999)
+		if err == nil {
+			t.Error("Expected error when getting nonexistent note")
+		}
+	})
+
+	t.Run("Update Nonexistent Note", func(t *testing.T) {
+		note := &models.Note{
+			ID:      999,
+			Title:   "Nonexistent",
+			Content: "Should fail",
+		}
+
+		err := repo.Update(ctx, note)
+		if err == nil {
+			t.Error("Expected error when updating nonexistent note")
+		}
+	})
+
+	t.Run("Delete Nonexistent Note", func(t *testing.T) {
+		err := repo.Delete(ctx, 999)
+		if err == nil {
+			t.Error("Expected error when deleting nonexistent note")
+		}
+	})
+
+	t.Run("Archive Nonexistent Note", func(t *testing.T) {
+		err := repo.Archive(ctx, 999)
+		if err == nil {
+			t.Error("Expected error when archiving nonexistent note")
+		}
+	})
+
+	t.Run("AddTag to Nonexistent Note", func(t *testing.T) {
+		err := repo.AddTag(ctx, 999, "tag")
+		if err == nil {
+			t.Error("Expected error when adding tag to nonexistent note")
+		}
+	})
+}
+
+func TestNoteRepository_EdgeCases(t *testing.T) {
+	db := createNoteTestDB(t)
+	repo := NewNoteRepository(db)
+	ctx := context.Background()
+
+	t.Run("Note with Empty Tags", func(t *testing.T) {
+		note := &models.Note{
+			Title:   "No Tags Note",
+			Content: "This note has no tags",
+			Tags:    []string{},
+		}
+
+		id, err := repo.Create(ctx, note)
+		if err != nil {
+			t.Fatalf("Failed to create note with empty tags: %v", err)
+		}
+
+		retrieved, err := repo.Get(ctx, id)
+		if err != nil {
+			t.Fatalf("Failed to get note: %v", err)
+		}
+
+		if len(retrieved.Tags) != 0 {
+			t.Errorf("Expected empty tags slice, got %d tags", len(retrieved.Tags))
+		}
+	})
+
+	t.Run("Note with Nil Tags", func(t *testing.T) {
+		note := &models.Note{
+			Title:   "Nil Tags Note",
+			Content: "This note has nil tags",
+			Tags:    nil,
+		}
+
+		id, err := repo.Create(ctx, note)
+		if err != nil {
+			t.Fatalf("Failed to create note with nil tags: %v", err)
+		}
+
+		retrieved, err := repo.Get(ctx, id)
+		if err != nil {
+			t.Fatalf("Failed to get note: %v", err)
+		}
+
+		if retrieved.Tags != nil {
+			t.Errorf("Expected nil tags, got %v", retrieved.Tags)
+		}
+	})
+
+	t.Run("Note with Long Content", func(t *testing.T) {
+		longContent := ""
+		for i := 0; i < 1000; i++ {
+			longContent += "This is a very long content string. "
+		}
+
+		note := &models.Note{
+			Title:   "Long Content Note",
+			Content: longContent,
+		}
+
+		id, err := repo.Create(ctx, note)
+		if err != nil {
+			t.Fatalf("Failed to create note with long content: %v", err)
+		}
+
+		retrieved, err := repo.Get(ctx, id)
+		if err != nil {
+			t.Fatalf("Failed to get note: %v", err)
+		}
+
+		if retrieved.Content != longContent {
+			t.Error("Long content was not stored/retrieved correctly")
+		}
+	})
+}

internal/repo/repo.go

···
 	Movies *MovieRepository
 	TV     *TVRepository
 	Books  *BookRepository
+	Notes  *NoteRepository
 }
 
 // NewRepositories creates a new set of repositories
···
 		Movies: NewMovieRepository(db),
 		TV:     NewTVRepository(db),
 		Books:  NewBookRepository(db),
+		Notes:  NewNoteRepository(db),
 	}
 }

internal/repo/repositories_test.go

···
 		t.Fatalf("Failed to enable foreign keys: %v", err)
 	}
 
-	// Create all tables
 	schema := `
 		-- Tasks table
 		CREATE TABLE IF NOT EXISTS tasks (
···
 			started DATETIME,
 			finished DATETIME
 		);
+
+		-- Notes table
+		CREATE TABLE IF NOT EXISTS notes (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			title TEXT NOT NULL,
+			content TEXT NOT NULL,
+			tags TEXT,
+			archived BOOLEAN DEFAULT FALSE,
+			created DATETIME DEFAULT CURRENT_TIMESTAMP,
+			modified DATETIME DEFAULT CURRENT_TIMESTAMP,
+			file_path TEXT
+		);
 	`
 
 	if _, err := db.Exec(schema); err != nil {
···
 			if bookID == 0 {
 				t.Error("Expected non-zero book ID")
 			}
+
+			note := &models.Note{
+				Title:   "Integration Note",
+				Content: "This is test content for integration",
+				Tags:    []string{"integration", "test"},
+			}
+			noteID, err := repos.Notes.Create(ctx, note)
+			if err != nil {
+				t.Errorf("Failed to create note: %v", err)
+			}
+			if noteID == 0 {
+				t.Error("Expected non-zero note ID")
+			}
 		})
 
 		t.Run("Retrieve all resources", func(t *testing.T) {
···
 			}
 			if len(books) != 1 {
 				t.Errorf("Expected 1 book, got %d", len(books))
+			}
+
+			notes, err := repos.Notes.List(ctx, NoteListOptions{})
+			if err != nil {
+				t.Errorf("Failed to list notes: %v", err)
+			}
+			if len(notes) != 1 {
+				t.Errorf("Expected 1 note, got %d", len(notes))
 			}
 		})
 
···
 			if len(queuedBooks) != 1 {
 				t.Errorf("Expected 1 queued book, got %d", len(queuedBooks))
 			}
+
+			activeNotes, err := repos.Notes.GetActive(ctx)
+			if err != nil {
+				t.Errorf("Failed to get active notes: %v", err)
+			}
+			if len(activeNotes) != 1 {
+				t.Errorf("Expected 1 active note, got %d", len(activeNotes))
+			}
 		})
 	})
 
···
 			}
 			if repos.Books == nil {
 				t.Error("Books repository should be initialized")
+			}
+			if repos.Notes == nil {
+				t.Error("Notes repository should be initialized")
 			}
 		})