@mauricio.wolff/mcp-obsidian 0.7.0 → 0.7.2

package/dist/src/filesystem.js

@@ -44,25 +44,19 @@ export class FileSystemService {
             throw new Error(`Cannot read directory as file: ${path}. Use list_directory tool instead.`);
         }
         try {
-            try {
-                await access(fullPath, constants.F_OK);
-            }
-            catch {
-                throw new Error(`File not found: ${path}`);
-            }
             const content = await readFile(fullPath, 'utf-8');
             return this.frontmatterHandler.parse(content);
         }
         catch (error) {
-            if (error instanceof Error) {
-                if (error.message.includes('File not found')) {
-                    throw error;
+            if (error instanceof Error && 'code' in error) {
+                if (error.code === 'ENOENT') {
+                    throw new Error(`File not found: ${path}`);
                 }
-                if (error.message.includes('permission') || error.message.includes('access')) {
+                if (error.code === 'EACCES') {
                     throw new Error(`Permission denied: ${path}`);
                 }
-                if (error.message.includes('Cannot read directory')) {
-                    throw error;
+                if (error.code === 'EISDIR') {
+                    throw new Error(`Cannot read directory as file: ${path}. Use list_directory tool instead.`);
                 }
             }
             throw new Error(`Failed to read file: ${path} - ${error instanceof Error ? error.message : 'Unknown error'}`);
@@ -303,17 +297,6 @@ export class FileSystemService {
                     message: `Cannot delete: ${path} is not a file`
                 };
             }
-            // Check if file exists
-            try {
-                await access(fullPath, constants.F_OK);
-            }
-            catch {
-                return {
-                    success: false,
-                    path: path,
-                    message: `File not found: ${path}`
-                };
-            }
             // Perform the deletion using Node.js native API
             await unlink(fullPath);
             return {
@@ -367,51 +350,44 @@ export class FileSystemService {
         const oldFullPath = this.resolvePath(oldPath);
         const newFullPath = this.resolvePath(newPath);
         try {
-            // Check if source file exists
-            try {
-                await access(oldFullPath, constants.F_OK);
-            }
-            catch {
-                return {
-                    success: false,
-                    oldPath,
-                    newPath,
-                    message: `Source file not found: ${oldPath}`
-                };
-            }
-            // Check if target already exists
-            let targetExists = false;
+            // Read source content (will throw ENOENT if not found)
+            let content;
             try {
-                await access(newFullPath, constants.F_OK);
-                targetExists = true;
-            }
-            catch {
-                // Target doesn't exist, which is fine
+                content = await readFile(oldFullPath, 'utf-8');
             }
-            if (targetExists && !overwrite) {
-                return {
-                    success: false,
-                    oldPath,
-                    newPath,
-                    message: `Target file already exists: ${newPath}. Use overwrite=true to replace it.`
-                };
+            catch (error) {
+                if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+                    return {
+                        success: false,
+                        oldPath,
+                        newPath,
+                        message: `Source file not found: ${oldPath}`
+                    };
+                }
+                throw error;
             }
-            // Read source content
-            const content = await readFile(oldFullPath, 'utf-8');
-            // Write to new location (create directories if they don't exist)
+            // Create directories if needed
             await mkdir(dirname(newFullPath), { recursive: true });
-            await writeFile(newFullPath, content, 'utf-8');
-            // Verify the write was successful
+            // Write to new location, checking for existing file atomically if !overwrite
             try {
-                await access(newFullPath, constants.F_OK);
+                if (overwrite) {
+                    await writeFile(newFullPath, content, 'utf-8');
+                }
+                else {
+                    // wx flag: write exclusive - fails if file exists
+                    await writeFile(newFullPath, content, { encoding: 'utf-8', flag: 'wx' });
+                }
             }
-            catch {
-                return {
-                    success: false,
-                    oldPath,
-                    newPath,
-                    message: `Failed to create target file: ${newPath}`
-                };
+            catch (error) {
+                if (error instanceof Error && 'code' in error && error.code === 'EEXIST') {
+                    return {
+                        success: false,
+                        oldPath,
+                        newPath,
+                        message: `Target file already exists: ${newPath}. Use overwrite=true to replace it.`
+                    };
+                }
+                throw error;
             }
             // Delete the source file
             await unlink(oldFullPath);
@@ -497,13 +473,16 @@ export class FileSystemService {
                 throw new Error(`Access denied: ${path}`);
             }
             const fullPath = this.resolvePath(path);
+            let stats;
             try {
-                await access(fullPath, constants.F_OK);
+                stats = await stat(fullPath);
             }
-            catch {
-                throw new Error(`File not found: ${path}`);
+            catch (error) {
+                if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+                    throw new Error(`File not found: ${path}`);
+                }
+                throw error;
             }
-            const stats = await stat(fullPath);
             const size = stats.size;
             const lastModified = stats.mtime.getTime();
             // Quick check for frontmatter without reading full content

package/dist/src/filesystem.test.js

@@ -1,18 +1,19 @@
 import { test, expect, beforeEach, afterEach } from "vitest";
 import { FileSystemService } from "./filesystem.js";
-import { writeFile, mkdir, rmdir } from "fs/promises";
+import { writeFile, mkdir, mkdtemp, rm } from "fs/promises";
 import { join } from "path";
-const testVaultPath = "/tmp/test-vault-filesystem";
+import { tmpdir } from "os";
+let testVaultPath;
 let fileSystem;
 beforeEach(async () => {
-    await mkdir(testVaultPath, { recursive: true });
+    testVaultPath = await mkdtemp(join(tmpdir(), "mcp-obsidian-test-"));
     fileSystem = new FileSystemService(testVaultPath);
 });
 afterEach(async () => {
     try {
-        await rmdir(testVaultPath, { recursive: true });
+        await rm(testVaultPath, { recursive: true });
     }
-    catch (error) {
+    catch {
         // Ignore cleanup errors
     }
 });
@@ -513,3 +514,139 @@ test("frontmatter validation with invalid data", async () => {
         }
     })).rejects.toThrow(/Invalid frontmatter/);
 });
+// ============================================================================
+// NON-EXISTENT VAULT TESTS
+// ============================================================================
+test("read from non-existent vault throws error", async () => {
+    const nonExistentFs = new FileSystemService("/non/existent/vault/path");
+    await expect(nonExistentFs.readNote("test.md"))
+        .rejects.toThrow(/File not found|ENOENT/);
+});
+test("write to non-existent vault creates directories", async () => {
+    const tempVault = await mkdtemp(join(tmpdir(), "mcp-obsidian-new-vault-"));
+    const newFs = new FileSystemService(tempVault);
+    try {
+        await newFs.writeNote({
+            path: "new-folder/nested/note.md",
+            content: "Test content"
+        });
+        const note = await newFs.readNote("new-folder/nested/note.md");
+        expect(note.content).toContain("Test content");
+    }
+    finally {
+        await rm(tempVault, { recursive: true });
+    }
+});
+test("list directory in non-existent vault", async () => {
+    const nonExistentFs = new FileSystemService("/non/existent/vault/path");
+    await expect(nonExistentFs.listDirectory("/"))
+        .rejects.toThrow();
+});
+// ============================================================================
+// PATH TRAVERSAL WITH SPECIAL CHARACTERS
+// ============================================================================
+test("path traversal attempt with encoded dots blocked", async () => {
+    // Path traversal should be blocked even with URL encoding
+    await expect(fileSystem.readNote("..%2F..%2Fetc%2Fpasswd"))
+        .rejects.toThrow(/Path traversal not allowed/);
+});
+test("path traversal with .. is blocked", async () => {
+    await expect(fileSystem.readNote("../outside.md"))
+        .rejects.toThrow(/Path traversal not allowed/);
+});
+test("path traversal with nested .. is blocked", async () => {
+    await expect(fileSystem.readNote("folder/../../outside.md"))
+        .rejects.toThrow(/Path traversal not allowed/);
+});
+test("path with regex special chars is treated literally", async () => {
+    const testPath = "folder (copy)/note [1].md";
+    const content = "# Test with special chars";
+    await mkdir(join(testVaultPath, "folder (copy)"), { recursive: true });
+    await writeFile(join(testVaultPath, testPath), content);
+    const note = await fileSystem.readNote(testPath);
+    expect(note.content).toContain("Test with special chars");
+});
+test("path with dollar sign works", async () => {
+    const testPath = "$special/price$100.md";
+    const content = "# Price note";
+    await mkdir(join(testVaultPath, "$special"), { recursive: true });
+    await writeFile(join(testVaultPath, testPath), content);
+    const note = await fileSystem.readNote(testPath);
+    expect(note.content).toContain("Price note");
+});
+test("path with plus sign works", async () => {
+    const testPath = "C++/notes.md";
+    const content = "# C++ notes";
+    await mkdir(join(testVaultPath, "C++"), { recursive: true });
+    await writeFile(join(testVaultPath, testPath), content);
+    const note = await fileSystem.readNote(testPath);
+    expect(note.content).toContain("C++ notes");
+});
+test("path with pipe character works", async () => {
+    const testPath = "choice|option.md";
+    const content = "# Choice note";
+    await writeFile(join(testVaultPath, testPath), content);
+    const note = await fileSystem.readNote(testPath);
+    expect(note.content).toContain("Choice note");
+});
+test("delete note with special chars in path", async () => {
+    const testPath = "folder (archive)/note [old].md";
+    const content = "# Old note";
+    await mkdir(join(testVaultPath, "folder (archive)"), { recursive: true });
+    await writeFile(join(testVaultPath, testPath), content);
+    const result = await fileSystem.deleteNote({
+        path: testPath,
+        confirmPath: testPath
+    });
+    expect(result.success).toBe(true);
+});
+test("move note with special chars in both paths", async () => {
+    const oldPath = "source (1)/note [a].md";
+    const newPath = "dest (2)/note [b].md";
+    const content = "# Moving note";
+    await mkdir(join(testVaultPath, "source (1)"), { recursive: true });
+    await mkdir(join(testVaultPath, "dest (2)"), { recursive: true });
+    await writeFile(join(testVaultPath, oldPath), content);
+    const result = await fileSystem.moveNote({
+        oldPath,
+        newPath
+    });
+    expect(result.success).toBe(true);
+    const note = await fileSystem.readNote(newPath);
+    expect(note.content).toContain("Moving note");
+});
+test("patch note with regex special chars in oldString", async () => {
+    const testPath = "regex-test.md";
+    const content = "Price: $10.50 (discount)";
+    await writeFile(join(testVaultPath, testPath), content);
+    const result = await fileSystem.patchNote({
+        path: testPath,
+        oldString: "$10.50 (discount)",
+        newString: "$15.00 (regular)",
+        replaceAll: false
+    });
+    expect(result.success).toBe(true);
+    const note = await fileSystem.readNote(testPath);
+    expect(note.content).toContain("$15.00 (regular)");
+});
+// Note: searchNotes is in SearchService, not FileSystemService
+// Search tests with regex special chars should be in search.test.ts
+// ============================================================================
+// UNICODE AND INTERNATIONAL PATHS
+// ============================================================================
+test("handles unicode in file paths", async () => {
+    const testPath = "日本語/ノート.md";
+    const content = "# Japanese note";
+    await mkdir(join(testVaultPath, "日本語"), { recursive: true });
+    await writeFile(join(testVaultPath, testPath), content);
+    const note = await fileSystem.readNote(testPath);
+    expect(note.content).toContain("Japanese note");
+});
+test("handles emoji in file paths", async () => {
+    const testPath = "📁/🎉.md";
+    const content = "# Emoji note";
+    await mkdir(join(testVaultPath, "📁"), { recursive: true });
+    await writeFile(join(testVaultPath, testPath), content);
+    const note = await fileSystem.readNote(testPath);
+    expect(note.content).toContain("Emoji note");
+});

package/dist/src/integration.test.js

@@ -0,0 +1,229 @@
+import { test, expect, beforeEach, afterEach, describe } from "vitest";
+import { FileSystemService } from "./filesystem.js";
+import { FrontmatterHandler } from "./frontmatter.js";
+import { PathFilter } from "./pathfilter.js";
+import { SearchService } from "./search.js";
+import { writeFile, mkdir, mkdtemp, rm } from "fs/promises";
+import { join } from "path";
+import { tmpdir } from "os";
+let testVaultPath;
+let pathFilter;
+let frontmatterHandler;
+let fileSystem;
+let searchService;
+beforeEach(async () => {
+    testVaultPath = await mkdtemp(join(tmpdir(), "mcp-obsidian-integration-"));
+    // Initialize services (same as server.ts)
+    pathFilter = new PathFilter();
+    frontmatterHandler = new FrontmatterHandler();
+    fileSystem = new FileSystemService(testVaultPath, pathFilter, frontmatterHandler);
+    searchService = new SearchService(testVaultPath, pathFilter);
+});
+afterEach(async () => {
+    try {
+        await rm(testVaultPath, { recursive: true });
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+});
+// ============================================================================
+// INTEGRATION TESTS - END-TO-END WORKFLOW
+// ============================================================================
+describe("Integration: Service Layer Workflows", () => {
+    test("write, read, and delete note workflow", async () => {
+        // 1. Write a note with frontmatter
+        await fileSystem.writeNote({
+            path: "test-note.md",
+            content: "# Test Note\n\nThis is a test.",
+            frontmatter: { tags: ["test"], status: "draft" }
+        });
+        // 2. Read the note back
+        const note = await fileSystem.readNote("test-note.md");
+        expect(note.content).toContain("This is a test");
+        expect(note.frontmatter?.tags).toEqual(["test"]);
+        expect(note.frontmatter?.status).toBe("draft");
+        // 3. Delete the note
+        const deleteResult = await fileSystem.deleteNote({
+            path: "test-note.md",
+            confirmPath: "test-note.md"
+        });
+        expect(deleteResult.success).toBe(true);
+    });
+    test("search notes with special characters in filenames", async () => {
+        // Create notes with special characters in paths
+        const testCases = [
+            { path: "folder (archive)/note [old].md", content: "# Old Note\n\nArchived keyword." },
+            { path: "C++/notes.md", content: "# C++ Notes\n\nProgramming keyword." },
+            { path: "backup.2024/important.md", content: "# Important\n\nBackup keyword." },
+            { path: "price$100.md", content: "# Pricing\n\nCost keyword." }
+        ];
+        // Write all test notes
+        for (const { path, content } of testCases) {
+            if (path.includes('/')) {
+                const dirName = path.split('/')[0];
+                if (dirName) {
+                    await mkdir(join(testVaultPath, dirName), { recursive: true });
+                }
+            }
+            await writeFile(join(testVaultPath, path), content);
+        }
+        // Search for keyword
+        const results = await searchService.search({
+            query: "keyword",
+            limit: 10
+        });
+        expect(results.length).toBe(4);
+        // Verify paths with special characters are returned correctly
+        const paths = results.map((r) => r.p);
+        expect(paths).toContain("folder (archive)/note [old].md");
+        expect(paths).toContain("C++/notes.md");
+    });
+    test("write note with regex special chars in content", async () => {
+        const content = `# Price List
+
+Item: Widget ($10.50)
+Regex: [a-z]+ matches lowercase
+Math: 2 + 2 = 4
+Pattern: backup.2024/**/*.md`;
+        await fileSystem.writeNote({
+            path: "special-chars.md",
+            content
+        });
+        // Read back and verify exact content
+        const note = await fileSystem.readNote("special-chars.md");
+        expect(note.content).toContain("($10.50)");
+        expect(note.content).toContain("[a-z]+");
+        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("multi-step workflow: search, read multiple, update frontmatter", async () => {
+        // Create several notes
+        for (let i = 1; i <= 3; i++) {
+            await fileSystem.writeNote({
+                path: `note-${i}.md`,
+                content: `# Note ${i}\n\nThis contains searchterm.`,
+                frontmatter: { id: i, processed: false }
+            });
+        }
+        // Search for notes
+        const searchResults = await searchService.search({
+            query: "searchterm",
+            limit: 10
+        });
+        expect(searchResults.length).toBe(3);
+        // Read multiple notes
+        const paths = searchResults.map(r => r.p);
+        const readResult = await fileSystem.readMultipleNotes({
+            paths,
+            includeContent: true,
+            includeFrontmatter: true
+        });
+        expect(readResult.successful.length).toBe(3);
+        // Update frontmatter on all notes
+        for (const path of paths) {
+            await fileSystem.updateFrontmatter({
+                path,
+                frontmatter: { processed: true },
+                merge: true
+            });
+        }
+        // Verify updates
+        for (const path of paths) {
+            const note = await fileSystem.readNote(path);
+            expect(note.frontmatter?.processed).toBe(true);
+        }
+    });
+});
+// ============================================================================
+// 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 (< 100ms for 8000 checks)
+        expect(duration).toBeLessThan(100);
+    });
+    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

@@ -18,13 +18,14 @@ export class PathFilter {
         ];
     }
     simpleGlobMatch(pattern, path) {
-        // Convert glob pattern to regex
-        // Handle ** (any number of directories)
-        let regexPattern = pattern
-            .replace(/\*\*/g, '.*') // ** matches any number of directories
-            .replace(/\*/g, '[^/]*') // * matches anything except /
-            .replace(/\?/g, '[^/]') // ? matches single character except /
-            .replace(/\./g, '\\.'); // Escape dots
+        // Normalize pattern path separators (Windows compatibility)
+        const normalizedPattern = pattern.replace(/\\/g, '/');
+        // Convert glob pattern to regex, escaping special regex chars first
+        let regexPattern = normalizedPattern
+            .replace(/[\\^$.*+?()[\]{}|]/g, '\\$&') // Escape all regex special chars
+            .replace(/\\\*\\\*/g, '.*') // ** matches any number of directories (unescape)
+            .replace(/\\\*/g, '[^/]*') // * matches anything except / (unescape)
+            .replace(/\\\?/g, '[^/]'); // ? matches single character except / (unescape)
         // Ensure we match the full path
         regexPattern = '^' + regexPattern + '$';
         const regex = new RegExp(regexPattern);

package/dist/src/pathfilter.test.js

@@ -0,0 +1,232 @@
+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/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/config")).toBe(false);
+        expect(filter.isAllowed(".git/objects/abc123")).toBe(false);
+    });
+    test("blocks node_modules", () => {
+        const filter = new PathFilter();
+        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);
+    });
+    // ============================================================================
+    // 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();
+        });
+    });
+    // ============================================================================
+    // 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);
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mauricio.wolff/mcp-obsidian",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Universal AI bridge for Obsidian vaults - connect any MCP-compatible assistant",
   "author": "bitbonsai",
   "license": "MIT",
@@ -34,7 +34,7 @@
     "@types/node": "^20.19.21",
     "tsx": "^4.20.6",
     "typescript": "^5.9.3",
-    "vitest": "^1.6.1"
+    "vitest": "^4.0.15"
   },
   "engines": {
     "node": ">=18.0.0"