feat: implement document management functionality for search

* developed search engine capabilities for documents using TF-IDF indexing
* utility functions for tokenization and frequency counting for document content

cmd/main.go

···
 	newBookHandler        = handlers.NewBookHandler
 	newArticleHandler     = handlers.NewArticleHandler
 	newPublicationHandler = handlers.NewPublicationHandler
+	newDocumentHandler    = handlers.NewDocumentHandler
 	exc                   = fang.Execute
 )
 
···
 		return 1
 	}
 
+	documentHandler, err := newDocumentHandler()
+	if err != nil {
+		log.Error("failed to create document handler", "err", err)
+		return 1
+	}
+
 	root := rootCmd()
 
 	coreGroups := []CommandGroup{
···
 		NewNoteCommand(noteHandler),
 		NewPublicationCommand(publicationHandler),
 		NewArticleCommand(articleHandler),
+		NewSearchCommand(documentHandler),
 	}
 
 	for _, group := range coreGroups {

cmd/search_commands.go

···
+package main
+
+import (
+	"strings"
+
+	"github.com/spf13/cobra"
+	"github.com/stormlightlabs/noteleaf/internal/handlers"
+)
+
+// SearchCommand implements [CommandGroup] for document search commands
+type SearchCommand struct {
+	handler *handlers.DocumentHandler
+}
+
+// NewSearchCommand creates a new search command group
+func NewSearchCommand(handler *handlers.DocumentHandler) *SearchCommand {
+	return &SearchCommand{handler: handler}
+}
+
+func (c *SearchCommand) Create() *cobra.Command {
+	root := &cobra.Command{
+		Use:   "search",
+		Short: "Search notes using TF-IDF",
+		Long: `Full-text search for notes using Term Frequency-Inverse Document Frequency (TF-IDF) ranking.
+
+The search engine tokenizes text, builds an inverted index, and ranks results by relevance.
+Results are sorted by TF-IDF score, with higher scores indicating better matches.`,
+	}
+
+	queryCmd := &cobra.Command{
+		Use:   "query [search terms...]",
+		Short: "Search for documents matching query terms",
+		Long: `Search for documents using TF-IDF ranking.
+
+Examples:
+  noteleaf search query go programming
+  noteleaf search query "machine learning" --limit 5`,
+		Args: cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			query := strings.Join(args, " ")
+			limit, _ := cmd.Flags().GetInt("limit")
+
+			return c.handler.Search(cmd.Context(), query, limit)
+		},
+	}
+	queryCmd.Flags().IntP("limit", "l", 10, "Maximum number of results to return")
+	root.AddCommand(queryCmd)
+
+	rebuildCmd := &cobra.Command{
+		Use:   "rebuild",
+		Short: "Rebuild search index from notes",
+		Long: `Rebuild the search index from all notes in the database.
+
+This command:
+1. Clears the existing document index
+2. Copies all notes to the documents table
+3. Builds a new TF-IDF search index
+
+Run this after adding, updating, or deleting notes to refresh the search index.`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return c.handler.RebuildIndex(cmd.Context())
+		},
+	}
+	root.AddCommand(rebuildCmd)
+
+	return root
+}

internal/docs/ROADMAP.md

···
     - Invalid IDs
     - Invalid flags
     - Schema corruption (already tested in repo)
-- [ ] Test cross-platform behavior (Linux/macOS/Windows).
 
 ### Packaging
 
···
 - [ ] Operations
     - [ ] `annotate`
     - [ ] Bulk edit and undo/history
-    - [ ] `$EDITOR` integration
 - [x] Reports and Views
     - [x] Next actions
     - [x] Completed/waiting/blocked reports
···
 ### Notes
 
 - [ ] Commands
-    - [ ] `note search`
+    - [x] `note search` - TF-IDF search via `search query` command
     - [ ] `note tag`
     - [ ] `note recent`
     - [ ] `note templates`
     - [ ] `note archive`
     - [ ] `note export`
 - [ ] Features
-    - [ ] Full-text search
+    - [x] Full-text search - TF-IDF ranking with Unicode tokenization
     - [ ] Linking between notes, tasks, and media
+
+### Search
+
+#### Ranking Improvements
+
+- [ ] BM25 scoring algorithm
+    - [ ] Implement Okapi BM25 with configurable parameters (k1, b)
+    - [ ] Field-aware BM25F with title/body weighting
+    - [ ] Pluggable scoring strategy interface (TF-IDF/BM25 interchangeable)
+    - [ ] Benchmark against TF-IDF on sample corpus
+
+#### Query Features
+
+- [ ] Phrase and proximity queries
+    - [ ] Positional inverted index (track term positions in documents)
+    - [ ] Exact phrase matching (`"go programming"`)
+    - [ ] Proximity scoring (boost when terms appear near each other)
+- [ ] Query understanding
+    - [ ] Synonym expansion with configurable dictionaries
+    - [ ] Boolean operators (AND, OR, NOT)
+    - [ ] Field-specific queries (`title:golang body:concurrency`)
+    - [ ] Spelling correction with edit distance suggestions
+    - [ ] Query boosting syntax (`title^3 golang`)
+
+#### Linguistic Processing
+
+- [ ] Text normalization
+    - [ ] Porter stemmer for English (run/runs/running → run)
+    - [ ] Stopword filtering with domain-specific lists
+    - [ ] Unicode normalization and diacritic folding
+    - [ ] Configurable token filter pipeline
+- [ ] Multi-language support
+    - [ ] Language detection
+    - [ ] Language-specific stemmers
+    - [ ] CJK tokenization improvements
+
+#### Advanced Scoring
+
+- [ ] Learning to Rank
+    - [ ] Feature extraction (TF-IDF/BM25 scores, term coverage, recency)
+    - [ ] Click-through rate tracking for relevance feedback
+    - [ ] Gradient-boosted tree models for re-ranking
+    - [ ] Evaluation metrics (NDCG, MAP)
+- [ ] Non-text signals
+    - [ ] Document recency scoring
+    - [ ] Tag-based relevance
+    - [ ] User interaction signals
+
+#### Index Management
+
+- [ ] Persistence and optimization
+    - [ ] On-disk index snapshots (gob serialization)
+    - [ ] Segmented indexing with periodic merging (Lucene-style)
+    - [ ] Incremental updates (add/update/delete without full rebuild)
+    - [ ] Index versioning and rollback
+    - [ ] Compression for large corpora
+- [ ] Performance
+    - [ ] Index build benchmarks vs corpus size
+    - [ ] Query latency monitoring
+    - [ ] Memory usage profiling
+    - [ ] Concurrent search support
+
+#### User Experience
+
+- [ ] Interactive search interface
+    - [ ] TUI with real-time search-as-you-type
+    - [ ] Result navigation with vim keybindings
+    - [ ] Preview pane showing full note content
+    - [ ] Filtering by tags, date ranges, doc kind
+    - [ ] Sort options (relevance, date, alphabetical)
+    - [ ] Quick actions (open in editor, copy ID, tag)
+- [ ] Search result display
+    - [ ] Snippet generation with matched term highlighting
+    - [ ] Configurable result limit and pagination
+    - [ ] Score explanation mode (`--explain` flag)
+    - [ ] Export results to JSON/CSV
+- [ ] CLI
+    - [ ] Saved search queries and aliases
+    - [ ] Search history
+    - [ ] Query latency and result count in output
+    - [ ] Color-coded relevance scores
 
 ### Media
 
···
 | Tasks        | Urgency scoring            | Complete  |
 | Tasks        | Reports and views          | Complete  |
 | Notes        | CRUD                       | Complete  |
-| Notes        | Search/tagging             | Planned   |
+| Notes        | Search (TF-IDF)            | Complete  |
+| Notes        | Advanced search            | Planned   |
+| Notes        | Tagging                    | Planned   |
 | Publications | AT Protocol sync           | Complete  |
 | Publications | Post/patch/push            | Complete  |
 | Publications | Markdown conversion        | Complete  |
···
 | System       | Configuration management   | Complete  |
 | System       | Synchronization            | Future    |
 | System       | Import/export formats      | Future    |
+
+## Parking Lot
+
+- [ ] Test cross-platform behavior (Linux/macOS/Windows).
+- [ ] `$EDITOR` integration

internal/documents/documents.go

···
+// Term Frequency-Inverse Document Frequency search model for notes
+package documents
+
+import (
+	"math"
+	"regexp"
+	"sort"
+	"strings"
+	"time"
+)
+
+type DocKind int64
+
+const (
+	NoteDoc DocKind = iota
+	ArticleDoc
+	MovieDoc
+	BookDoc
+	TVDoc
+)
+
+type Document struct {
+	ID        int64
+	Title     string
+	Body      string
+	CreatedAt time.Time
+	DocKind   int64
+}
+
+type Posting struct {
+	DocID int64
+	TF    int
+}
+
+type Index struct {
+	Postings   map[string][]Posting
+	DocLengths map[int64]int
+	NumDocs    int
+}
+
+type Result struct {
+	DocID int64
+	Score float64
+}
+
+type Searchable interface {
+	Search(query string, limit int) ([]Result, error)
+}
+
+// Tokenizer handles text tokenization and normalization
+type Tokenizer struct {
+	pattern *regexp.Regexp
+}
+
+// NewTokenizer creates a new tokenizer with Unicode-aware word/number matching
+func NewTokenizer() *Tokenizer {
+	return &Tokenizer{
+		pattern: regexp.MustCompile(`\p{L}+\p{M}*|\p{N}+`),
+	}
+}
+
+// Tokenize splits text into normalized tokens (lowercase words and numbers)
+func (t *Tokenizer) Tokenize(text string) []string {
+	lowered := strings.ToLower(text)
+	return t.pattern.FindAllString(lowered, -1)
+}
+
+// TokenFrequency computes term frequency map for tokens
+func TokenFrequency(tokens []string) map[string]int {
+	freq := make(map[string]int)
+	for _, token := range tokens {
+		freq[token]++
+	}
+	return freq
+}
+
+// BuildIndex constructs a TF-IDF index from a collection of documents
+func BuildIndex(docs []Document) *Index {
+	idx := &Index{
+		Postings:   make(map[string][]Posting),
+		DocLengths: make(map[int64]int),
+		NumDocs:    0,
+	}
+
+	tokenizer := NewTokenizer()
+
+	for _, doc := range docs {
+		text := doc.Title + " " + doc.Body
+		tokens := tokenizer.Tokenize(text)
+
+		idx.NumDocs++
+		idx.DocLengths[doc.ID] = len(tokens)
+
+		freq := TokenFrequency(tokens)
+
+		for term, tf := range freq {
+			idx.Postings[term] = append(idx.Postings[term], Posting{
+				DocID: doc.ID,
+				TF:    tf,
+			})
+		}
+	}
+
+	return idx
+}
+
+// Search performs TF-IDF ranked search on the index
+func (idx *Index) Search(query string, limit int) ([]Result, error) {
+	tokenizer := NewTokenizer()
+	queryTokens := tokenizer.Tokenize(query)
+
+	if len(queryTokens) == 0 {
+		return []Result{}, nil
+	}
+
+	scores := make(map[int64]float64)
+
+	for _, term := range queryTokens {
+		postings, exists := idx.Postings[term]
+		if !exists {
+			continue
+		}
+
+		df := len(postings)
+		idf := math.Log(float64(idx.NumDocs) / float64(df))
+
+		for _, posting := range postings {
+			tf := float64(posting.TF)
+			scores[posting.DocID] += tf * idf
+		}
+	}
+
+	results := make([]Result, 0, len(scores))
+	for docID, score := range scores {
+		results = append(results, Result{
+			DocID: docID,
+			Score: score,
+		})
+	}
+
+	sort.Slice(results, func(i, j int) bool {
+		if results[i].Score != results[j].Score {
+			return results[i].Score > results[j].Score
+		}
+		return results[i].DocID > results[j].DocID
+	})
+
+	if limit > 0 && limit < len(results) {
+		results = results[:limit]
+	}
+
+	return results, nil
+}

internal/documents/documents_test.go

···
+package documents
+
+import (
+	"testing"
+	"time"
+)
+
+func TestTokenizer(t *testing.T) {
+	tokenizer := NewTokenizer()
+
+	t.Run("Basic tokenization", func(t *testing.T) {
+		t.Run("tokenizes simple text", func(t *testing.T) {
+			tokens := tokenizer.Tokenize("Hello World")
+			if len(tokens) != 2 {
+				t.Fatalf("expected 2 tokens, got %d", len(tokens))
+			}
+			if tokens[0] != "hello" || tokens[1] != "world" {
+				t.Errorf("expected [hello world], got %v", tokens)
+			}
+		})
+
+		t.Run("lowercases all tokens", func(t *testing.T) {
+			tokens := tokenizer.Tokenize("UPPERCASE MiXeD lowercase")
+			if len(tokens) != 3 {
+				t.Fatalf("expected 3 tokens, got %d", len(tokens))
+			}
+			for _, token := range tokens {
+				if token != "uppercase" && token != "mixed" && token != "lowercase" {
+					t.Errorf("unexpected token: %s", token)
+				}
+			}
+		})
+
+		t.Run("handles punctuation", func(t *testing.T) {
+			tokens := tokenizer.Tokenize("Hello, world! How are you?")
+			expected := []string{"hello", "world", "how", "are", "you"}
+			if len(tokens) != len(expected) {
+				t.Fatalf("expected %d tokens, got %d", len(expected), len(tokens))
+			}
+			for i, token := range tokens {
+				if token != expected[i] {
+					t.Errorf("token %d: expected %s, got %s", i, expected[i], token)
+				}
+			}
+		})
+	})
+
+	t.Run("Unicode support", func(t *testing.T) {
+		t.Run("tokenizes unicode characters", func(t *testing.T) {
+			tokens := tokenizer.Tokenize("café résumé naïve")
+			if len(tokens) != 3 {
+				t.Fatalf("expected 3 tokens, got %d", len(tokens))
+			}
+		})
+
+		t.Run("handles emoji and special characters", func(t *testing.T) {
+			tokens := tokenizer.Tokenize("hello 😀 world")
+			if len(tokens) != 2 {
+				t.Fatalf("expected 2 tokens (emoji excluded), got %d", len(tokens))
+			}
+			if tokens[0] != "hello" || tokens[1] != "world" {
+				t.Errorf("expected [hello world], got %v", tokens)
+			}
+		})
+
+		t.Run("tokenizes CJK characters", func(t *testing.T) {
+			tokens := tokenizer.Tokenize("你好 世界")
+			if len(tokens) != 2 {
+				t.Fatalf("expected 2 tokens, got %d", len(tokens))
+			}
+		})
+	})
+
+	t.Run("Numbers", func(t *testing.T) {
+		t.Run("tokenizes numbers", func(t *testing.T) {
+			tokens := tokenizer.Tokenize("test 123 456")
+			if len(tokens) != 3 {
+				t.Fatalf("expected 3 tokens, got %d", len(tokens))
+			}
+			if tokens[1] != "123" || tokens[2] != "456" {
+				t.Errorf("expected numbers to be tokenized, got %v", tokens)
+			}
+		})
+
+		t.Run("handles mixed alphanumeric", func(t *testing.T) {
+			tokens := tokenizer.Tokenize("version 2 released")
+			if len(tokens) != 3 {
+				t.Fatalf("expected 3 tokens, got %d", len(tokens))
+			}
+		})
+	})
+
+	t.Run("Edge cases", func(t *testing.T) {
+		t.Run("handles empty string", func(t *testing.T) {
+			tokens := tokenizer.Tokenize("")
+			if len(tokens) != 0 {
+				t.Errorf("expected 0 tokens for empty string, got %d", len(tokens))
+			}
+		})
+
+		t.Run("handles whitespace only", func(t *testing.T) {
+			tokens := tokenizer.Tokenize("   \t\n  ")
+			if len(tokens) != 0 {
+				t.Errorf("expected 0 tokens for whitespace, got %d", len(tokens))
+			}
+		})
+
+		t.Run("handles punctuation only", func(t *testing.T) {
+			tokens := tokenizer.Tokenize("!@#$%^&*()")
+			if len(tokens) != 0 {
+				t.Errorf("expected 0 tokens for punctuation only, got %d", len(tokens))
+			}
+		})
+	})
+}
+
+func TestTokenFrequency(t *testing.T) {
+	t.Run("counts term frequencies", func(t *testing.T) {
+		tokens := []string{"hello", "world", "hello", "test"}
+		freq := TokenFrequency(tokens)
+
+		if freq["hello"] != 2 {
+			t.Errorf("expected hello frequency 2, got %d", freq["hello"])
+		}
+		if freq["world"] != 1 {
+			t.Errorf("expected world frequency 1, got %d", freq["world"])
+		}
+		if freq["test"] != 1 {
+			t.Errorf("expected test frequency 1, got %d", freq["test"])
+		}
+	})
+
+	t.Run("handles empty token list", func(t *testing.T) {
+		freq := TokenFrequency([]string{})
+		if len(freq) != 0 {
+			t.Errorf("expected empty frequency map, got %d entries", len(freq))
+		}
+	})
+
+	t.Run("handles single token", func(t *testing.T) {
+		freq := TokenFrequency([]string{"single"})
+		if freq["single"] != 1 {
+			t.Errorf("expected frequency 1, got %d", freq["single"])
+		}
+	})
+}
+
+func TestBuildIndex(t *testing.T) {
+	now := time.Now()
+
+	t.Run("builds index from documents", func(t *testing.T) {
+		docs := []Document{
+			{ID: 1, Title: "Go Programming", Body: "Go is a great language", CreatedAt: now, DocKind: int64(NoteDoc)},
+			{ID: 2, Title: "Python Guide", Body: "Python is versatile", CreatedAt: now, DocKind: int64(ArticleDoc)},
+		}
+
+		idx := BuildIndex(docs)
+
+		if idx.NumDocs != 2 {
+			t.Errorf("expected NumDocs 2, got %d", idx.NumDocs)
+		}
+
+		if len(idx.DocLengths) != 2 {
+			t.Errorf("expected 2 document lengths, got %d", len(idx.DocLengths))
+		}
+
+		if idx.DocLengths[1] <= 0 || idx.DocLengths[2] <= 0 {
+			t.Error("document lengths should be positive")
+		}
+
+		if _, exists := idx.Postings["go"]; !exists {
+			t.Error("expected 'go' to be in postings")
+		}
+		if _, exists := idx.Postings["python"]; !exists {
+			t.Error("expected 'python' to be in postings")
+		}
+	})
+
+	t.Run("handles empty document list", func(t *testing.T) {
+		idx := BuildIndex([]Document{})
+		if idx.NumDocs != 0 {
+			t.Errorf("expected NumDocs 0, got %d", idx.NumDocs)
+		}
+		if len(idx.Postings) != 0 {
+			t.Errorf("expected empty postings, got %d entries", len(idx.Postings))
+		}
+	})
+
+	t.Run("calculates term frequencies correctly", func(t *testing.T) {
+		docs := []Document{
+			{ID: 1, Title: "test", Body: "test test test", CreatedAt: now, DocKind: int64(NoteDoc)},
+		}
+
+		idx := BuildIndex(docs)
+
+		postings := idx.Postings["test"]
+		if len(postings) != 1 {
+			t.Fatalf("expected 1 posting for 'test', got %d", len(postings))
+		}
+
+		if postings[0].TF != 4 {
+			t.Errorf("expected TF 4 (title + 3 in body), got %d", postings[0].TF)
+		}
+	})
+
+	t.Run("builds postings for multiple documents with same term", func(t *testing.T) {
+		docs := []Document{
+			{ID: 1, Title: "Go", Body: "Go is great", CreatedAt: now, DocKind: int64(NoteDoc)},
+			{ID: 2, Title: "Go Tutorial", Body: "Learn Go", CreatedAt: now, DocKind: int64(NoteDoc)},
+		}
+
+		idx := BuildIndex(docs)
+
+		postings := idx.Postings["go"]
+		if len(postings) != 2 {
+			t.Fatalf("expected 2 postings for 'go', got %d", len(postings))
+		}
+	})
+}
+
+func TestIndexSearch(t *testing.T) {
+	now := time.Now()
+
+	t.Run("Search functionality", func(t *testing.T) {
+		t.Run("returns empty results for empty query", func(t *testing.T) {
+			docs := []Document{
+				{ID: 1, Title: "Test", Body: "content", CreatedAt: now, DocKind: int64(NoteDoc)},
+			}
+			idx := BuildIndex(docs)
+
+			results, err := idx.Search("", 10)
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if len(results) != 0 {
+				t.Errorf("expected 0 results for empty query, got %d", len(results))
+			}
+		})
+
+		t.Run("finds matching documents", func(t *testing.T) {
+			docs := []Document{
+				{ID: 1, Title: "Go Programming", Body: "Learn Go language", CreatedAt: now, DocKind: int64(NoteDoc)},
+				{ID: 2, Title: "Python Guide", Body: "Python is versatile", CreatedAt: now, DocKind: int64(ArticleDoc)},
+			}
+			idx := BuildIndex(docs)
+
+			results, err := idx.Search("go", 10)
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+
+			if len(results) != 1 {
+				t.Fatalf("expected 1 result, got %d", len(results))
+			}
+
+			if results[0].DocID != 1 {
+				t.Errorf("expected DocID 1, got %d", results[0].DocID)
+			}
+
+			if results[0].Score <= 0 {
+				t.Error("expected positive score")
+			}
+		})
+
+		t.Run("ranks documents by relevance", func(t *testing.T) {
+			docs := []Document{
+				{ID: 1, Title: "Go", Body: "tutorial python rust", CreatedAt: now, DocKind: int64(NoteDoc)},
+				{ID: 2, Title: "Go Programming", Body: "advanced go tutorial", CreatedAt: now, DocKind: int64(NoteDoc)},
+				{ID: 3, Title: "Python", Body: "different language", CreatedAt: now, DocKind: int64(NoteDoc)},
+			}
+			idx := BuildIndex(docs)
+
+			results, err := idx.Search("go", 10)
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+
+			if len(results) != 2 {
+				t.Fatalf("expected 2 results, got %d", len(results))
+			}
+
+			if results[0].DocID != 2 {
+				t.Errorf("expected document 2 to rank higher (has more 'go' terms)")
+			}
+
+			if results[0].Score <= results[1].Score {
+				t.Errorf("expected first result to have higher score, got %f <= %f", results[0].Score, results[1].Score)
+			}
+		})
+
+		t.Run("respects limit parameter", func(t *testing.T) {
+			docs := []Document{
+				{ID: 1, Title: "test one", Body: "content", CreatedAt: now, DocKind: int64(NoteDoc)},
+				{ID: 2, Title: "test two", Body: "content", CreatedAt: now, DocKind: int64(NoteDoc)},
+				{ID: 3, Title: "test three", Body: "content", CreatedAt: now, DocKind: int64(NoteDoc)},
+			}
+			idx := BuildIndex(docs)
+
+			results, err := idx.Search("test", 2)
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+
+			if len(results) != 2 {
+				t.Errorf("expected 2 results with limit=2, got %d", len(results))
+			}
+		})
+
+		t.Run("handles multi-term queries", func(t *testing.T) {
+			docs := []Document{
+				{ID: 1, Title: "Go Programming", Body: "advanced tutorial", CreatedAt: now, DocKind: int64(NoteDoc)},
+				{ID: 2, Title: "Go Basics", Body: "beginner tutorial", CreatedAt: now, DocKind: int64(NoteDoc)},
+				{ID: 3, Title: "Python", Body: "different language", CreatedAt: now, DocKind: int64(NoteDoc)},
+			}
+			idx := BuildIndex(docs)
+
+			results, err := idx.Search("go tutorial", 10)
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+
+			if len(results) != 2 {
+				t.Errorf("expected 2 results, got %d", len(results))
+			}
+		})
+
+		t.Run("returns no results for non-matching query", func(t *testing.T) {
+			docs := []Document{
+				{ID: 1, Title: "Go", Body: "programming", CreatedAt: now, DocKind: int64(NoteDoc)},
+			}
+			idx := BuildIndex(docs)
+
+			results, err := idx.Search("rust", 10)
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+
+			if len(results) != 0 {
+				t.Errorf("expected 0 results for non-matching query, got %d", len(results))
+			}
+		})
+
+		t.Run("handles zero limit", func(t *testing.T) {
+			docs := []Document{
+				{ID: 1, Title: "test", Body: "content", CreatedAt: now, DocKind: int64(NoteDoc)},
+			}
+			idx := BuildIndex(docs)
+
+			results, err := idx.Search("test", 0)
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+
+			if len(results) != 1 {
+				t.Errorf("expected all results with limit=0, got %d", len(results))
+			}
+		})
+
+		t.Run("tie-breaking uses DocID", func(t *testing.T) {
+			docs := []Document{
+				{ID: 1, Title: "test", Body: "content", CreatedAt: now, DocKind: int64(NoteDoc)},
+				{ID: 2, Title: "test", Body: "content", CreatedAt: now, DocKind: int64(NoteDoc)},
+			}
+			idx := BuildIndex(docs)
+
+			results, err := idx.Search("test", 10)
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+
+			if len(results) != 2 {
+				t.Fatalf("expected 2 results, got %d", len(results))
+			}
+
+			if results[0].DocID <= results[1].DocID {
+				t.Error("expected higher DocID first when scores are equal")
+			}
+		})
+	})
+}

internal/documents/test_utilities.go

···
+package documents

internal/handlers/documents.go

···
+package handlers
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+	"github.com/stormlightlabs/noteleaf/internal/store"
+)
+
+// DocumentHandler provides operations for document search
+type DocumentHandler struct {
+	db     *sql.DB
+	repos  *repo.Repositories
+	engine *repo.SearchEngine
+}
+
+// NewDocumentHandler creates a new document handler
+func NewDocumentHandler() (*DocumentHandler, error) {
+	db, err := store.NewDatabase()
+	if err != nil {
+		return nil, fmt.Errorf("failed to initialize database: %w", err)
+	}
+
+	repos := repo.NewRepositories(db.DB)
+	engine := repo.NewSearchEngine(repos.Documents)
+
+	return &DocumentHandler{
+		db:     db.DB,
+		repos:  repos,
+		engine: engine,
+	}, nil
+}
+
+// RebuildIndex rebuilds the search index from notes
+func (h *DocumentHandler) RebuildIndex(ctx context.Context) error {
+	if err := h.repos.Documents.DeleteAll(ctx); err != nil {
+		return fmt.Errorf("failed to clear documents: %w", err)
+	}
+
+	if err := h.repos.Documents.RebuildFromNotes(ctx, h.repos.Notes); err != nil {
+		return fmt.Errorf("failed to rebuild from notes: %w", err)
+	}
+
+	if err := h.engine.Rebuild(ctx); err != nil {
+		return fmt.Errorf("failed to rebuild search index: %w", err)
+	}
+
+	fmt.Println("Search index rebuilt successfully")
+	return nil
+}
+
+// Search performs a TF-IDF search and displays results
+func (h *DocumentHandler) Search(ctx context.Context, query string, limit int) error {
+	if err := h.engine.Rebuild(ctx); err != nil {
+		return fmt.Errorf("failed to rebuild index: %w", err)
+	}
+
+	results, docs, err := h.engine.SearchWithScores(ctx, query, limit)
+	if err != nil {
+		return fmt.Errorf("search failed: %w", err)
+	}
+
+	if len(results) == 0 {
+		fmt.Println("No results found")
+		return nil
+	}
+
+	fmt.Printf("Found %d results:\n\n", len(results))
+	for i, doc := range docs {
+		score := results[i].Score
+		fmt.Printf("%d. [Score: %.2f] %s\n", i+1, score, doc.Title)
+		fmt.Printf("   %s\n\n", truncate(doc.Body, 100))
+	}
+
+	return nil
+}
+
+func truncate(s string, maxLen int) string {
+	if len(s) <= maxLen {
+		return s
+	}
+	return s[:maxLen] + "..."
+}

internal/repo/document_repository.go

···
+package repo
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+
+	"github.com/stormlightlabs/noteleaf/internal/documents"
+)
+
+func DocumentNotFoundError(id int64) error {
+	return fmt.Errorf("document with id %d not found", id)
+}
+
+// DocumentRepository provides database operations for documents
+type DocumentRepository struct {
+	db *sql.DB
+}
+
+// NewDocumentRepository creates a new document repository
+func NewDocumentRepository(db *sql.DB) *DocumentRepository {
+	return &DocumentRepository{db: db}
+}
+
+// scanDocument scans a database row into a Document model
+func (r *DocumentRepository) scanDocument(s scanner) (*documents.Document, error) {
+	var doc documents.Document
+	err := s.Scan(&doc.ID, &doc.Title, &doc.Body, &doc.CreatedAt, &doc.DocKind)
+	if err != nil {
+		return nil, err
+	}
+	return &doc, nil
+}
+
+// queryOne executes a query that returns a single document
+func (r *DocumentRepository) queryOne(ctx context.Context, query string, args ...any) (*documents.Document, error) {
+	row := r.db.QueryRowContext(ctx, query, args...)
+	doc, err := r.scanDocument(row)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return nil, fmt.Errorf("document not found")
+		}
+		return nil, fmt.Errorf("failed to scan document: %w", err)
+	}
+	return doc, nil
+}
+
+// queryMany executes a query that returns multiple documents
+func (r *DocumentRepository) queryMany(ctx context.Context, query string, args ...any) ([]documents.Document, error) {
+	rows, err := r.db.QueryContext(ctx, query, args...)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query documents: %w", err)
+	}
+	defer rows.Close()
+
+	var docs []documents.Document
+	for rows.Next() {
+		doc, err := r.scanDocument(rows)
+		if err != nil {
+			return nil, fmt.Errorf("failed to scan document: %w", err)
+		}
+		docs = append(docs, *doc)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("error iterating over documents: %w", err)
+	}
+
+	return docs, nil
+}
+
+// Create stores a new document and returns its assigned ID
+func (r *DocumentRepository) Create(ctx context.Context, doc *documents.Document) (int64, error) {
+	result, err := r.db.ExecContext(ctx, queryDocumentInsert,
+		doc.Title, doc.Body, doc.CreatedAt, doc.DocKind)
+	if err != nil {
+		return 0, fmt.Errorf("failed to insert document: %w", err)
+	}
+
+	id, err := result.LastInsertId()
+	if err != nil {
+		return 0, fmt.Errorf("failed to get last insert id: %w", err)
+	}
+
+	doc.ID = id
+	return id, nil
+}
+
+// Get retrieves a document by its ID
+func (r *DocumentRepository) Get(ctx context.Context, id int64) (*documents.Document, error) {
+	doc, err := r.queryOne(ctx, queryDocumentByID, id)
+	if err != nil {
+		return nil, DocumentNotFoundError(id)
+	}
+	return doc, nil
+}
+
+// Delete removes a document by its ID
+func (r *DocumentRepository) Delete(ctx context.Context, id int64) error {
+	result, err := r.db.ExecContext(ctx, queryDocumentDelete, id)
+	if err != nil {
+		return fmt.Errorf("failed to delete document: %w", err)
+	}
+
+	rowsAffected, err := result.RowsAffected()
+	if err != nil {
+		return fmt.Errorf("failed to get rows affected: %w", err)
+	}
+
+	if rowsAffected == 0 {
+		return DocumentNotFoundError(id)
+	}
+
+	return nil
+}
+
+// List retrieves all documents
+func (r *DocumentRepository) List(ctx context.Context) ([]documents.Document, error) {
+	return r.queryMany(ctx, queryDocumentsList)
+}
+
+// ListByKind retrieves documents of a specific kind
+func (r *DocumentRepository) ListByKind(ctx context.Context, kind documents.DocKind) ([]documents.Document, error) {
+	return r.queryMany(ctx, queryDocumentsByKind, int64(kind))
+}
+
+// DeleteAll removes all documents from the database
+func (r *DocumentRepository) DeleteAll(ctx context.Context) error {
+	_, err := r.db.ExecContext(ctx, queryDocumentsDeleteAll)
+	if err != nil {
+		return fmt.Errorf("failed to delete all documents: %w", err)
+	}
+	return nil
+}
+
+// RebuildFromNotes rebuilds the documents table from notes
+func (r *DocumentRepository) RebuildFromNotes(ctx context.Context, noteRepo *NoteRepository) error {
+	notes, err := noteRepo.List(ctx, NoteListOptions{})
+	if err != nil {
+		return fmt.Errorf("failed to list notes: %w", err)
+	}
+
+	for _, note := range notes {
+		doc := &documents.Document{
+			Title:     note.Title,
+			Body:      note.Content,
+			CreatedAt: note.Created,
+			DocKind:   int64(documents.NoteDoc),
+		}
+
+		if _, err := r.Create(ctx, doc); err != nil {
+			return fmt.Errorf("failed to create document from note %d: %w", note.ID, err)
+		}
+	}
+
+	return nil
+}
+
+// BuildIndex creates a TF-IDF index from all documents in the database
+func (r *DocumentRepository) BuildIndex(ctx context.Context) (*documents.Index, error) {
+	docs, err := r.List(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to list documents: %w", err)
+	}
+
+	return documents.BuildIndex(docs), nil
+}
+
+// SearchEngine wraps a DocumentRepository with search capabilities
+type SearchEngine struct {
+	repo  *DocumentRepository
+	index *documents.Index
+}
+
+// NewSearchEngine creates a new search engine with the given repository
+func NewSearchEngine(repo *DocumentRepository) *SearchEngine {
+	return &SearchEngine{
+		repo:  repo,
+		index: nil,
+	}
+}
+
+// Rebuild rebuilds the search index from the database
+func (se *SearchEngine) Rebuild(ctx context.Context) error {
+	idx, err := se.repo.BuildIndex(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to build index: %w", err)
+	}
+
+	se.index = idx
+	return nil
+}
+
+// Search performs a TF-IDF search and returns matching documents
+func (se *SearchEngine) Search(ctx context.Context, query string, limit int) ([]documents.Document, error) {
+	if se.index == nil {
+		return nil, fmt.Errorf("search index not initialized")
+	}
+
+	results, err := se.index.Search(query, limit)
+	if err != nil {
+		return nil, fmt.Errorf("failed to search: %w", err)
+	}
+
+	docs := make([]documents.Document, 0, len(results))
+	for _, result := range results {
+		doc, err := se.repo.Get(ctx, result.DocID)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get document %d: %w", result.DocID, err)
+		}
+		docs = append(docs, *doc)
+	}
+
+	return docs, nil
+}
+
+// SearchWithScores performs a TF-IDF search and returns results with scores
+func (se *SearchEngine) SearchWithScores(ctx context.Context, query string, limit int) ([]documents.Result, []documents.Document, error) {
+	if se.index == nil {
+		return nil, nil, fmt.Errorf("search index not initialized")
+	}
+
+	results, err := se.index.Search(query, limit)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to search: %w", err)
+	}
+
+	docs := make([]documents.Document, 0, len(results))
+	for _, result := range results {
+		doc, err := se.repo.Get(ctx, result.DocID)
+		if err != nil {
+			return nil, nil, fmt.Errorf("failed to get document %d: %w", result.DocID, err)
+		}
+		docs = append(docs, *doc)
+	}
+
+	return results, docs, nil
+}

internal/repo/document_repository_test.go

···
+package repo
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stormlightlabs/noteleaf/internal/documents"
+	"github.com/stormlightlabs/noteleaf/internal/shared"
+)
+
+func CreateSampleDocument() *documents.Document {
+	return &documents.Document{
+		Title:     "Test Document",
+		Body:      "This is test content for searching",
+		CreatedAt: time.Now(),
+		DocKind:   int64(documents.NoteDoc),
+	}
+}
+
+func TestDocumentRepository(t *testing.T) {
+	db := CreateTestDB(t)
+	repo := NewDocumentRepository(db)
+	ctx := context.Background()
+
+	t.Run("Create", func(t *testing.T) {
+		t.Run("creates document successfully", func(t *testing.T) {
+			doc := CreateSampleDocument()
+			id, err := repo.Create(ctx, doc)
+
+			shared.AssertNoError(t, err, "create should succeed")
+			shared.AssertTrue(t, id > 0, "id should be positive")
+			shared.AssertEqual(t, id, doc.ID, "document ID should be set")
+		})
+
+		t.Run("returns error with cancelled context", func(t *testing.T) {
+			doc := CreateSampleDocument()
+			canceledCtx := NewCanceledContext()
+
+			_, err := repo.Create(canceledCtx, doc)
+			AssertCancelledContext(t, err)
+		})
+	})
+
+	t.Run("Get", func(t *testing.T) {
+		t.Run("retrieves existing document", func(t *testing.T) {
+			doc := CreateSampleDocument()
+			id, err := repo.Create(ctx, doc)
+			shared.AssertNoError(t, err, "create should succeed")
+
+			retrieved, err := repo.Get(ctx, id)
+			shared.AssertNoError(t, err, "get should succeed")
+			shared.AssertEqual(t, doc.Title, retrieved.Title, "title should match")
+			shared.AssertEqual(t, doc.Body, retrieved.Body, "body should match")
+			shared.AssertEqual(t, doc.DocKind, retrieved.DocKind, "doc kind should match")
+		})
+
+		t.Run("returns error for non-existent document", func(t *testing.T) {
+			_, err := repo.Get(ctx, 99999)
+			shared.AssertError(t, err, "should return error for non-existent document")
+			shared.AssertContains(t, err.Error(), "not found", "error should mention not found")
+		})
+
+		t.Run("returns error with cancelled context", func(t *testing.T) {
+			canceledCtx := NewCanceledContext()
+			_, err := repo.Get(canceledCtx, 1)
+			AssertCancelledContext(t, err)
+		})
+	})
+
+	t.Run("Delete", func(t *testing.T) {
+		t.Run("deletes existing document", func(t *testing.T) {
+			doc := CreateSampleDocument()
+			id, err := repo.Create(ctx, doc)
+			shared.AssertNoError(t, err, "create should succeed")
+
+			err = repo.Delete(ctx, id)
+			shared.AssertNoError(t, err, "delete should succeed")
+
+			_, err = repo.Get(ctx, id)
+			shared.AssertError(t, err, "get after delete should fail")
+		})
+
+		t.Run("returns error for non-existent document", func(t *testing.T) {
+			err := repo.Delete(ctx, 99999)
+			shared.AssertError(t, err, "should return error for non-existent document")
+		})
+
+		t.Run("returns error with cancelled context", func(t *testing.T) {
+			canceledCtx := NewCanceledContext()
+			err := repo.Delete(canceledCtx, 1)
+			AssertCancelledContext(t, err)
+		})
+	})
+
+	t.Run("List", func(t *testing.T) {
+		t.Run("returns all documents", func(t *testing.T) {
+			db := CreateTestDB(t)
+			repo := NewDocumentRepository(db)
+
+			doc1 := CreateSampleDocument()
+			doc1.Title = "First"
+			doc2 := CreateSampleDocument()
+			doc2.Title = "Second"
+
+			_, err := repo.Create(ctx, doc1)
+			shared.AssertNoError(t, err, "create doc1 should succeed")
+			_, err = repo.Create(ctx, doc2)
+			shared.AssertNoError(t, err, "create doc2 should succeed")
+
+			docs, err := repo.List(ctx)
+			shared.AssertNoError(t, err, "list should succeed")
+			shared.AssertEqual(t, 2, len(docs), "should return 2 documents")
+		})
+
+		t.Run("returns empty list when no documents exist", func(t *testing.T) {
+			db := CreateTestDB(t)
+			repo := NewDocumentRepository(db)
+
+			docs, err := repo.List(ctx)
+			shared.AssertNoError(t, err, "list should succeed")
+			shared.AssertEqual(t, 0, len(docs), "should return empty list")
+		})
+
+		t.Run("returns error with cancelled context", func(t *testing.T) {
+			canceledCtx := NewCanceledContext()
+			_, err := repo.List(canceledCtx)
+			AssertCancelledContext(t, err)
+		})
+	})
+
+	t.Run("ListByKind", func(t *testing.T) {
+		t.Run("filters documents by kind", func(t *testing.T) {
+			db := CreateTestDB(t)
+			repo := NewDocumentRepository(db)
+
+			noteDoc := CreateSampleDocument()
+			noteDoc.DocKind = int64(documents.NoteDoc)
+			articleDoc := CreateSampleDocument()
+			articleDoc.DocKind = int64(documents.ArticleDoc)
+
+			_, err := repo.Create(ctx, noteDoc)
+			shared.AssertNoError(t, err, "create note should succeed")
+			_, err = repo.Create(ctx, articleDoc)
+			shared.AssertNoError(t, err, "create article should succeed")
+
+			notes, err := repo.ListByKind(ctx, documents.NoteDoc)
+			shared.AssertNoError(t, err, "list by kind should succeed")
+			shared.AssertEqual(t, 1, len(notes), "should return 1 note")
+			shared.AssertEqual(t, int64(documents.NoteDoc), notes[0].DocKind, "should be note kind")
+		})
+
+		t.Run("returns error with cancelled context", func(t *testing.T) {
+			canceledCtx := NewCanceledContext()
+			_, err := repo.ListByKind(canceledCtx, documents.NoteDoc)
+			AssertCancelledContext(t, err)
+		})
+	})
+
+	t.Run("DeleteAll", func(t *testing.T) {
+		t.Run("removes all documents", func(t *testing.T) {
+			db := CreateTestDB(t)
+			repo := NewDocumentRepository(db)
+
+			_, err := repo.Create(ctx, CreateSampleDocument())
+			shared.AssertNoError(t, err, "create should succeed")
+			_, err = repo.Create(ctx, CreateSampleDocument())
+			shared.AssertNoError(t, err, "create should succeed")
+
+			err = repo.DeleteAll(ctx)
+			shared.AssertNoError(t, err, "delete all should succeed")
+
+			docs, err := repo.List(ctx)
+			shared.AssertNoError(t, err, "list should succeed")
+			shared.AssertEqual(t, 0, len(docs), "should have no documents after delete all")
+		})
+
+		t.Run("returns error with cancelled context", func(t *testing.T) {
+			canceledCtx := NewCanceledContext()
+			err := repo.DeleteAll(canceledCtx)
+			AssertCancelledContext(t, err)
+		})
+	})
+
+	t.Run("RebuildFromNotes", func(t *testing.T) {
+		t.Run("creates documents from notes", func(t *testing.T) {
+			db := CreateTestDB(t)
+			repo := NewDocumentRepository(db)
+			noteRepo := NewNoteRepository(db)
+
+			note1 := CreateSampleNote()
+			note1.Title = "Note 1"
+			note2 := CreateSampleNote()
+			note2.Title = "Note 2"
+
+			_, err := noteRepo.Create(ctx, note1)
+			shared.AssertNoError(t, err, "create note1 should succeed")
+			_, err = noteRepo.Create(ctx, note2)
+			shared.AssertNoError(t, err, "create note2 should succeed")
+
+			err = repo.RebuildFromNotes(ctx, noteRepo)
+			shared.AssertNoError(t, err, "rebuild should succeed")
+
+			docs, err := repo.List(ctx)
+			shared.AssertNoError(t, err, "list should succeed")
+			shared.AssertEqual(t, 2, len(docs), "should have 2 documents from notes")
+		})
+
+		t.Run("returns error with cancelled context", func(t *testing.T) {
+			db := CreateTestDB(t)
+			repo := NewDocumentRepository(db)
+			noteRepo := NewNoteRepository(db)
+			canceledCtx := NewCanceledContext()
+
+			err := repo.RebuildFromNotes(canceledCtx, noteRepo)
+			AssertCancelledContext(t, err)
+		})
+	})
+
+	t.Run("BuildIndex", func(t *testing.T) {
+		t.Run("creates search index from documents", func(t *testing.T) {
+			db := CreateTestDB(t)
+			repo := NewDocumentRepository(db)
+
+			doc1 := CreateSampleDocument()
+			doc1.Title = "Go Programming"
+			doc1.Body = "Learn Go language"
+			doc2 := CreateSampleDocument()
+			doc2.Title = "Python Guide"
+			doc2.Body = "Python tutorial"
+
+			_, err := repo.Create(ctx, doc1)
+			shared.AssertNoError(t, err, "create doc1 should succeed")
+			_, err = repo.Create(ctx, doc2)
+			shared.AssertNoError(t, err, "create doc2 should succeed")
+
+			idx, err := repo.BuildIndex(ctx)
+			shared.AssertNoError(t, err, "build index should succeed")
+			shared.AssertNotNil(t, idx, "index should not be nil")
+			shared.AssertEqual(t, 2, idx.NumDocs, "index should contain 2 documents")
+		})
+
+		t.Run("handles empty document set", func(t *testing.T) {
+			db := CreateTestDB(t)
+			repo := NewDocumentRepository(db)
+
+			idx, err := repo.BuildIndex(ctx)
+			shared.AssertNoError(t, err, "build index should succeed with empty set")
+			shared.AssertEqual(t, 0, idx.NumDocs, "index should be empty")
+		})
+
+		t.Run("returns error with cancelled context", func(t *testing.T) {
+			canceledCtx := NewCanceledContext()
+			_, err := repo.BuildIndex(canceledCtx)
+			AssertCancelledContext(t, err)
+		})
+	})
+}
+
+func TestSearchEngine(t *testing.T) {
+	db := CreateTestDB(t)
+	docRepo := NewDocumentRepository(db)
+	ctx := context.Background()
+
+	doc1 := CreateSampleDocument()
+	doc1.Title = "Go Programming"
+	doc1.Body = "Learn Go programming language with examples"
+	doc2 := CreateSampleDocument()
+	doc2.Title = "Python Tutorial"
+	doc2.Body = "Python is a versatile programming language"
+	doc3 := CreateSampleDocument()
+	doc3.Title = "Go Advanced"
+	doc3.Body = "Advanced Go concepts and patterns"
+
+	_, err := docRepo.Create(ctx, doc1)
+	shared.AssertNoError(t, err, "create doc1 should succeed")
+	_, err = docRepo.Create(ctx, doc2)
+	shared.AssertNoError(t, err, "create doc2 should succeed")
+	_, err = docRepo.Create(ctx, doc3)
+	shared.AssertNoError(t, err, "create doc3 should succeed")
+
+	t.Run("Rebuild", func(t *testing.T) {
+		t.Run("builds search index", func(t *testing.T) {
+			engine := NewSearchEngine(docRepo)
+			err := engine.Rebuild(ctx)
+			shared.AssertNoError(t, err, "rebuild should succeed")
+			shared.AssertNotNil(t, engine.index, "index should be set after rebuild")
+		})
+
+		t.Run("returns error with cancelled context", func(t *testing.T) {
+			engine := NewSearchEngine(docRepo)
+			canceledCtx := NewCanceledContext()
+			err := engine.Rebuild(canceledCtx)
+			AssertCancelledContext(t, err)
+		})
+	})
+
+	t.Run("Search", func(t *testing.T) {
+		t.Run("returns error when index not initialized", func(t *testing.T) {
+			engine := NewSearchEngine(docRepo)
+			_, err := engine.Search(ctx, "go", 10)
+			shared.AssertError(t, err, "should error when index not initialized")
+			shared.AssertContains(t, err.Error(), "not initialized", "error should mention not initialized")
+		})
+
+		t.Run("finds matching documents", func(t *testing.T) {
+			engine := NewSearchEngine(docRepo)
+			err := engine.Rebuild(ctx)
+			shared.AssertNoError(t, err, "rebuild should succeed")
+
+			docs, err := engine.Search(ctx, "go", 10)
+			shared.AssertNoError(t, err, "search should succeed")
+			shared.AssertTrue(t, len(docs) >= 2, "should find at least 2 documents with 'go'")
+		})
+
+		t.Run("returns empty results for non-matching query", func(t *testing.T) {
+			engine := NewSearchEngine(docRepo)
+			err := engine.Rebuild(ctx)
+			shared.AssertNoError(t, err, "rebuild should succeed")
+
+			docs, err := engine.Search(ctx, "rust", 10)
+			shared.AssertNoError(t, err, "search should succeed")
+			shared.AssertEqual(t, 0, len(docs), "should return no results for non-matching query")
+		})
+
+		t.Run("respects limit parameter", func(t *testing.T) {
+			engine := NewSearchEngine(docRepo)
+			err := engine.Rebuild(ctx)
+			shared.AssertNoError(t, err, "rebuild should succeed")
+
+			docs, err := engine.Search(ctx, "programming", 1)
+			shared.AssertNoError(t, err, "search should succeed")
+			shared.AssertTrue(t, len(docs) <= 1, "should respect limit parameter")
+		})
+
+		t.Run("returns error with cancelled context", func(t *testing.T) {
+			engine := NewSearchEngine(docRepo)
+			err := engine.Rebuild(ctx)
+			shared.AssertNoError(t, err, "rebuild should succeed")
+
+			canceledCtx := NewCanceledContext()
+			_, err = engine.Search(canceledCtx, "go", 10)
+			AssertCancelledContext(t, err)
+		})
+	})
+
+	t.Run("SearchWithScores", func(t *testing.T) {
+		t.Run("returns results with scores", func(t *testing.T) {
+			engine := NewSearchEngine(docRepo)
+			err := engine.Rebuild(ctx)
+			shared.AssertNoError(t, err, "rebuild should succeed")
+
+			results, docs, err := engine.SearchWithScores(ctx, "go", 10)
+			shared.AssertNoError(t, err, "search should succeed")
+			shared.AssertEqual(t, len(results), len(docs), "results and docs should have same length")
+			shared.AssertTrue(t, len(results) >= 2, "should find at least 2 results")
+
+			for _, result := range results {
+				shared.AssertTrue(t, result.Score > 0, "score should be positive")
+			}
+		})
+
+		t.Run("returns error when index not initialized", func(t *testing.T) {
+			engine := NewSearchEngine(docRepo)
+			_, _, err := engine.SearchWithScores(ctx, "go", 10)
+			shared.AssertError(t, err, "should error when index not initialized")
+		})
+
+		t.Run("returns error with cancelled context", func(t *testing.T) {
+			engine := NewSearchEngine(docRepo)
+			err := engine.Rebuild(ctx)
+			shared.AssertNoError(t, err, "rebuild should succeed")
+
+			canceledCtx := NewCanceledContext()
+			_, _, err = engine.SearchWithScores(canceledCtx, "go", 10)
+			AssertCancelledContext(t, err)
+		})
+	})
+}

internal/repo/queries.go

···
 	queryTasksList  = "SELECT " + taskColumns + " FROM tasks"
 )
 
+const (
+	documentColumns         = "id, title, body, created_at, doc_kind"
+	queryDocumentByID       = "SELECT " + documentColumns + " FROM documents WHERE id = ?"
+	queryDocumentInsert     = `INSERT INTO documents (title, body, created_at, doc_kind) VALUES (?, ?, ?, ?)`
+	queryDocumentDelete     = "DELETE FROM documents WHERE id = ?"
+	queryDocumentsList      = "SELECT " + documentColumns + " FROM documents ORDER BY created_at DESC"
+	queryDocumentsByKind    = "SELECT " + documentColumns + " FROM documents WHERE doc_kind = ? ORDER BY created_at DESC"
+	queryDocumentsDeleteAll = "DELETE FROM documents"
+)
+
 type scanner interface {
 	Scan(dest ...any) error
 }

internal/repo/repo.go

···
 	Notes       *NoteRepository
 	TimeEntries *TimeEntryRepository
 	Articles    *ArticleRepository
+	Documents   *DocumentRepository
 }
 
 // NewRepositories creates a new set of [Repositories]
···
 		Notes:       NewNoteRepository(db),
 		TimeEntries: NewTimeEntryRepository(db),
 		Articles:    NewArticleRepository(db),
+		Documents:   NewDocumentRepository(db),
 	}
 }
 

internal/store/sql/migrations/0010_create_documents_table_down.sql

···
+DROP INDEX IF EXISTS idx_documents_created_at;
+DROP INDEX IF EXISTS idx_documents_doc_kind;
+DROP TABLE IF EXISTS documents;

internal/store/sql/migrations/0010_create_documents_table_up.sql

···
+CREATE TABLE IF NOT EXISTS documents (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    title TEXT NOT NULL,
+    body TEXT NOT NULL,
+    created_at DATETIME NOT NULL,
+    doc_kind INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_documents_doc_kind ON documents(doc_kind);
+CREATE INDEX IF NOT EXISTS idx_documents_created_at ON documents(created_at);