@bitbonsai/mcpvault 0.8.2

package/dist/src/frontmatter.js

@@ -0,0 +1,129 @@
+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 {
+            const parsed = matter(content);
+            return {
+                frontmatter: parsed.data,
+                content: parsed.content,
+                originalContent: content
+            };
+        }
+        catch (error) {
+            // If parsing fails, treat as content without frontmatter
+            return {
+                frontmatter: {},
+                content: content,
+                originalContent: content
+            };
+        }
+    }
+    stringify(frontmatterData, content) {
+        try {
+            // If no frontmatter, return content as-is
+            if (!frontmatterData || Object.keys(frontmatterData).length === 0) {
+                return content;
+            }
+            return matter.stringify(content, frontmatterData);
+        }
+        catch (error) {
+            throw new Error(`Failed to stringify frontmatter: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    validate(frontmatterData) {
+        const result = {
+            isValid: true,
+            errors: [],
+            warnings: []
+        };
+        try {
+            // Test if the frontmatter can be serialized to valid YAML using gray-matter
+            matter.stringify('', frontmatterData);
+        }
+        catch (error) {
+            result.isValid = false;
+            result.errors.push(`Invalid YAML structure: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+        // Check for problematic values
+        this.checkForProblematicValues(frontmatterData, result, '');
+        return result;
+    }
+    checkForProblematicValues(obj, result, path) {
+        if (obj === null || obj === undefined) {
+            return;
+        }
+        if (typeof obj === 'function') {
+            result.errors.push(`Functions are not allowed in frontmatter at path: ${path}`);
+            result.isValid = false;
+            return;
+        }
+        if (typeof obj === 'symbol') {
+            result.errors.push(`Symbols are not allowed in frontmatter at path: ${path}`);
+            result.isValid = false;
+            return;
+        }
+        if (obj instanceof Date) {
+            // Dates are fine, but warn if they're invalid
+            if (isNaN(obj.getTime())) {
+                result.warnings.push(`Invalid date at path: ${path}`);
+            }
+            return;
+        }
+        if (Array.isArray(obj)) {
+            obj.forEach((item, index) => {
+                this.checkForProblematicValues(item, result, `${path}[${index}]`);
+            });
+            return;
+        }
+        if (typeof obj === 'object' && obj !== null) {
+            for (const [key, value] of Object.entries(obj)) {
+                const currentPath = path ? `${path}.${key}` : key;
+                // Check for problematic keys
+                if (typeof key !== 'string') {
+                    result.errors.push(`Non-string keys are not allowed: ${key}`);
+                    result.isValid = false;
+                }
+                this.checkForProblematicValues(value, result, currentPath);
+            }
+        }
+    }
+    extractFrontmatter(content) {
+        const parsed = this.parse(content);
+        return parsed.frontmatter;
+    }
+    updateFrontmatter(content, updates) {
+        const parsed = this.parse(content);
+        const updatedFrontmatter = { ...parsed.frontmatter, ...updates };
+        const validation = this.validate(updatedFrontmatter);
+        if (!validation.isValid) {
+            throw new Error(`Invalid frontmatter: ${validation.errors.join(', ')}`);
+        }
+        return this.stringify(updatedFrontmatter, parsed.content);
+    }
+}

package/dist/src/frontmatter.test.js

@@ -0,0 +1,118 @@
+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

@@ -0,0 +1,168 @@
+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.js

@@ -0,0 +1,94 @@
+export class PathFilter {
+    ignoredPatterns;
+    allowedExtensions;
+    constructor(config) {
+        this.ignoredPatterns = [
+            '.obsidian',
+            '.obsidian/**',
+            '.git',
+            '.git/**',
+            'node_modules',
+            'node_modules/**',
+            '.DS_Store',
+            'Thumbs.db',
+            ...config?.ignoredPatterns || []
+        ];
+        this.allowedExtensions = [
+            '.md',
+            '.markdown',
+            '.txt',
+            '.base', // Obsidian Bases (YAML)
+            '.canvas', // Obsidian Canvas (JSON)
+            ...config?.allowedExtensions || []
+        ];
+    }
+    simpleGlobMatch(pattern, path) {
+        // 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);
+        return regex.test(path);
+    }
+    isAllowed(path) {
+        // Normalize path separators
+        const normalizedPath = path.replace(/\\/g, '/');
+        if (this.isIgnoredPath(normalizedPath)) {
+            return false;
+        }
+        // For files, check extension if allowedExtensions is configured
+        if (this.allowedExtensions.length > 0 && this.isFile(normalizedPath)) {
+            const hasAllowedExtension = this.allowedExtensions.some(ext => normalizedPath.toLowerCase().endsWith(ext.toLowerCase()));
+            if (!hasAllowedExtension) {
+                return false;
+            }
+        }
+        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
+        if (path.endsWith('/')) {
+            return false;
+        }
+        // Get the last component of the path
+        const lastSlashIndex = path.lastIndexOf('/');
+        const lastComponent = lastSlashIndex === -1 ? path : path.substring(lastSlashIndex + 1);
+        // Check if the last component has a file extension
+        // A file extension is a dot followed by 1-10 alphanumeric characters at the end
+        // This distinguishes "file.md" (file) from "1. Project" (directory with dot in name)
+        const lastDotIndex = lastComponent.lastIndexOf('.');
+        if (lastDotIndex === -1 || lastDotIndex === 0) {
+            // No dot, or dot at the start (like .gitignore) - treat as no extension
+            return false;
+        }
+        const extension = lastComponent.substring(lastDotIndex + 1);
+        // Extension should be 1-10 characters and contain only alphanumeric characters
+        // This allows .md, .txt, .markdown but not ". Project" (space after dot)
+        return extension.length >= 1 && extension.length <= 10 && /^[a-zA-Z0-9]+$/.test(extension);
+    }
+    filterPaths(paths) {
+        return paths.filter(path => this.isAllowed(path));
+    }
+}