@bitbonsai/mcpvault 0.8.2

package/dist/src/pathfilter.test.js

@@ -0,0 +1,264 @@
+import { test, expect, describe } from "vitest";
+import { PathFilter } from "./pathfilter.js";
+describe("PathFilter", () => {
+    // ============================================================================
+    // BASIC FUNCTIONALITY
+    // ============================================================================
+    test("allows markdown files by default", () => {
+        const filter = new PathFilter();
+        expect(filter.isAllowed("notes/test.md")).toBe(true);
+        expect(filter.isAllowed("test.markdown")).toBe(true);
+        expect(filter.isAllowed("folder/subfolder/note.txt")).toBe(true);
+    });
+    test("blocks .obsidian directory", () => {
+        const filter = new PathFilter();
+        expect(filter.isAllowed(".obsidian")).toBe(false);
+        expect(filter.isAllowed(".obsidian/app.json")).toBe(false);
+        expect(filter.isAllowed(".obsidian/plugins/plugin/main.js")).toBe(false);
+    });
+    test("blocks .git directory", () => {
+        const filter = new PathFilter();
+        expect(filter.isAllowed(".git")).toBe(false);
+        expect(filter.isAllowed(".git/config")).toBe(false);
+        expect(filter.isAllowed(".git/objects/abc123")).toBe(false);
+    });
+    test("blocks node_modules", () => {
+        const filter = new PathFilter();
+        expect(filter.isAllowed("node_modules")).toBe(false);
+        expect(filter.isAllowed("node_modules/package/index.js")).toBe(false);
+    });
+    test("blocks system files", () => {
+        const filter = new PathFilter();
+        expect(filter.isAllowed(".DS_Store")).toBe(false);
+        expect(filter.isAllowed("Thumbs.db")).toBe(false);
+    });
+    test("blocks non-allowed extensions", () => {
+        const filter = new PathFilter();
+        expect(filter.isAllowed("script.js")).toBe(false);
+        expect(filter.isAllowed("data.json")).toBe(false);
+        expect(filter.isAllowed("image.png")).toBe(false);
+    });
+    test("allows non-note files for directory listing", () => {
+        const filter = new PathFilter();
+        expect(filter.isAllowedForListing("image.png")).toBe(true);
+        expect(filter.isAllowedForListing("docs/report.pdf")).toBe(true);
+        expect(filter.isAllowedForListing("archive/data.json")).toBe(true);
+    });
+    test("blocks restricted paths in directory listing", () => {
+        const filter = new PathFilter();
+        expect(filter.isAllowedForListing(".obsidian/app.json")).toBe(false);
+        expect(filter.isAllowedForListing(".git/config")).toBe(false);
+        expect(filter.isAllowedForListing("node_modules/pkg/index.js")).toBe(false);
+        expect(filter.isAllowedForListing(".DS_Store")).toBe(false);
+    });
+    // ============================================================================
+    // REGEX SPECIAL CHARACTERS - SECURITY TESTS
+    // ============================================================================
+    describe("regex special characters in paths", () => {
+        test("handles dots in filenames literally", () => {
+            const filter = new PathFilter();
+            // Dots should be literal, not regex wildcards
+            expect(filter.isAllowed("file.name.md")).toBe(true);
+            expect(filter.isAllowed("v1.0.0-notes.md")).toBe(true);
+        });
+        test("handles parentheses in paths", () => {
+            const filter = new PathFilter();
+            expect(filter.isAllowed("notes/(archived)/old.md")).toBe(true);
+            expect(filter.isAllowed("project (copy).md")).toBe(true);
+        });
+        test("handles square brackets in paths", () => {
+            const filter = new PathFilter();
+            expect(filter.isAllowed("notes/[2024]/january.md")).toBe(true);
+            expect(filter.isAllowed("[inbox]/task.md")).toBe(true);
+        });
+        test("handles curly braces in paths", () => {
+            const filter = new PathFilter();
+            expect(filter.isAllowed("templates/{daily}.md")).toBe(true);
+        });
+        test("handles plus signs in paths", () => {
+            const filter = new PathFilter();
+            expect(filter.isAllowed("C++/notes.md")).toBe(true);
+            expect(filter.isAllowed("topic+subtopic.md")).toBe(true);
+        });
+        test("handles question marks in paths", () => {
+            const filter = new PathFilter();
+            // Question mark is a glob wildcard, but in actual filenames should work
+            expect(filter.isAllowed("FAQ?.md")).toBe(true);
+        });
+        test("handles asterisks in filenames", () => {
+            const filter = new PathFilter();
+            // Asterisk in filename (rare but valid on Unix)
+            expect(filter.isAllowed("important*.md")).toBe(true);
+            expect(filter.isAllowed("file*name.md")).toBe(true);
+            expect(filter.isAllowed("notes/todo*.md")).toBe(true);
+        });
+        test("asterisk in custom ignored pattern works as glob", () => {
+            const filter = new PathFilter({
+                ignoredPatterns: ["temp*/**"]
+            });
+            // Pattern uses * as wildcard - should match temp, temp1, temporary, etc.
+            expect(filter.isAllowed("temp/file.md")).toBe(false);
+            expect(filter.isAllowed("temp1/file.md")).toBe(false);
+            expect(filter.isAllowed("temporary/file.md")).toBe(false);
+            // Should NOT match "atemp" (pattern starts with temp)
+            expect(filter.isAllowed("atemp/file.md")).toBe(true);
+        });
+        test("double asterisk ** matches nested paths", () => {
+            const filter = new PathFilter({
+                ignoredPatterns: ["archive/**"]
+            });
+            expect(filter.isAllowed("archive/old.md")).toBe(false);
+            expect(filter.isAllowed("archive/2024/jan/note.md")).toBe(false);
+            expect(filter.isAllowed("other/archive/note.md")).toBe(true);
+        });
+        test("handles pipe character in paths", () => {
+            const filter = new PathFilter();
+            expect(filter.isAllowed("option|choice.md")).toBe(true);
+        });
+        test("handles caret in paths", () => {
+            const filter = new PathFilter();
+            expect(filter.isAllowed("version^2.md")).toBe(true);
+        });
+        test("handles dollar sign in paths", () => {
+            const filter = new PathFilter();
+            expect(filter.isAllowed("price$100.md")).toBe(true);
+            expect(filter.isAllowed("$HOME/notes.md")).toBe(true);
+        });
+        test("handles backslash (Windows paths)", () => {
+            const filter = new PathFilter();
+            // Backslashes should be normalized to forward slashes
+            expect(filter.isAllowed("folder\\subfolder\\note.md")).toBe(true);
+        });
+    });
+    // ============================================================================
+    // CUSTOM IGNORED PATTERNS WITH SPECIAL CHARS
+    // ============================================================================
+    describe("custom patterns with special characters", () => {
+        test("custom pattern with dots is treated literally", () => {
+            const filter = new PathFilter({
+                ignoredPatterns: ["backup.2024/**"]
+            });
+            expect(filter.isAllowed("backup.2024/notes.md")).toBe(false);
+            // "backup_2024" should NOT match "backup.2024" pattern
+            expect(filter.isAllowed("backup_2024/notes.md")).toBe(true);
+        });
+        test("custom pattern with parentheses works", () => {
+            const filter = new PathFilter({
+                ignoredPatterns: ["(archive)/**"]
+            });
+            expect(filter.isAllowed("(archive)/old.md")).toBe(false);
+            expect(filter.isAllowed("archive/old.md")).toBe(true);
+        });
+        test("custom pattern with brackets works", () => {
+            const filter = new PathFilter({
+                ignoredPatterns: ["[trash]/**"]
+            });
+            expect(filter.isAllowed("[trash]/deleted.md")).toBe(false);
+            expect(filter.isAllowed("trash/deleted.md")).toBe(true);
+        });
+    });
+    // ============================================================================
+    // PATH TRAVERSAL ATTEMPTS
+    // ============================================================================
+    describe("path traversal prevention", () => {
+        test("blocks obvious traversal patterns", () => {
+            const filter = new PathFilter({
+                ignoredPatterns: ["../**"]
+            });
+            expect(filter.isAllowed("../secret.md")).toBe(false);
+            expect(filter.isAllowed("../../etc/passwd")).toBe(false);
+        });
+        test("handles encoded traversal attempts", () => {
+            const filter = new PathFilter();
+            // These should be allowed by PathFilter (path validation is in FileSystem)
+            // but filter shouldn't crash on unusual characters
+            expect(() => filter.isAllowed("%2e%2e/secret.md")).not.toThrow();
+            expect(() => filter.isAllowed("..%2fnotes.md")).not.toThrow();
+        });
+    });
+    test("allows Obsidian first-party file types", () => {
+        const filter = new PathFilter();
+        expect(filter.isAllowed("_Bases/daily-notes.base")).toBe(true);
+        expect(filter.isAllowed("canvas/mindmap.canvas")).toBe(true);
+    });
+    // ============================================================================
+    // FILTER PATHS BATCH OPERATION
+    // ============================================================================
+    describe("filterPaths", () => {
+        test("filters array of paths correctly", () => {
+            const filter = new PathFilter();
+            const paths = [
+                "notes/valid.md",
+                ".obsidian/config.json",
+                "archive/old.md",
+                ".git/HEAD",
+                "readme.txt"
+            ];
+            const allowed = filter.filterPaths(paths);
+            expect(allowed).toEqual([
+                "notes/valid.md",
+                "archive/old.md",
+                "readme.txt"
+            ]);
+        });
+        test("handles empty array", () => {
+            const filter = new PathFilter();
+            expect(filter.filterPaths([])).toEqual([]);
+        });
+        test("handles array with all blocked paths", () => {
+            const filter = new PathFilter();
+            const paths = [
+                ".obsidian/app.json",
+                ".git/config",
+                "node_modules/pkg/index.js"
+            ];
+            expect(filter.filterPaths(paths)).toEqual([]);
+        });
+    });
+    // ============================================================================
+    // EDGE CASES
+    // ============================================================================
+    describe("edge cases", () => {
+        test("handles empty path", () => {
+            const filter = new PathFilter();
+            expect(() => filter.isAllowed("")).not.toThrow();
+        });
+        test("handles path with only extension", () => {
+            const filter = new PathFilter();
+            expect(filter.isAllowed(".md")).toBe(true);
+        });
+        test("handles very long paths", () => {
+            const filter = new PathFilter();
+            const longPath = "a/".repeat(100) + "note.md";
+            expect(() => filter.isAllowed(longPath)).not.toThrow();
+            expect(filter.isAllowed(longPath)).toBe(true);
+        });
+        test("handles unicode characters in paths", () => {
+            const filter = new PathFilter();
+            expect(filter.isAllowed("notes/日本語.md")).toBe(true);
+            expect(filter.isAllowed("émojis/🎉.md")).toBe(true);
+            expect(filter.isAllowed("中文/笔记.md")).toBe(true);
+        });
+        test("handles spaces in paths", () => {
+            const filter = new PathFilter();
+            expect(filter.isAllowed("my notes/important file.md")).toBe(true);
+        });
+        test("handles directories (no extension)", () => {
+            const filter = new PathFilter();
+            // Directories should be allowed (no extension check)
+            expect(filter.isAllowed("folder/subfolder/")).toBe(true);
+            expect(filter.isAllowed("notes")).toBe(true);
+        });
+        test("handles directories with dots in their names", () => {
+            const filter = new PathFilter();
+            // Folders with dots should be allowed (common pattern: "1. Project", "2.5 Notes")
+            expect(filter.isAllowed("1. Project")).toBe(true);
+            expect(filter.isAllowed("2. Archive")).toBe(true);
+            expect(filter.isAllowed("3.5 Research")).toBe(true);
+            expect(filter.isAllowed("1. Project/subfolder")).toBe(true);
+            expect(filter.isAllowed("1. Project/note.md")).toBe(true);
+            // But files in those folders should still need proper extensions
+            expect(filter.isAllowed("1. Project/file.js")).toBe(false);
+        });
+    });
+});

package/dist/src/search.js

@@ -0,0 +1,182 @@
+import { join, resolve } from 'path';
+import { readFile, readdir } from 'node:fs/promises';
+import { generateObsidianUri } from './uri.js';
+export class SearchService {
+    pathFilter;
+    vaultPath;
+    constructor(vaultPath, pathFilter) {
+        this.pathFilter = pathFilter;
+        this.vaultPath = resolve(vaultPath);
+    }
+    async search(params) {
+        const { query, limit = 5, searchContent = true, searchFrontmatter = false, caseSensitive = false } = params;
+        if (!query || query.trim().length === 0) {
+            throw new Error('Search query cannot be empty');
+        }
+        const maxLimit = Math.min(limit, 20);
+        // Corpus stats for reranking
+        let totalDocLength = 0;
+        let docCount = 0;
+        const termDocFreq = new Map();
+        const candidates = [];
+        const searchQuery = caseSensitive ? query : query.toLowerCase();
+        const terms = searchQuery.split(/\s+/).filter(t => t.length > 0);
+        const scoringTerms = terms.length > 1 ? [...terms, searchQuery] : terms;
+        // Recursively find all .md files
+        const markdownFiles = await this.findMarkdownFiles(this.vaultPath);
+        // Pre-filter by pathFilter before I/O
+        const prefixLen = this.vaultPath.length + 1;
+        const allowedFiles = [];
+        for (const fullPath of markdownFiles) {
+            const relativePath = fullPath.substring(prefixLen).replace(/\\/g, '/');
+            if (this.pathFilter.isAllowed(relativePath)) {
+                allowedFiles.push({ fullPath, relativePath });
+            }
+        }
+        // Read files in parallel batches
+        const BATCH_SIZE = 5;
+        for (let start = 0; start < allowedFiles.length; start += BATCH_SIZE) {
+            const batch = allowedFiles.slice(start, start + BATCH_SIZE);
+            const contents = await Promise.all(batch.map(f => readFile(f.fullPath, 'utf-8').catch(() => null)));
+            for (let i = 0; i < batch.length; i++) {
+                const content = contents[i];
+                if (content === null || content === undefined)
+                    continue;
+                const { relativePath } = batch[i];
+                let searchableText = '';
+                // Prepare search text based on options
+                if (searchContent && searchFrontmatter) {
+                    searchableText = content;
+                }
+                else if (searchContent) {
+                    // Remove frontmatter from search
+                    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n/);
+                    searchableText = frontmatterMatch ? content.slice(frontmatterMatch[0].length) : content;
+                }
+                else if (searchFrontmatter) {
+                    // Search only frontmatter
+                    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n/);
+                    searchableText = frontmatterMatch ? frontmatterMatch[1] || '' : '';
+                }
+                const searchIn = caseSensitive ? searchableText : searchableText.toLowerCase();
+                // Collect corpus stats for reranking
+                const docLength = searchIn.split(/\s+/).filter(w => w.length > 0).length;
+                totalDocLength += docLength;
+                docCount++;
+                for (const term of scoringTerms) {
+                    if (searchIn.includes(term)) {
+                        termDocFreq.set(term, (termDocFreq.get(term) || 0) + 1);
+                    }
+                }
+                // Extract title from filename
+                const title = relativePath.split('/').pop()?.replace(/\.md$/, '') || relativePath;
+                // Check filename match (any term)
+                const filenameToSearch = caseSensitive ? title : title.toLowerCase();
+                const filenameMatch = terms.some(term => filenameToSearch.includes(term));
+                // Check content match (any term)
+                const termIndices = terms.map(term => searchIn.indexOf(term));
+                const anyTermFound = termIndices.some(idx => idx !== -1);
+                const firstIndex = anyTermFound
+                    ? Math.min(...termIndices.filter(idx => idx !== -1))
+                    : -1;
+                if (firstIndex !== -1 || filenameMatch) {
+                    let excerpt;
+                    let matchCount = 0;
+                    let lineNumber = 0;
+                    const termFreqs = new Map();
+                    if (firstIndex !== -1) {
+                        // Find the term that matched first for excerpt
+                        const firstTermIdx = termIndices.indexOf(firstIndex);
+                        const firstTerm = terms[firstTermIdx];
+                        // Extract excerpt around first content match
+                        const excerptStart = Math.max(0, firstIndex - 21);
+                        const excerptEnd = Math.min(searchableText.length, firstIndex + firstTerm.length + 21);
+                        excerpt = searchableText.slice(excerptStart, excerptEnd).trim();
+                        // Add ellipsis if excerpt is truncated
+                        if (excerptStart > 0)
+                            excerpt = '...' + excerpt;
+                        if (excerptEnd < searchableText.length)
+                            excerpt = excerpt + '...';
+                        // Count total content matches across all terms
+                        for (const term of scoringTerms) {
+                            let count = 0;
+                            let searchIndex = 0;
+                            while ((searchIndex = searchIn.indexOf(term, searchIndex)) !== -1) {
+                                count++;
+                                searchIndex += term.length;
+                            }
+                            termFreqs.set(term, count);
+                            matchCount += count;
+                        }
+                        // Find line number of first match
+                        const lines = searchableText.slice(0, firstIndex).split('\n');
+                        lineNumber = lines.length;
+                    }
+                    else {
+                        // Filename-only match: use beginning of content as excerpt
+                        excerpt = searchableText.slice(0, 50).trim();
+                        if (searchableText.length > 50)
+                            excerpt = excerpt + '...';
+                        matchCount = 0;
+                        lineNumber = 0;
+                    }
+                    // Add filename match to count
+                    if (filenameMatch)
+                        matchCount++;
+                    candidates.push({
+                        result: {
+                            p: relativePath,
+                            t: title,
+                            ex: excerpt,
+                            mc: matchCount,
+                            ln: lineNumber,
+                            uri: generateObsidianUri(this.vaultPath, relativePath)
+                        },
+                        termFreqs,
+                        docLength
+                    });
+                }
+            }
+        }
+        const results = this.rerank(candidates, scoringTerms, termDocFreq, docCount, totalDocLength, maxLimit);
+        return results;
+    }
+    async findMarkdownFiles(dirPath) {
+        const markdownFiles = [];
+        try {
+            const entries = await readdir(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = join(dirPath, entry.name);
+                if (entry.isDirectory()) {
+                    // Recursively search subdirectories
+                    const subFiles = await this.findMarkdownFiles(fullPath);
+                    markdownFiles.push(...subFiles);
+                }
+                else if (entry.isFile() && entry.name.endsWith('.md')) {
+                    markdownFiles.push(fullPath);
+                }
+            }
+        }
+        catch (error) {
+            // Skip directories that can't be read
+        }
+        return markdownFiles;
+    }
+    rerank(candidates, terms, termDocFreq, docCount, totalDocLength, maxLimit) {
+        const avgdl = docCount > 0 ? totalDocLength / docCount : 1;
+        const k1 = 1.2;
+        const b = 0.75;
+        const scored = candidates.map(c => {
+            let score = 0;
+            for (const term of terms) {
+                const tf = c.termFreqs.get(term) || 0;
+                const df = termDocFreq.get(term) || 0;
+                const idf = Math.log(1 + (docCount - df + 0.5) / (df + 0.5));
+                score += idf * (tf * (k1 + 1)) / (tf + k1 * (1 - b + b * c.docLength / avgdl));
+            }
+            return { score, result: c.result };
+        });
+        scored.sort((a, b) => b.score - a.score);
+        return scored.slice(0, maxLimit).map(s => s.result);
+    }
+}

package/dist/src/search.test.js

@@ -0,0 +1,212 @@
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import { SearchService } from "./search.js";
+import { PathFilter } from "./pathfilter.js";
+import { writeFile, mkdir, mkdtemp, rm } from "fs/promises";
+import { join } from "path";
+import { tmpdir } from "os";
+let testVaultPath;
+let searchService;
+beforeEach(async () => {
+    testVaultPath = await mkdtemp(join(tmpdir(), "mcpvault-search-"));
+    searchService = new SearchService(testVaultPath, new PathFilter());
+});
+afterEach(async () => {
+    try {
+        await rm(testVaultPath, { recursive: true });
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+});
+// Helper to write a note directly to disk
+async function writeNote(path, content) {
+    const fullPath = join(testVaultPath, path);
+    const dir = fullPath.substring(0, fullPath.lastIndexOf("/"));
+    if (dir !== testVaultPath) {
+        await mkdir(dir, { recursive: true });
+    }
+    await writeFile(fullPath, content);
+}
+describe("SearchService", () => {
+    // ============================================================================
+    // BASIC SEARCH
+    // ============================================================================
+    test("finds notes matching a query", async () => {
+        await writeNote("alpha.md", "# Alpha\n\nThis note has bananas.");
+        await writeNote("beta.md", "# Beta\n\nThis note has oranges.");
+        const results = await searchService.search({ query: "bananas" });
+        expect(results).toHaveLength(1);
+        expect(results[0].p).toBe("alpha.md");
+    });
+    test("returns empty array when no matches", async () => {
+        await writeNote("note.md", "# Note\n\nNothing relevant here.");
+        const results = await searchService.search({ query: "zzzznotfound" });
+        expect(results).toHaveLength(0);
+    });
+    test("returns empty array for empty vault", async () => {
+        const results = await searchService.search({ query: "anything" });
+        expect(results).toHaveLength(0);
+    });
+    test("throws on empty query", async () => {
+        await expect(searchService.search({ query: "" }))
+            .rejects.toThrow(/empty/);
+    });
+    test("throws on whitespace-only query", async () => {
+        await expect(searchService.search({ query: "   " }))
+            .rejects.toThrow(/empty/);
+    });
+    // ============================================================================
+    // LIMIT
+    // ============================================================================
+    test("respects limit parameter", async () => {
+        for (let i = 0; i < 5; i++) {
+            await writeNote(`note-${i}.md`, `# Note ${i}\n\nkeyword here.`);
+        }
+        const results = await searchService.search({ query: "keyword", limit: 2 });
+        expect(results).toHaveLength(2);
+    });
+    test("caps limit at 20", async () => {
+        for (let i = 0; i < 25; i++) {
+            await writeNote(`note-${i}.md`, `# Note ${i}\n\nkeyword here.`);
+        }
+        const results = await searchService.search({ query: "keyword", limit: 100 });
+        expect(results.length).toBeLessThanOrEqual(20);
+    });
+    test("defaults limit to 5", async () => {
+        for (let i = 0; i < 10; i++) {
+            await writeNote(`note-${i}.md`, `# Note ${i}\n\nkeyword here.`);
+        }
+        const results = await searchService.search({ query: "keyword" });
+        expect(results).toHaveLength(5);
+    });
+    // ============================================================================
+    // CASE SENSITIVITY
+    // ============================================================================
+    test("case-insensitive search by default", async () => {
+        await writeNote("upper.md", "# Upper\n\nBANANA is great.");
+        await writeNote("lower.md", "# Lower\n\nbanana is great.");
+        await writeNote("mixed.md", "# Mixed\n\nBanana is great.");
+        const results = await searchService.search({ query: "banana", limit: 10 });
+        expect(results).toHaveLength(3);
+    });
+    test("case-sensitive search when enabled", async () => {
+        await writeNote("upper.md", "# Upper\n\nBANANA is great.");
+        await writeNote("lower.md", "# Lower\n\nbanana is great.");
+        const results = await searchService.search({
+            query: "BANANA",
+            caseSensitive: true,
+            limit: 10
+        });
+        expect(results).toHaveLength(1);
+        expect(results[0].p).toBe("upper.md");
+    });
+    // ============================================================================
+    // FRONTMATTER SEARCH
+    // ============================================================================
+    test("excludes frontmatter from content-only search", async () => {
+        await writeNote("note.md", "---\ntags: [uniquetag]\n---\n\n# Note\n\nNo tag here.");
+        const results = await searchService.search({
+            query: "uniquetag",
+            searchContent: true,
+            searchFrontmatter: false,
+            limit: 10
+        });
+        expect(results).toHaveLength(0);
+    });
+    test("searches frontmatter when enabled", async () => {
+        await writeNote("note.md", "---\ntags: [uniquetag]\n---\n\n# Note\n\nNo tag here.");
+        const results = await searchService.search({
+            query: "uniquetag",
+            searchFrontmatter: true,
+            limit: 10
+        });
+        expect(results).toHaveLength(1);
+        expect(results[0].p).toBe("note.md");
+    });
+    test("searches both content and frontmatter together", async () => {
+        await writeNote("fm-only.md", "---\nstatus: special\n---\n\n# Note\n\nPlain body.");
+        await writeNote("content-only.md", "# Note\n\nThis is special content.");
+        const results = await searchService.search({
+            query: "special",
+            searchContent: true,
+            searchFrontmatter: true,
+            limit: 10
+        });
+        expect(results).toHaveLength(2);
+    });
+    // ============================================================================
+    // FILENAME MATCHING
+    // ============================================================================
+    test("matches by filename when content has no match", async () => {
+        await writeNote("Recipes.md", "Some unrelated content about cooking.");
+        const results = await searchService.search({ query: "recipes", limit: 10 });
+        expect(results).toHaveLength(1);
+        expect(results[0].p).toBe("Recipes.md");
+        expect(results[0].t).toBe("Recipes");
+    });
+    // ============================================================================
+    // MULTI-TERM SEARCH
+    // ============================================================================
+    test("multi-term search matches notes with any term", async () => {
+        await writeNote("cats.md", "# Cats\n\nI love cats.");
+        await writeNote("dogs.md", "# Dogs\n\nI love dogs.");
+        await writeNote("fish.md", "# Fish\n\nI love fish.");
+        const results = await searchService.search({ query: "cats dogs", limit: 10 });
+        const paths = results.map(r => r.p);
+        expect(paths).toContain("cats.md");
+        expect(paths).toContain("dogs.md");
+        expect(paths).not.toContain("fish.md");
+    });
+    // ============================================================================
+    // RANKING
+    // ============================================================================
+    test("ranks notes with more matches higher", async () => {
+        await writeNote("few.md", "# Few\n\napple once.");
+        await writeNote("many.md", "# Many\n\napple apple apple apple apple.");
+        const results = await searchService.search({ query: "apple", limit: 10 });
+        expect(results).toHaveLength(2);
+        expect(results[0].p).toBe("many.md");
+    });
+    // ============================================================================
+    // RESULT SHAPE
+    // ============================================================================
+    test("results include expected fields", async () => {
+        await writeNote("folder/note.md", "# My Note\n\nSome content with target word.");
+        const results = await searchService.search({ query: "target", limit: 10 });
+        expect(results).toHaveLength(1);
+        const r = results[0];
+        expect(r.p).toBe("folder/note.md");
+        expect(r.t).toBe("note");
+        expect(r.ex).toBeDefined();
+        expect(r.mc).toBeGreaterThanOrEqual(1);
+        expect(r.ln).toBeGreaterThanOrEqual(1);
+        expect(r.uri).toMatch(/^obsidian:\/\//);
+    });
+    test("excerpt contains context around match", async () => {
+        await writeNote("note.md", "# Note\n\nSome words before target some words after.");
+        const results = await searchService.search({ query: "target", limit: 10 });
+        expect(results[0].ex).toContain("target");
+    });
+    // ============================================================================
+    // PATH FILTERING
+    // ============================================================================
+    test("excludes notes in filtered directories", async () => {
+        await writeNote("visible.md", "# Visible\n\nkeyword here.");
+        await mkdir(join(testVaultPath, ".obsidian"), { recursive: true });
+        await writeFile(join(testVaultPath, ".obsidian/config.md"), "keyword here.");
+        const results = await searchService.search({ query: "keyword", limit: 10 });
+        expect(results).toHaveLength(1);
+        expect(results[0].p).toBe("visible.md");
+    });
+    // ============================================================================
+    // TRAILING SLASH IN VAULT PATH
+    // ============================================================================
+    test("vault path with trailing slash does not truncate result paths", async () => {
+        const trailingSlashService = new SearchService(testVaultPath + "/", new PathFilter());
+        await mkdir(join(testVaultPath, "sessions"), { recursive: true });
+        await writeNote("sessions/foo-bar.md", "# Foo Bar\n\nSome content here.");
+        const results = await trailingSlashService.search({ query: "foo", limit: 5 });
+        expect(results).toHaveLength(1);
+        expect(results[0].p).toBe("sessions/foo-bar.md");
+    });
+});

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};