@mauricio.wolff/mcp-obsidian 0.7.4 → 0.8.1

package/dist/server.js

@@ -15,12 +15,13 @@ const __dirname = dirname(__filename);
 const packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
 const VERSION = packageJson.version;
 // Handle --version and --help flags
-const arg = process.argv[2];
-if (arg === "--version" || arg === "-v") {
+const cliArgs = process.argv.slice(2);
+const firstArg = cliArgs[0];
+if (firstArg === "--version" || firstArg === "-v") {
     console.log(VERSION);
     process.exit(0);
 }
-if (arg === "--help" || arg === "-h") {
+if (firstArg === "--help" || firstArg === "-h") {
     console.log(`
 @mauricio.wolff/mcp-obsidian v${VERSION}
 
@@ -39,10 +40,12 @@ Options:
 Examples:
   npx @mauricio.wolff/mcp-obsidian ~/Documents/MyVault
   npx @mauricio.wolff/mcp-obsidian /path/to/obsidian/vault
+  npx @mauricio.wolff/mcp-obsidian "/path/with spaces/Obsidian Vault"
 `);
     process.exit(0);
 }
-const vaultPath = arg;
+// 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");
@@ -140,7 +143,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             },
             {
                 name: "list_directory",
-                description: "List files and directories in the vault",
+                description: "List files and directories in the vault (includes non-note filenames, while read/write tools remain note-only)",
                 inputSchema: {
                     type: "object",
                     properties: {
@@ -237,6 +240,37 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ["oldPath", "newPath"]
                 }
             },
+            {
+                name: "move_file",
+                description: "Move or rename any file in the vault (binary-safe, file-only, requires confirmation)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        oldPath: {
+                            type: "string",
+                            description: "Current path of the file"
+                        },
+                        newPath: {
+                            type: "string",
+                            description: "New path for the file"
+                        },
+                        confirmOldPath: {
+                            type: "string",
+                            description: "Confirmation: must exactly match oldPath"
+                        },
+                        confirmNewPath: {
+                            type: "string",
+                            description: "Confirmation: must exactly match newPath"
+                        },
+                        overwrite: {
+                            type: "boolean",
+                            description: "Allow overwriting existing file (default: false)",
+                            default: false
+                        }
+                    },
+                    required: ["oldPath", "newPath", "confirmOldPath", "confirmNewPath"]
+                }
+            },
             {
                 name: "read_multiple_notes",
                 description: "Read multiple notes in a batch (max 10 files)",
@@ -392,6 +426,12 @@ function trimPaths(args) {
     if (trimmed.confirmPath && typeof trimmed.confirmPath === 'string') {
         trimmed.confirmPath = trimmed.confirmPath.trim();
     }
+    if (trimmed.confirmOldPath && typeof trimmed.confirmOldPath === 'string') {
+        trimmed.confirmOldPath = trimmed.confirmOldPath.trim();
+    }
+    if (trimmed.confirmNewPath && typeof trimmed.confirmNewPath === 'string') {
+        trimmed.confirmNewPath = trimmed.confirmNewPath.trim();
+    }
     // Trim path arrays
     if (trimmed.paths && Array.isArray(trimmed.paths)) {
         trimmed.paths = trimmed.paths.map((p) => typeof p === 'string' ? p.trim() : p);
@@ -515,6 +555,24 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     isError: !result.success
                 };
             }
+            case "move_file": {
+                const result = await fileSystem.moveFile({
+                    oldPath: trimmedArgs.oldPath,
+                    newPath: trimmedArgs.newPath,
+                    confirmOldPath: trimmedArgs.confirmOldPath,
+                    confirmNewPath: trimmedArgs.confirmNewPath,
+                    overwrite: trimmedArgs.overwrite
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2)
+                        }
+                    ],
+                    isError: !result.success
+                };
+            }
             case "read_multiple_notes": {
                 const result = await fileSystem.readMultipleNotes({
                     paths: trimmedArgs.paths,

package/dist/src/filesystem.js

@@ -1,5 +1,5 @@
 import { join, resolve, relative, dirname } from 'path';
-import { readdir, stat, readFile, writeFile, unlink, mkdir, access } from 'node:fs/promises';
+import { readdir, stat, readFile, writeFile, unlink, mkdir, access, rename, copyFile } from 'node:fs/promises';
 import { constants } from 'node:fs';
 import { FrontmatterHandler } from './frontmatter.js';
 import { PathFilter } from './pathfilter.js';
@@ -68,6 +68,10 @@ export class FileSystemService {
         if (!this.pathFilter.isAllowed(path)) {
             throw new Error(`Access denied: ${path}. This path is restricted (system files like .obsidian, .git, and dotfiles are not accessible).`);
         }
+        // Validate content is a defined string to prevent writing literal "undefined"
+        if (content === undefined || content === null) {
+            throw new Error(`Content is required for writing a note: ${path}. The content parameter must be a string.`);
+        }
         // Validate frontmatter if provided
         if (frontmatter) {
             const validation = this.frontmatterHandler.validate(frontmatter);
@@ -141,7 +145,7 @@ export class FileSystemService {
                 message: 'oldString cannot be empty'
             };
         }
-        if (newString === '') {
+        if (!newString) {
             return {
                 success: false,
                 path,
@@ -212,7 +216,7 @@ export class FileSystemService {
             const directories = [];
             for (const entry of entries) {
                 const entryPath = normalizedPath ? `${normalizedPath}/${entry.name}` : entry.name;
-                if (!this.pathFilter.isAllowed(entryPath)) {
+                if (!this.pathFilter.isAllowedForListing(entryPath)) {
                     continue;
                 }
                 if (entry.isDirectory()) {
@@ -407,6 +411,126 @@ export class FileSystemService {
             };
         }
     }
+    async moveFile(params) {
+        const { oldPath, newPath, confirmOldPath, confirmNewPath, overwrite = false } = params;
+        if (oldPath !== confirmOldPath || newPath !== confirmNewPath) {
+            return {
+                success: false,
+                oldPath,
+                newPath,
+                message: "Move cancelled: confirmation paths do not match. For safety, oldPath must equal confirmOldPath and newPath must equal confirmNewPath."
+            };
+        }
+        if (!this.pathFilter.isAllowedForListing(oldPath)) {
+            return {
+                success: false,
+                oldPath,
+                newPath,
+                message: `Access denied: ${oldPath}. This path is restricted (system files like .obsidian, .git, and dotfiles are not accessible).`
+            };
+        }
+        if (!this.pathFilter.isAllowedForListing(newPath)) {
+            return {
+                success: false,
+                oldPath,
+                newPath,
+                message: `Access denied: ${newPath}. This path is restricted (system files like .obsidian, .git, and dotfiles are not accessible).`
+            };
+        }
+        const oldFullPath = this.resolvePath(oldPath);
+        const newFullPath = this.resolvePath(newPath);
+        try {
+            const sourceStat = await stat(oldFullPath);
+            if (sourceStat.isDirectory()) {
+                return {
+                    success: false,
+                    oldPath,
+                    newPath,
+                    message: `Source path is a directory: ${oldPath}. move_file currently supports files only.`
+                };
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+                return {
+                    success: false,
+                    oldPath,
+                    newPath,
+                    message: `Source file not found: ${oldPath}. Use list_directory to see available files.`
+                };
+            }
+            return {
+                success: false,
+                oldPath,
+                newPath,
+                message: `Failed to inspect source file: ${error instanceof Error ? error.message : 'Unknown error'}`
+            };
+        }
+        try {
+            if (!overwrite) {
+                try {
+                    await access(newFullPath, constants.F_OK);
+                    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') {
+                        throw error;
+                    }
+                }
+            }
+            await mkdir(dirname(newFullPath), { recursive: true });
+            if (overwrite) {
+                try {
+                    const targetStat = await stat(newFullPath);
+                    if (targetStat.isDirectory()) {
+                        return {
+                            success: false,
+                            oldPath,
+                            newPath,
+                            message: `Target path is a directory: ${newPath}. Please provide a file path.`
+                        };
+                    }
+                    await unlink(newFullPath);
+                }
+                catch (error) {
+                    if (!(error instanceof Error) || !('code' in error) || error.code !== 'ENOENT') {
+                        throw error;
+                    }
+                }
+            }
+            try {
+                await rename(oldFullPath, newFullPath);
+            }
+            catch (error) {
+                if (error instanceof Error && 'code' in error && error.code === 'EXDEV') {
+                    await copyFile(oldFullPath, newFullPath);
+                    await unlink(oldFullPath);
+                }
+                else {
+                    throw error;
+                }
+            }
+            return {
+                success: true,
+                oldPath,
+                newPath,
+                message: `Successfully moved file from ${oldPath} to ${newPath}`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                oldPath,
+                newPath,
+                message: `Failed to move file: ${error instanceof Error ? error.message : 'Unknown error'}`
+            };
+        }
+    }
     async readMultipleNotes(params) {
         const { paths, includeContent = true, includeFrontmatter = true } = params;
         if (paths.length > 10) {

package/dist/src/filesystem.test.js

@@ -1,6 +1,6 @@
 import { test, expect, beforeEach, afterEach } from "vitest";
 import { FileSystemService } from "./filesystem.js";
-import { writeFile, mkdir, mkdtemp, rm } from "fs/promises";
+import { writeFile, readFile, mkdir, mkdtemp, rm } from "fs/promises";
 import { join } from "path";
 import { tmpdir } from "os";
 let testVaultPath;
@@ -184,6 +184,68 @@ test("patch note fails with empty newString", async () => {
     expect(result.success).toBe(false);
     expect(result.message).toMatch(/empty|filled|required/i);
 });
+test("patch note fails with undefined newString", async () => {
+    const testPath = "test-note.md";
+    const content = "# Test Note\n\nSome content.";
+    await writeFile(join(testVaultPath, testPath), content);
+    const result = await fileSystem.patchNote({
+        path: testPath,
+        oldString: "content",
+        newString: undefined,
+        replaceAll: false
+    });
+    expect(result.success).toBe(false);
+    expect(result.message).toMatch(/empty|filled|required/i);
+    // Verify the note was NOT corrupted
+    const note = await fileSystem.readNote(testPath);
+    expect(note.content).not.toContain("undefined");
+    expect(note.content).toContain("Some content.");
+});
+test("patch note fails with null newString", async () => {
+    const testPath = "test-note.md";
+    const content = "# Test Note\n\nSome content.";
+    await writeFile(join(testVaultPath, testPath), content);
+    const result = await fileSystem.patchNote({
+        path: testPath,
+        oldString: "content",
+        newString: null,
+        replaceAll: false
+    });
+    expect(result.success).toBe(false);
+    expect(result.message).toMatch(/empty|filled|required/i);
+    // Verify the note was NOT corrupted
+    const note = await fileSystem.readNote(testPath);
+    expect(note.content).not.toContain("null");
+    expect(note.content).toContain("Some content.");
+});
+test("writeNote rejects undefined content", async () => {
+    const testPath = "test-note.md";
+    await expect(fileSystem.writeNote({
+        path: testPath,
+        content: undefined
+    })).rejects.toThrow(/Content is required/);
+});
+test("writeNote rejects null content", async () => {
+    const testPath = "test-note.md";
+    await expect(fileSystem.writeNote({
+        path: testPath,
+        content: null
+    })).rejects.toThrow(/Content is required/);
+});
+test("writeNote append with undefined content does not corrupt note", async () => {
+    const testPath = "test-note.md";
+    const content = "# Test Note\n\nOriginal content.";
+    await writeFile(join(testVaultPath, testPath), content);
+    await expect(fileSystem.writeNote({
+        path: testPath,
+        content: undefined,
+        mode: 'append'
+    })).rejects.toThrow(/Content is required/);
+    // Verify the note was NOT corrupted
+    const note = await fileSystem.readNote(testPath);
+    expect(note.content).not.toContain("undefined");
+    expect(note.content).toContain("Original content.");
+});
 test("patch note handles regex special characters literally", async () => {
     const testPath = "test-note.md";
     const content = "Price: $10.50 (special)";
@@ -199,6 +261,34 @@ test("patch note handles regex special characters literally", async () => {
     expect(updatedNote.content).toContain("$15.75");
     expect(updatedNote.content).not.toContain("$10.50");
 });
+test("patch note works with fenced code blocks", async () => {
+    const testPath = "code-fence-test.md";
+    const content = "# Example\n\n```rust\nfn main() {\n    println!(\"hello\");\n}\n```\n";
+    await writeFile(join(testVaultPath, testPath), content);
+    const result = await fileSystem.patchNote({
+        path: testPath,
+        oldString: "println!(\"hello\");",
+        newString: "println!(\"hello world\");",
+        replaceAll: false
+    });
+    expect(result.success).toBe(true);
+    const updatedNote = await fileSystem.readNote(testPath);
+    expect(updatedNote.originalContent).toContain("println!(\"hello world\");");
+});
+test("patch note works with markdown tables", async () => {
+    const testPath = "table-test.md";
+    const content = "| Tool | Status |\n|---|---|\n| patch_note | flaky |\n";
+    await writeFile(join(testVaultPath, testPath), content);
+    const result = await fileSystem.patchNote({
+        path: testPath,
+        oldString: "| patch_note | flaky |",
+        newString: "| patch_note | stable |",
+        replaceAll: false
+    });
+    expect(result.success).toBe(true);
+    const updatedNote = await fileSystem.readNote(testPath);
+    expect(updatedNote.originalContent).toContain("| patch_note | stable |");
+});
 test("patch note preserves tabs and spaces", async () => {
     const testPath = "test-note.md";
     const content = "Line with\ttabs\n  Line with spaces\n\tTabbed line";
@@ -514,6 +604,14 @@ test("frontmatter validation with invalid data", async () => {
         }
     })).rejects.toThrow(/Invalid frontmatter/);
 });
+test("listDirectory includes non-note files but readNote still blocks them", async () => {
+    const imagePath = "assets/diagram.png";
+    await mkdir(join(testVaultPath, "assets"), { recursive: true });
+    await writeFile(join(testVaultPath, imagePath), "fake-png-content");
+    const listing = await fileSystem.listDirectory("assets");
+    expect(listing.files).toContain("diagram.png");
+    await expect(fileSystem.readNote(imagePath)).rejects.toThrow(/Access denied/);
+});
 // ============================================================================
 // NON-EXISTENT VAULT TESTS
 // ============================================================================
@@ -615,6 +713,96 @@ test("move note with special chars in both paths", async () => {
     const note = await fileSystem.readNote(newPath);
     expect(note.content).toContain("Moving note");
 });
+test("move_file moves binary files without corruption", async () => {
+    const oldPath = "attachments/original image.png";
+    const newPath = "assets/original image.png";
+    const binaryContent = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x00, 0xff, 0x10, 0x42]);
+    await mkdir(join(testVaultPath, "attachments"), { recursive: true });
+    await writeFile(join(testVaultPath, oldPath), binaryContent);
+    const result = await fileSystem.moveFile({
+        oldPath,
+        newPath,
+        confirmOldPath: oldPath,
+        confirmNewPath: newPath
+    });
+    expect(result.success).toBe(true);
+    const moved = await readFile(join(testVaultPath, newPath));
+    expect(Buffer.compare(moved, binaryContent)).toBe(0);
+    await expect(readFile(join(testVaultPath, oldPath))).rejects.toMatchObject({ code: "ENOENT" });
+});
+test("move_file respects overwrite=false", async () => {
+    const oldPath = "attachments/image.png";
+    const newPath = "assets/image.png";
+    await mkdir(join(testVaultPath, "attachments"), { recursive: true });
+    await mkdir(join(testVaultPath, "assets"), { recursive: true });
+    await writeFile(join(testVaultPath, oldPath), Buffer.from([0x01, 0x02, 0x03]));
+    await writeFile(join(testVaultPath, newPath), Buffer.from([0xaa, 0xbb]));
+    const result = await fileSystem.moveFile({
+        oldPath,
+        newPath,
+        confirmOldPath: oldPath,
+        confirmNewPath: newPath,
+        overwrite: false
+    });
+    expect(result.success).toBe(false);
+    expect(result.message).toContain("Target file already exists");
+});
+test("move_file overwrites existing file when overwrite=true", async () => {
+    const oldPath = "attachments/image.png";
+    const newPath = "assets/image.png";
+    const replacement = Buffer.from([0xde, 0xad, 0xbe, 0xef]);
+    await mkdir(join(testVaultPath, "attachments"), { recursive: true });
+    await mkdir(join(testVaultPath, "assets"), { recursive: true });
+    await writeFile(join(testVaultPath, oldPath), replacement);
+    await writeFile(join(testVaultPath, newPath), Buffer.from([0x00]));
+    const result = await fileSystem.moveFile({
+        oldPath,
+        newPath,
+        confirmOldPath: oldPath,
+        confirmNewPath: newPath,
+        overwrite: true
+    });
+    expect(result.success).toBe(true);
+    const moved = await readFile(join(testVaultPath, newPath));
+    expect(Buffer.compare(moved, replacement)).toBe(0);
+});
+test("move_file rejects directory sources", async () => {
+    await mkdir(join(testVaultPath, "attachments/folder"), { recursive: true });
+    const result = await fileSystem.moveFile({
+        oldPath: "attachments/folder",
+        newPath: "assets/folder",
+        confirmOldPath: "attachments/folder",
+        confirmNewPath: "assets/folder"
+    });
+    expect(result.success).toBe(false);
+    expect(result.message).toContain("supports files only");
+});
+test("move_file blocks restricted system paths", async () => {
+    const result = await fileSystem.moveFile({
+        oldPath: ".obsidian/plugins/data.json",
+        newPath: "assets/data.json",
+        confirmOldPath: ".obsidian/plugins/data.json",
+        confirmNewPath: "assets/data.json"
+    });
+    expect(result.success).toBe(false);
+    expect(result.message).toContain("Access denied");
+});
+test("move_file requires matching confirmation paths", async () => {
+    const oldPath = "attachments/check.png";
+    const newPath = "assets/check.png";
+    await mkdir(join(testVaultPath, "attachments"), { recursive: true });
+    await writeFile(join(testVaultPath, oldPath), Buffer.from([0x11, 0x22]));
+    const result = await fileSystem.moveFile({
+        oldPath,
+        newPath,
+        confirmOldPath: "attachments/other.png",
+        confirmNewPath: newPath
+    });
+    expect(result.success).toBe(false);
+    expect(result.message).toContain("confirmation paths do not match");
+    const stillExists = await readFile(join(testVaultPath, oldPath));
+    expect(Buffer.compare(stillExists, Buffer.from([0x11, 0x22]))).toBe(0);
+});
 test("patch note with regex special chars in oldString", async () => {
     const testPath = "regex-test.md";
     const content = "Price: $10.50 (discount)";

package/dist/src/integration.test.js

@@ -134,6 +134,37 @@ Pattern: backup.2024/**/*.md`;
         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({
+            path: "Yard.md",
+            content: "Some info about lawn care and gardening tips."
+        });
+        await fileSystem.writeNote({
+            path: "Kitchen.md",
+            content: "Recipes and kitchen organization."
+        });
+        // Search for "yard" — should match Yard.md by filename
+        const results = await searchService.search({
+            query: "yard",
+            searchContent: true,
+            limit: 10
+        });
+        expect(results.length).toBeGreaterThanOrEqual(1);
+        expect(results.some(r => r.p === "Yard.md")).toBe(true);
+        // Verify filename-only match has reasonable fields
+        const yardResult = results.find(r => r.p === "Yard.md");
+        expect(yardResult.t).toBe("Yard");
+        expect(yardResult.mc).toBeGreaterThanOrEqual(1);
+        // Search for "kitchen" — should match Kitchen.md by filename
+        const kitchenResults = await searchService.search({
+            query: "kitchen",
+            searchContent: true,
+            limit: 10
+        });
+        // Should match both filename AND content (content contains "kitchen")
+        expect(kitchenResults.some(r => r.p === "Kitchen.md")).toBe(true);
+    });
     test("multi-step workflow: search, read multiple, update frontmatter", async () => {
         // Create several notes
         for (let i = 1; i <= 3; i++) {

package/dist/src/pathfilter.js

@@ -3,8 +3,11 @@ export class PathFilter {
     allowedExtensions;
     constructor(config) {
         this.ignoredPatterns = [
+            '.obsidian',
             '.obsidian/**',
+            '.git',
             '.git/**',
+            'node_modules',
             'node_modules/**',
             '.DS_Store',
             'Thumbs.db',
@@ -34,11 +37,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)) {
@@ -49,6 +49,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

@@ -12,16 +12,19 @@ describe("PathFilter", () => {
     });
     test("blocks .obsidian directory", () => {
         const filter = new PathFilter();
+        expect(filter.isAllowed(".obsidian")).toBe(false);
         expect(filter.isAllowed(".obsidian/app.json")).toBe(false);
         expect(filter.isAllowed(".obsidian/plugins/plugin/main.js")).toBe(false);
     });
     test("blocks .git directory", () => {
         const filter = new PathFilter();
+        expect(filter.isAllowed(".git")).toBe(false);
         expect(filter.isAllowed(".git/config")).toBe(false);
         expect(filter.isAllowed(".git/objects/abc123")).toBe(false);
     });
     test("blocks node_modules", () => {
         const filter = new PathFilter();
+        expect(filter.isAllowed("node_modules")).toBe(false);
         expect(filter.isAllowed("node_modules/package/index.js")).toBe(false);
     });
     test("blocks system files", () => {
@@ -35,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
     // ============================================================================