@mauricio.wolff/mcp-obsidian 0.7.5 → 0.8.2

package/dist/src/frontmatter.test.js

@@ -1,5 +1,5 @@
-import { test, expect } from "vitest";
-import { FrontmatterHandler } from "./frontmatter.js";
+import { test, expect, describe } from "vitest";
+import { FrontmatterHandler, parseFrontmatter } from "./frontmatter.js";
 const handler = new FrontmatterHandler();
 test("parse note with frontmatter", () => {
     const content = `---
@@ -84,3 +84,35 @@ Some content here.`;
     expect(result).toContain("tags:");
     expect(result).toContain("# Content");
 });
+describe("parseFrontmatter", () => {
+    test("returns undefined for null and undefined", () => {
+        expect(parseFrontmatter(null)).toBeUndefined();
+        expect(parseFrontmatter(undefined)).toBeUndefined();
+    });
+    test("passes through a plain object", () => {
+        const obj = { tags: ["test"], title: "Hello" };
+        expect(parseFrontmatter(obj)).toBe(obj);
+    });
+    test("parses a JSON string into an object", () => {
+        const input = '{"tags": ["test"], "title": "Hello"}';
+        expect(parseFrontmatter(input)).toEqual({ tags: ["test"], title: "Hello" });
+    });
+    test("parses an empty JSON object string", () => {
+        expect(parseFrontmatter("{}")).toEqual({});
+    });
+    test("throws for a non-JSON string", () => {
+        expect(() => parseFrontmatter("not json")).toThrow("frontmatter must be a JSON object");
+    });
+    test("throws for a JSON array string", () => {
+        expect(() => parseFrontmatter('[1, 2, 3]')).toThrow("frontmatter must be a JSON object");
+    });
+    test("throws for a JSON primitive string", () => {
+        expect(() => parseFrontmatter('"just a string"')).toThrow("frontmatter must be a JSON object");
+    });
+    test("throws for an array value", () => {
+        expect(() => parseFrontmatter([1, 2, 3])).toThrow("frontmatter must be a JSON object");
+    });
+    test("throws for a number value", () => {
+        expect(() => parseFrontmatter(42)).toThrow("frontmatter must be a JSON object");
+    });
+});

package/dist/src/integration.test.js

@@ -97,43 +97,6 @@ Pattern: backup.2024/**/*.md`;
         expect(note.content).toContain("2 + 2 = 4");
         expect(note.content).toContain("backup.2024/**/*.md");
     });
-    test("unicode and emoji in paths and content", async () => {
-        // Create folders with unicode
-        await mkdir(join(testVaultPath, "日本語"), { recursive: true });
-        await mkdir(join(testVaultPath, "📁"), { recursive: true });
-        const testCases = [
-            { path: "日本語/ノート.md", content: "# 日本語のメモ\n\nこんにちは世界" },
-            { path: "📁/🎉.md", content: "# Celebration\n\n🎊 Party time! 🎈" }
-        ];
-        // Write notes
-        for (const { path, content } of testCases) {
-            await fileSystem.writeNote({ path, content });
-        }
-        // Read back and verify
-        for (const { path, content } of testCases) {
-            const note = await fileSystem.readNote(path);
-            expect(note.content).toBe(content);
-        }
-    });
-    test("security: path traversal blocked", async () => {
-        const maliciousPaths = [
-            "../etc/passwd",
-            "../../secret.txt",
-            "folder/../../../outside.md"
-        ];
-        for (const path of maliciousPaths) {
-            await expect(fileSystem.readNote(path))
-                .rejects.toThrow(/Path traversal not allowed|Access denied/);
-        }
-    });
-    test("security: blocked directories not accessible", async () => {
-        // Try to access .obsidian
-        await expect(fileSystem.readNote(".obsidian/app.json"))
-            .rejects.toThrow(/Access denied/);
-        // Try to access .git
-        await expect(fileSystem.readNote(".git/config"))
-            .rejects.toThrow(/Access denied/);
-    });
     test("search matches note filename even without content match", async () => {
         // Issue #30: notes without a heading that rely on filename for discovery
         await fileSystem.writeNote({
@@ -203,59 +166,3 @@ Pattern: backup.2024/**/*.md`;
         }
     });
 });
-// ============================================================================
-// PERFORMANCE TESTS
-// ============================================================================
-describe("Performance: Post-PR#12 Overhead", () => {
-    test("pathfilter performance with many checks", () => {
-        const filter = new PathFilter();
-        const testPaths = [
-            "notes/daily/2024-01-01.md",
-            "projects/work/report (final).md",
-            "archive [2023]/old-note.md",
-            "C++/algorithms/sort.md",
-            "backup.2024/data.md",
-            ".obsidian/app.json",
-            ".git/config",
-            "node_modules/package/index.js"
-        ];
-        const start = performance.now();
-        // Run 1000 iterations
-        for (let i = 0; i < 1000; i++) {
-            for (const path of testPaths) {
-                filter.isAllowed(path);
-            }
-        }
-        const duration = performance.now() - start;
-        // Should complete in reasonable time (< 200ms for 8000 checks)
-        // Increased threshold to account for CI runner variability
-        expect(duration).toBeLessThan(200);
-    });
-    test("large batch operations performance", async () => {
-        // Create 50 notes
-        const paths = [];
-        for (let i = 1; i <= 50; i++) {
-            const path = `batch/note-${i}.md`;
-            paths.push(path);
-        }
-        await mkdir(join(testVaultPath, "batch"), { recursive: true });
-        for (const path of paths) {
-            await writeFile(join(testVaultPath, path), `# Note\n\nContent for ${path}`);
-        }
-        const start = performance.now();
-        // Read all 50 notes (max batch size is 10, so this tests multiple batches)
-        const batches = [];
-        for (let i = 0; i < paths.length; i += 10) {
-            const batchPaths = paths.slice(i, i + 10);
-            batches.push(fileSystem.readMultipleNotes({
-                paths: batchPaths,
-                includeContent: true,
-                includeFrontmatter: true
-            }));
-        }
-        await Promise.all(batches);
-        const duration = performance.now() - start;
-        // Should complete in reasonable time (< 500ms for 50 files)
-        expect(duration).toBeLessThan(500);
-    });
-});

package/dist/src/pathfilter.js

@@ -17,6 +17,8 @@ export class PathFilter {
             '.md',
             '.markdown',
             '.txt',
+            '.base', // Obsidian Bases (YAML)
+            '.canvas', // Obsidian Canvas (JSON)
             ...config?.allowedExtensions || []
         ];
     }
@@ -37,11 +39,8 @@ export class PathFilter {
     isAllowed(path) {
         // Normalize path separators
         const normalizedPath = path.replace(/\\/g, '/');
-        // Check if path matches any ignored pattern
-        for (const pattern of this.ignoredPatterns) {
-            if (this.simpleGlobMatch(pattern, normalizedPath)) {
-                return false;
-            }
+        if (this.isIgnoredPath(normalizedPath)) {
+            return false;
         }
         // For files, check extension if allowedExtensions is configured
         if (this.allowedExtensions.length > 0 && this.isFile(normalizedPath)) {
@@ -52,6 +51,21 @@ export class PathFilter {
         }
         return true;
     }
+    isAllowedForListing(path) {
+        // Normalize path separators
+        const normalizedPath = path.replace(/\\/g, '/');
+        // Listing includes non-note files, but still blocks restricted system paths
+        return !this.isIgnoredPath(normalizedPath);
+    }
+    isIgnoredPath(normalizedPath) {
+        // Check if path matches any ignored pattern
+        for (const pattern of this.ignoredPatterns) {
+            if (this.simpleGlobMatch(pattern, normalizedPath)) {
+                return true;
+            }
+        }
+        return false;
+    }
     isFile(path) {
         // A path is a file if it has a file extension at the end
         // Paths ending with '/' are always directories

package/dist/src/pathfilter.test.js

@@ -38,6 +38,19 @@ describe("PathFilter", () => {
         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
     // ============================================================================
@@ -163,6 +176,11 @@ describe("PathFilter", () => {
             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
     // ============================================================================

package/dist/src/search.js

@@ -1,31 +1,48 @@
-import { join } from 'path';
+import { join, resolve } from 'path';
 import { readFile, readdir } from 'node:fs/promises';
 import { generateObsidianUri } from './uri.js';
 export class SearchService {
-    vaultPath;
     pathFilter;
+    vaultPath;
     constructor(vaultPath, pathFilter) {
-        this.vaultPath = vaultPath;
         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 results = [];
         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) {
-            // Convert absolute path back to relative path
-            const relativePath = fullPath.substring(this.vaultPath.length + 1).replace(/\\/g, '/');
-            if (!this.pathFilter.isAllowed(relativePath))
-                continue;
-            if (results.length >= maxLimit)
-                break;
-            try {
-                const content = await readFile(fullPath, 'utf-8');
+            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) {
@@ -42,36 +59,57 @@ export class SearchService {
                     searchableText = frontmatterMatch ? frontmatterMatch[1] || '' : '';
                 }
                 const searchIn = caseSensitive ? searchableText : searchableText.toLowerCase();
-                const searchQuery = caseSensitive ? query : query.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
+                // Check filename match (any term)
                 const filenameToSearch = caseSensitive ? title : title.toLowerCase();
-                const filenameMatch = filenameToSearch.includes(searchQuery);
-                // Check content match
-                const index = searchIn.indexOf(searchQuery);
-                if (index !== -1 || filenameMatch) {
+                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;
-                    if (index !== -1) {
+                    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, index - 21);
-                        const excerptEnd = Math.min(searchableText.length, index + searchQuery.length + 21);
+                        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
-                        let searchIndex = 0;
-                        while ((searchIndex = searchIn.indexOf(searchQuery, searchIndex)) !== -1) {
-                            matchCount++;
-                            searchIndex += searchQuery.length;
+                        // 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, index).split('\n');
+                        const lines = searchableText.slice(0, firstIndex).split('\n');
                         lineNumber = lines.length;
                     }
                     else {
@@ -85,21 +123,22 @@ export class SearchService {
                     // Add filename match to count
                     if (filenameMatch)
                         matchCount++;
-                    results.push({
-                        p: relativePath,
-                        t: title,
-                        ex: excerpt,
-                        mc: matchCount,
-                        ln: lineNumber,
-                        uri: generateObsidianUri(this.vaultPath, relativePath)
+                    candidates.push({
+                        result: {
+                            p: relativePath,
+                            t: title,
+                            ex: excerpt,
+                            mc: matchCount,
+                            ln: lineNumber,
+                            uri: generateObsidianUri(this.vaultPath, relativePath)
+                        },
+                        termFreqs,
+                        docLength
                     });
                 }
             }
-            catch (error) {
-                // Skip files that can't be read
-                continue;
-            }
         }
+        const results = this.rerank(candidates, scoringTerms, termDocFreq, docCount, totalDocLength, maxLimit);
         return results;
     }
     async findMarkdownFiles(dirPath) {
@@ -123,4 +162,21 @@ export class SearchService {
         }
         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(), "mcp-obsidian-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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mauricio.wolff/mcp-obsidian",
-  "version": "0.7.5",
+  "version": "0.8.2",
   "description": "Universal AI bridge for Obsidian vaults - connect any MCP-compatible assistant",
   "author": "bitbonsai",
   "license": "MIT",
@@ -8,8 +8,7 @@
   "packageManager": "npm@10.9.0+sha512.65a9c38a8172948f617a53619762cd77e12b9950fe1f9239debcb8d62c652f2081824b986fee7c0af6c0a7df615becebe4bf56e17ec27214a87aa29d9e038b4b",
   "main": "dist/server.js",
   "bin": {
-    "mcp-obsidian": "./dist/server.js",
-    "@mauricio.wolff/mcp-obsidian": "./dist/server.js"
+    "mcp-obsidian": "dist/server.js"
   },
   "files": [
     "dist/**/*",
@@ -33,7 +32,7 @@
     "gray-matter": "^4.0.3"
   },
   "devDependencies": {
-    "@types/node": "^24.10.1",
+    "@types/node": "^25.3.3",
     "tsx": "^4.20.6",
     "typescript": "^5.9.3",
     "vitest": "^4.0.15"
@@ -43,7 +42,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/bitbonsai/mcp-obsidian.git"
+    "url": "git+https://github.com/bitbonsai/mcp-obsidian.git"
   },
   "keywords": [
     "mcp",