@bitbonsai/mcpvault 0.9.0 → 0.10.0

package/dist/src/frontmatter.test.js

@@ -1,118 +0,0 @@
-import { test, expect, describe } from "vitest";
-import { FrontmatterHandler, parseFrontmatter } from "./frontmatter.js";
-const handler = new FrontmatterHandler();
-test("parse note with frontmatter", () => {
-    const content = `---
-title: Test Note
-tags: [test, example]
-created: 2023-01-01
----
-
-# Test Note
-
-This is a test note with frontmatter.`;
-    const result = handler.parse(content);
-    expect(result.frontmatter.title).toBe("Test Note");
-    expect(result.frontmatter.tags).toEqual(["test", "example"]);
-    expect(result.frontmatter.created).toEqual(new Date("2023-01-01"));
-    expect(result.content.trim()).toBe("# Test Note\n\nThis is a test note with frontmatter.");
-});
-test("parse note without frontmatter", () => {
-    const content = `# Test Note
-
-This is a test note without frontmatter.`;
-    const result = handler.parse(content);
-    expect(result.frontmatter).toEqual({});
-    expect(result.content).toBe(content);
-});
-test("stringify with frontmatter", () => {
-    const frontmatter = {
-        title: "Test Note",
-        tags: ["test", "example"]
-    };
-    const content = "# Test Note\n\nContent here.";
-    const result = handler.stringify(frontmatter, content);
-    expect(result).toContain("---");
-    expect(result).toContain("title: Test Note");
-    expect(result).toContain("tags:");
-    expect(result).toContain("# Test Note");
-});
-test("stringify without frontmatter", () => {
-    const content = "# Test Note\n\nContent here.";
-    const result = handler.stringify({}, content);
-    expect(result).toBe(content);
-});
-test("validate valid frontmatter", () => {
-    const frontmatter = {
-        title: "Valid Title",
-        tags: ["tag1", "tag2"],
-        date: new Date("2023-01-01"),
-        count: 42,
-        enabled: true
-    };
-    const result = handler.validate(frontmatter);
-    expect(result.isValid).toBe(true);
-    expect(result.errors).toHaveLength(0);
-});
-test("validate invalid frontmatter with function", () => {
-    const frontmatter = {
-        title: "Invalid",
-        badFunction: () => "not allowed"
-    };
-    const result = handler.validate(frontmatter);
-    expect(result.isValid).toBe(false);
-    expect(result.errors.length).toBeGreaterThan(0);
-    // The specific error message may vary between YAML libraries
-    expect(result.errors[0]).toMatch(/Functions are not allowed|Invalid YAML structure/);
-});
-test("update frontmatter in existing content", () => {
-    const content = `---
-title: Old Title
-tags: [old]
----
-
-# Content
-
-Some content here.`;
-    const updates = {
-        title: "New Title",
-        modified: "2023-12-01"
-    };
-    const result = handler.updateFrontmatter(content, updates);
-    expect(result).toContain("title: New Title");
-    expect(result).toContain("modified: '2023-12-01'");
-    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

@@ -1,168 +0,0 @@
-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(), "mcpvault-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("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++) {
-            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);
-        }
-    });
-});

package/dist/src/pathfilter.test.js

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