@mauricio.wolff/mcp-obsidian 0.8.1 → 0.8.2

package/README.md

@@ -143,7 +143,7 @@ MCP is an open protocol. You're not tied to any specific vendor or platform. You
 ## Prerequisites
 
 - [Node.js](https://nodejs.org) runtime (v18.0.0 or later)
-- An Obsidian vault (local directory with `.md` files)
+- An Obsidian vault (local directory with `.md`, `.markdown`, `.txt`, `.base`, or `.canvas` files)
 - MCP-compatible AI client (Claude Desktop, ChatGPT Desktop, Claude Code, etc.)
 
 ## Installation
@@ -156,6 +156,8 @@ No installation needed! Use `npx` to run directly:
 npx @mauricio.wolff/mcp-obsidian@latest /path/to/your/obsidian/vault
 ```
 
+If you omit the vault path, the server uses your current working directory as the vault root.
+
 ### For Developers
 
 1. Clone this repository
@@ -194,13 +196,17 @@ mcp-inspector npx @mauricio.wolff/mcp-obsidian@latest /path/to/your/vault
 **End users:**
 
 ```bash
+npx @mauricio.wolff/mcp-obsidian@latest
 npx @mauricio.wolff/mcp-obsidian@latest /path/to/your/obsidian/vault
+npx @mauricio.wolff/mcp-obsidian@latest ./Vault
 ```
 
 **Developers:**
 
 ```bash
+npm start
 npm start /path/to/your/obsidian/vault
+npm start ./Vault
 ```
 
 ### AI Client Configuration
@@ -366,10 +372,10 @@ Most modern MCP clients use similar JSON configuration patterns. Refer to your s
 - **Solution:** Install Node.js runtime from [nodejs.org](https://nodejs.org)
 - **Alternative:** Use global install: `npm install -g @mauricio.wolff/mcp-obsidian`
 
-#### "Usage: node server.ts /path/to/vault"
+#### "File not found" when paths look correct
 
-- **Cause:** No vault path provided
-- **Solution:** Specify the full path to your Obsidian vault directory
+- **Cause:** The server is using the wrong vault root
+- **Solution:** Either run the command from your vault directory or pass the vault path explicitly
 
 #### "Permission denied" errors
 
@@ -553,7 +559,7 @@ Efficiently replace an exact string inside an existing note without rewriting th
 
 List files and directories in the vault.
 
-Note: this includes non-note filenames (for example `pdf`, `png`, `jpg`) so AI assistants can see vault structure, but note tools like `read_note` and `write_note` still operate on note files only (`.md`, `.markdown`, `.txt`).
+Note: this includes non-note filenames (for example `pdf`, `png`, `jpg`) so AI assistants can see vault structure, but note tools like `read_note` and `write_note` still operate on note files only (`.md`, `.markdown`, `.txt`, `.base`, `.canvas`).
 
 **Request:**
 
@@ -740,7 +746,7 @@ Search for notes in the vault by content or frontmatter with multi-word matching
 
 ### `move_note`
 
-Move or rename a note in the vault (`.md`, `.markdown`, `.txt`).
+Move or rename a note in the vault (`.md`, `.markdown`, `.txt`, `.base`, `.canvas`).
 
 **Request:**
 
@@ -939,7 +945,7 @@ This MCP server implements several security measures to protect your Obsidian va
 ### File Filtering
 
 - **Automatic Exclusions:** `.obsidian`, `.git`, `node_modules`, and system files are filtered
-- **Extension Whitelist:** Only `.md`, `.markdown`, and `.txt` files are accessible by default
+- **Extension Whitelist:** Only `.md`, `.markdown`, `.txt`, `.base`, and `.canvas` files are accessible by default
 - **Hidden File Protection:** Dot files and system directories are automatically excluded
 
 ### Content Validation

package/dist/server.js

@@ -3,12 +3,12 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { FileSystemService } from "./src/filesystem.js";
-import { FrontmatterHandler } from "./src/frontmatter.js";
+import { FrontmatterHandler, parseFrontmatter } from "./src/frontmatter.js";
 import { PathFilter } from "./src/pathfilter.js";
 import { SearchService } from "./src/search.js";
 import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
-import { dirname, join } from "path";
+import { dirname, join, resolve } from "path";
 // Get package.json version
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -28,29 +28,29 @@ if (firstArg === "--help" || firstArg === "-h") {
 Universal AI bridge for Obsidian vaults - connect any MCP-compatible assistant
 
 Usage:
-  npx @mauricio.wolff/mcp-obsidian <vault-path>
+  npx @mauricio.wolff/mcp-obsidian [vault-path]
 
 Arguments:
-  <vault-path>    Path to your Obsidian vault directory
+  [vault-path]    Optional path to your Obsidian vault directory
+                  Defaults to current working directory when omitted
 
 Options:
   --version, -v   Show version number
   --help, -h      Show this help message
 
 Examples:
+  npx @mauricio.wolff/mcp-obsidian
   npx @mauricio.wolff/mcp-obsidian ~/Documents/MyVault
+  npx @mauricio.wolff/mcp-obsidian ./Vault
   npx @mauricio.wolff/mcp-obsidian /path/to/obsidian/vault
   npx @mauricio.wolff/mcp-obsidian "/path/with spaces/Obsidian Vault"
 `);
     process.exit(0);
 }
-// Join all trailing args to support vault paths with spaces
-const vaultPath = cliArgs.join(' ').trim();
-if (!vaultPath) {
-    console.error("Usage: npx @mauricio.wolff/mcp-obsidian /path/to/vault");
-    console.error("Run 'npx @mauricio.wolff/mcp-obsidian --help' for more information");
-    process.exit(1);
-}
+// Join trailing args to support vault paths with spaces.
+// When omitted, default to current working directory.
+const vaultPathArg = cliArgs.join(' ').trim();
+const vaultPath = resolve(vaultPathArg || process.cwd());
 // Initialize services
 const pathFilter = new PathFilter();
 const frontmatterHandler = new FrontmatterHandler();
@@ -459,10 +459,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case "write_note": {
+                const fm = parseFrontmatter(trimmedArgs.frontmatter);
                 await fileSystem.writeNote({
                     path: trimmedArgs.path,
                     content: trimmedArgs.content,
-                    frontmatter: trimmedArgs.frontmatter,
+                    ...(fm !== undefined && { frontmatter: fm }),
                     mode: trimmedArgs.mode || 'overwrite'
                 });
                 return {
@@ -593,9 +594,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case "update_frontmatter": {
+                const fm = parseFrontmatter(trimmedArgs.frontmatter);
+                if (!fm) {
+                    throw new Error('frontmatter is required');
+                }
                 await fileSystem.updateFrontmatter({
                     path: trimmedArgs.path,
-                    frontmatter: trimmedArgs.frontmatter,
+                    frontmatter: fm,
                     merge: trimmedArgs.merge
                 });
                 return {

package/dist/src/filesystem.js

@@ -719,19 +719,18 @@ export class FileSystemService {
             const entries = await readdir(dirPath, { withFileTypes: true });
             for (const entry of entries) {
                 const entryRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-                if (!this.pathFilter.isAllowed(entryRelativePath)) {
-                    continue;
-                }
                 const fullEntryPath = join(dirPath, entry.name);
                 if (entry.isDirectory()) {
-                    // Also check if directory contents would be filtered (e.g., .obsidian/**)
-                    if (!this.pathFilter.isAllowed(`${entryRelativePath}/test.md`)) {
+                    if (!this.pathFilter.isAllowedForListing(entryRelativePath)) {
                         continue;
                     }
                     totalFolders++;
                     await scanDirectory(fullEntryPath, entryRelativePath);
                 }
                 else if (entry.isFile()) {
+                    if (!this.pathFilter.isAllowed(entryRelativePath)) {
+                        continue;
+                    }
                     totalNotes++;
                     const stats = await stat(fullEntryPath);
                     totalSize += stats.size;

package/dist/src/filesystem.test.js

@@ -1,5 +1,6 @@
 import { test, expect, beforeEach, afterEach } from "vitest";
 import { FileSystemService } from "./filesystem.js";
+import { PathFilter } from "./pathfilter.js";
 import { writeFile, readFile, mkdir, mkdtemp, rm } from "fs/promises";
 import { join } from "path";
 import { tmpdir } from "os";
@@ -891,6 +892,34 @@ test("get vault stats excludes filtered paths", async () => {
     expect(stats.recentlyModified.map(f => f.path)).toContain("visible.md");
     expect(stats.recentlyModified.map(f => f.path)).not.toContain(".obsidian/config.json");
 });
+test("get vault stats excludes files matched by custom ** ignored patterns", async () => {
+    const customFilter = new PathFilter({
+        ignoredPatterns: ["ignored/**"]
+    });
+    const customFileSystem = new FileSystemService(testVaultPath, customFilter);
+    await mkdir(join(testVaultPath, "ignored"), { recursive: true });
+    await mkdir(join(testVaultPath, "ignored/nested"), { recursive: true });
+    await writeFile(join(testVaultPath, "ignored/something.md"), "# Disallowed 1");
+    await writeFile(join(testVaultPath, "ignored/nested/something.md"), "# Disallowed 2");
+    await writeFile(join(testVaultPath, "visible.md"), "# Visible");
+    const stats = await customFileSystem.getVaultStats(10);
+    const recentPaths = stats.recentlyModified.map(file => file.path);
+    expect(stats.totalNotes).toBe(1);
+    expect(recentPaths).toContain("visible.md");
+    expect(recentPaths).not.toContain("ignored/something.md");
+    expect(recentPaths).not.toContain("ignored/nested/something.md");
+});
+test("get vault stats includes notes inside directories that contain dots", async () => {
+    await mkdir(join(testVaultPath, "2026.03"), { recursive: true });
+    await writeFile(join(testVaultPath, "2026.03/nested.md"), "# Nested");
+    await writeFile(join(testVaultPath, "root.md"), "# Root");
+    const stats = await fileSystem.getVaultStats(10);
+    const recentPaths = stats.recentlyModified.map(file => file.path);
+    expect(stats.totalNotes).toBe(2);
+    expect(stats.totalFolders).toBe(1);
+    expect(recentPaths).toContain("2026.03/nested.md");
+    expect(recentPaths).toContain("root.md");
+});
 test("get vault stats calculates total size correctly", async () => {
     const content1 = "# Note 1 with some content";
     const content2 = "# Note 2 with more content here";

package/dist/src/frontmatter.js

@@ -1,4 +1,30 @@
 import matter from 'gray-matter';
+/**
+ * Parse a frontmatter value that may be a JSON string (LLM clients sometimes
+ * pass frontmatter as a serialized JSON string instead of an object).
+ * Returns undefined if the value is null/undefined, or throws if invalid.
+ */
+export function parseFrontmatter(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        try {
+            const parsed = JSON.parse(value);
+            if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+        catch {
+            // not valid JSON
+        }
+        throw new Error('frontmatter must be a JSON object, got a string that is not valid JSON');
+    }
+    throw new Error(`frontmatter must be a JSON object, got ${typeof value}`);
+}
 export class FrontmatterHandler {
     parse(content) {
         try {

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 || []
         ];
     }

package/dist/src/pathfilter.test.js

@@ -176,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,12 +1,12 @@
-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;

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.8.1",
+  "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",