@bitbonsai/mcpvault 0.8.2 → 0.10.0

package/dist/src/createServer.js

@@ -0,0 +1,383 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { FileSystemService } from "./filesystem.js";
+import { FrontmatterHandler, parseFrontmatter } from "./frontmatter.js";
+import { PathFilter } from "./pathfilter.js";
+import { SearchService } from "./search.js";
+import { resolve } from "path";
+export function createServer(vaultPath, options = {}) {
+    const { name = "mcpvault", version = "0.0.0", pathFilter = new PathFilter(), frontmatterHandler = new FrontmatterHandler(), } = options;
+    const resolvedVaultPath = resolve(vaultPath);
+    const fileSystem = new FileSystemService(resolvedVaultPath, pathFilter, frontmatterHandler);
+    const searchService = new SearchService(resolvedVaultPath, pathFilter);
+    const server = new Server({ name, version }, {
+        capabilities: { tools: {} },
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return {
+            tools: [
+                {
+                    name: "read_note",
+                    description: "Read a note from the Obsidian vault",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            path: { type: "string", description: "Path to the note relative to vault root" },
+                            prettyPrint: { type: "boolean", description: "Format JSON response with indentation (default: false)", default: false }
+                        },
+                        required: ["path"]
+                    }
+                },
+                {
+                    name: "write_note",
+                    description: "Write a note to the Obsidian vault",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            path: { type: "string", description: "Path to the note relative to vault root" },
+                            content: { type: "string", description: "Content of the note" },
+                            frontmatter: { type: "object", description: "Frontmatter object (optional)" },
+                            mode: { type: "string", enum: ["overwrite", "append", "prepend"], description: "Write mode: 'overwrite' (default), 'append', or 'prepend'", default: "overwrite" }
+                        },
+                        required: ["path", "content"]
+                    }
+                },
+                {
+                    name: "patch_note",
+                    description: "Efficiently update part of a note by replacing a specific string. This is more efficient than rewriting the entire note for small changes.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            path: { type: "string", description: "Path to the note relative to vault root" },
+                            oldString: { type: "string", description: "The exact string to replace. Must match exactly including whitespace and line breaks." },
+                            newString: { type: "string", description: "The new string to insert in place of oldString" },
+                            replaceAll: { type: "boolean", description: "If true, replace all occurrences. If false (default), the operation will fail if multiple matches are found to prevent unintended replacements.", default: false }
+                        },
+                        required: ["path", "oldString", "newString"]
+                    }
+                },
+                {
+                    name: "list_directory",
+                    description: "List files and directories in the vault (includes non-note filenames, while read/write tools remain note-only)",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            path: { type: "string", description: "Path relative to vault root (default: '/')", default: "/" },
+                            prettyPrint: { type: "boolean", description: "Format JSON response with indentation (default: false)", default: false }
+                        }
+                    }
+                },
+                {
+                    name: "delete_note",
+                    description: "Delete a note from the Obsidian vault (requires confirmation)",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            path: { type: "string", description: "Path to the note relative to vault root" },
+                            confirmPath: { type: "string", description: "Confirmation: must exactly match the path parameter to proceed with deletion" }
+                        },
+                        required: ["path", "confirmPath"]
+                    }
+                },
+                {
+                    name: "search_notes",
+                    description: "Search for notes in the vault by content or frontmatter",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            query: { type: "string", description: "Search query text" },
+                            limit: { type: "number", description: "Maximum number of results (default: 5, max: 20)", default: 5 },
+                            searchContent: { type: "boolean", description: "Search in note content (default: true)", default: true },
+                            searchFrontmatter: { type: "boolean", description: "Search in frontmatter (default: false)", default: false },
+                            caseSensitive: { type: "boolean", description: "Case sensitive search (default: false)", default: false },
+                            prettyPrint: { type: "boolean", description: "Format JSON response with indentation (default: false)", default: false }
+                        },
+                        required: ["query"]
+                    }
+                },
+                {
+                    name: "move_note",
+                    description: "Move or rename a note in the vault",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            oldPath: { type: "string", description: "Current path of the note" },
+                            newPath: { type: "string", description: "New path for the note" },
+                            overwrite: { type: "boolean", description: "Allow overwriting existing file (default: false)", default: false }
+                        },
+                        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)",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            paths: { type: "array", items: { type: "string" }, description: "Array of note paths to read", maxItems: 10 },
+                            includeContent: { type: "boolean", description: "Include note content (default: true)", default: true },
+                            includeFrontmatter: { type: "boolean", description: "Include frontmatter (default: true)", default: true },
+                            prettyPrint: { type: "boolean", description: "Format JSON response with indentation (default: false)", default: false }
+                        },
+                        required: ["paths"]
+                    }
+                },
+                {
+                    name: "update_frontmatter",
+                    description: "Update frontmatter of a note without changing content",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            path: { type: "string", description: "Path to the note" },
+                            frontmatter: { type: "object", description: "Frontmatter object to update" },
+                            merge: { type: "boolean", description: "Merge with existing frontmatter (default: true)", default: true }
+                        },
+                        required: ["path", "frontmatter"]
+                    }
+                },
+                {
+                    name: "get_notes_info",
+                    description: "Get metadata for notes without reading full content",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            paths: { type: "array", items: { type: "string" }, description: "Array of note paths to get info for" },
+                            prettyPrint: { type: "boolean", description: "Format JSON response with indentation (default: false)", default: false }
+                        },
+                        required: ["paths"]
+                    }
+                },
+                {
+                    name: "get_frontmatter",
+                    description: "Extract frontmatter from a note without reading the content",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            path: { type: "string", description: "Path to the note relative to vault root" },
+                            prettyPrint: { type: "boolean", description: "Format JSON response with indentation (default: false)", default: false }
+                        },
+                        required: ["path"]
+                    }
+                },
+                {
+                    name: "manage_tags",
+                    description: "Add, remove, or list tags in a note",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            path: { type: "string", description: "Path to the note relative to vault root" },
+                            operation: { type: "string", enum: ["add", "remove", "list"], description: "Operation to perform: 'add', 'remove', or 'list'" },
+                            tags: { type: "array", items: { type: "string" }, description: "Array of tags (required for 'add' and 'remove' operations)" }
+                        },
+                        required: ["path", "operation"]
+                    }
+                },
+                {
+                    name: "get_vault_stats",
+                    description: "Get vault statistics including total notes, folders, size, and recently modified files. Useful for understanding vault scope before batch operations.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            recentCount: { type: "number", description: "Number of recently modified files to return (default: 5, max: 20)", default: 5 },
+                            prettyPrint: { type: "boolean", description: "Format JSON response with indentation (default: false)", default: false }
+                        }
+                    }
+                }
+            ]
+        };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name: toolName, arguments: args } = request.params;
+        const trimmedArgs = trimPaths(args);
+        try {
+            switch (toolName) {
+                case "read_note": {
+                    const note = await fileSystem.readNote(trimmedArgs.path);
+                    const indent = trimmedArgs.prettyPrint ? 2 : undefined;
+                    return {
+                        content: [{ type: "text", text: JSON.stringify({ fm: note.frontmatter, content: note.content }, null, indent) }]
+                    };
+                }
+                case "write_note": {
+                    const fm = parseFrontmatter(trimmedArgs.frontmatter);
+                    await fileSystem.writeNote({
+                        path: trimmedArgs.path,
+                        content: trimmedArgs.content,
+                        ...(fm !== undefined && { frontmatter: fm }),
+                        mode: trimmedArgs.mode || 'overwrite'
+                    });
+                    return {
+                        content: [{ type: "text", text: `Successfully wrote note: ${trimmedArgs.path} (mode: ${trimmedArgs.mode || 'overwrite'})` }]
+                    };
+                }
+                case "patch_note": {
+                    const result = await fileSystem.patchNote({
+                        path: trimmedArgs.path,
+                        oldString: trimmedArgs.oldString,
+                        newString: trimmedArgs.newString,
+                        replaceAll: trimmedArgs.replaceAll
+                    });
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                        isError: !result.success
+                    };
+                }
+                case "list_directory": {
+                    const listing = await fileSystem.listDirectory(trimmedArgs.path || '');
+                    const indent = trimmedArgs.prettyPrint ? 2 : undefined;
+                    return {
+                        content: [{ type: "text", text: JSON.stringify({ dirs: listing.directories, files: listing.files }, null, indent) }]
+                    };
+                }
+                case "delete_note": {
+                    const result = await fileSystem.deleteNote({
+                        path: trimmedArgs.path,
+                        confirmPath: trimmedArgs.confirmPath
+                    });
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                        isError: !result.success
+                    };
+                }
+                case "search_notes": {
+                    const results = await searchService.search({
+                        query: trimmedArgs.query,
+                        limit: trimmedArgs.limit,
+                        searchContent: trimmedArgs.searchContent,
+                        searchFrontmatter: trimmedArgs.searchFrontmatter,
+                        caseSensitive: trimmedArgs.caseSensitive
+                    });
+                    const indent = trimmedArgs.prettyPrint ? 2 : undefined;
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(results, null, indent) }]
+                    };
+                }
+                case "move_note": {
+                    const result = await fileSystem.moveNote({
+                        oldPath: trimmedArgs.oldPath,
+                        newPath: trimmedArgs.newPath,
+                        overwrite: trimmedArgs.overwrite
+                    });
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                        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,
+                        includeContent: trimmedArgs.includeContent,
+                        includeFrontmatter: trimmedArgs.includeFrontmatter
+                    });
+                    const indent = trimmedArgs.prettyPrint ? 2 : undefined;
+                    return {
+                        content: [{ type: "text", text: JSON.stringify({ ok: result.successful, err: result.failed }, null, indent) }]
+                    };
+                }
+                case "update_frontmatter": {
+                    const fm = parseFrontmatter(trimmedArgs.frontmatter);
+                    if (!fm) {
+                        throw new Error('frontmatter is required');
+                    }
+                    await fileSystem.updateFrontmatter({
+                        path: trimmedArgs.path,
+                        frontmatter: fm,
+                        merge: trimmedArgs.merge
+                    });
+                    return {
+                        content: [{ type: "text", text: `Successfully updated frontmatter for: ${trimmedArgs.path}` }]
+                    };
+                }
+                case "get_notes_info": {
+                    const result = await fileSystem.getNotesInfo(trimmedArgs.paths);
+                    const indent = trimmedArgs.prettyPrint ? 2 : undefined;
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(result, null, indent) }]
+                    };
+                }
+                case "get_frontmatter": {
+                    const note = await fileSystem.readNote(trimmedArgs.path);
+                    const indent = trimmedArgs.prettyPrint ? 2 : undefined;
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(note.frontmatter, null, indent) }]
+                    };
+                }
+                case "manage_tags": {
+                    const result = await fileSystem.manageTags({
+                        path: trimmedArgs.path,
+                        operation: trimmedArgs.operation,
+                        tags: trimmedArgs.tags
+                    });
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                        isError: !result.success
+                    };
+                }
+                case "get_vault_stats": {
+                    const recentCount = Math.min(trimmedArgs.recentCount || 5, 20);
+                    const stats = await fileSystem.getVaultStats(recentCount);
+                    const indent = trimmedArgs.prettyPrint ? 2 : undefined;
+                    return {
+                        content: [{ type: "text", text: JSON.stringify({ notes: stats.totalNotes, folders: stats.totalFolders, size: stats.totalSize, recent: stats.recentlyModified }, null, indent) }]
+                    };
+                }
+                default:
+                    throw new Error(`Unknown tool: ${toolName}`);
+            }
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}` }],
+                isError: true
+            };
+        }
+    });
+    return server;
+}
+function trimPaths(args) {
+    const trimmed = { ...args };
+    if (trimmed.path && typeof trimmed.path === 'string')
+        trimmed.path = trimmed.path.trim();
+    if (trimmed.oldPath && typeof trimmed.oldPath === 'string')
+        trimmed.oldPath = trimmed.oldPath.trim();
+    if (trimmed.newPath && typeof trimmed.newPath === 'string')
+        trimmed.newPath = trimmed.newPath.trim();
+    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();
+    if (trimmed.paths && Array.isArray(trimmed.paths)) {
+        trimmed.paths = trimmed.paths.map((p) => typeof p === 'string' ? p.trim() : p);
+    }
+    return trimmed;
+}

package/dist/src/filesystem.d.ts

@@ -0,0 +1,26 @@
+import { FrontmatterHandler } from './frontmatter.js';
+import { PathFilter } from './pathfilter.js';
+import type { ParsedNote, DirectoryListing, NoteWriteParams, DeleteNoteParams, DeleteResult, MoveNoteParams, MoveFileParams, MoveResult, BatchReadParams, BatchReadResult, UpdateFrontmatterParams, NoteInfo, TagManagementParams, TagManagementResult, PatchNoteParams, PatchNoteResult, VaultStats } from './types.js';
+export declare class FileSystemService {
+    private vaultPath;
+    private frontmatterHandler;
+    private pathFilter;
+    constructor(vaultPath: string, pathFilter?: PathFilter, frontmatterHandler?: FrontmatterHandler);
+    private resolvePath;
+    readNote(path: string): Promise<ParsedNote>;
+    writeNote(params: NoteWriteParams): Promise<void>;
+    patchNote(params: PatchNoteParams): Promise<PatchNoteResult>;
+    listDirectory(path?: string): Promise<DirectoryListing>;
+    exists(path: string): Promise<boolean>;
+    isDirectory(path: string): Promise<boolean>;
+    deleteNote(params: DeleteNoteParams): Promise<DeleteResult>;
+    moveNote(params: MoveNoteParams): Promise<MoveResult>;
+    moveFile(params: MoveFileParams): Promise<MoveResult>;
+    readMultipleNotes(params: BatchReadParams): Promise<BatchReadResult>;
+    updateFrontmatter(params: UpdateFrontmatterParams): Promise<void>;
+    getNotesInfo(paths: string[]): Promise<NoteInfo[]>;
+    manageTags(params: TagManagementParams): Promise<TagManagementResult>;
+    getVaultPath(): string;
+    getVaultStats(recentCount?: number): Promise<VaultStats>;
+}
+//# sourceMappingURL=filesystem.d.ts.map

package/dist/src/filesystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../../src/filesystem.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,eAAe,EAAE,gBAAgB,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,UAAU,EAAE,eAAe,EAAE,eAAe,EAAE,uBAAuB,EAAE,QAAQ,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,eAAe,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAEzT,qBAAa,iBAAiB;IAK1B,OAAO,CAAC,SAAS;IAJnB,OAAO,CAAC,kBAAkB,CAAqB;IAC/C,OAAO,CAAC,UAAU,CAAa;gBAGrB,SAAS,EAAE,MAAM,EACzB,UAAU,CAAC,EAAE,UAAU,EACvB,kBAAkB,CAAC,EAAE,kBAAkB;IAazC,OAAO,CAAC,WAAW;IA6Db,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAgC3C,SAAS,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IA6EjD,SAAS,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;IA2F5D,aAAa,CAAC,IAAI,GAAE,MAAW,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA8D3D,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAetC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAe3C,UAAU,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC;IAmE3D,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC;IAoFrD,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC;IA6HrD,iBAAiB,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;IAgDpE,iBAAiB,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC;IA6BjE,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;IA2ClD,UAAU,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IA0F3E,YAAY,IAAI,MAAM;IAIhB,aAAa,CAAC,WAAW,GAAE,MAAU,GAAG,OAAO,CAAC,UAAU,CAAC;CAwDlE"}

package/dist/src/filesystem.js

@@ -1,6 +1,6 @@
 import { join, resolve, relative, dirname } from 'path';
 import { readdir, stat, readFile, writeFile, unlink, mkdir, access, rename, copyFile } from 'node:fs/promises';
-import { constants } from 'node:fs';
+import { constants, realpathSync } from 'node:fs';
 import { FrontmatterHandler } from './frontmatter.js';
 import { PathFilter } from './pathfilter.js';
 import { generateObsidianUri } from './uri.js';
@@ -10,7 +10,14 @@ export class FileSystemService {
     pathFilter;
     constructor(vaultPath, pathFilter, frontmatterHandler) {
         this.vaultPath = vaultPath;
-        this.vaultPath = resolve(vaultPath);
+        const resolved = resolve(vaultPath);
+        try {
+            this.vaultPath = realpathSync(resolved);
+        }
+        catch {
+            // Vault path doesn't exist yet or is inaccessible; fall back to lexical resolution
+            this.vaultPath = resolved;
+        }
         this.pathFilter = pathFilter || new PathFilter();
         this.frontmatterHandler = frontmatterHandler || new FrontmatterHandler();
     }
@@ -26,11 +33,52 @@ export class FileSystemService {
             ? relativePath.slice(1)
             : relativePath;
         const fullPath = resolve(join(this.vaultPath, normalizedPath));
-        // Security check: ensure path is within vault
+        // Security check: ensure path is within vault (lexical)
         const relativeToVault = relative(this.vaultPath, fullPath);
         if (relativeToVault.startsWith('..')) {
             throw new Error(`Path traversal not allowed: ${relativePath}. Paths must be within the vault directory.`);
         }
+        // Security check: ensure symlinks don't escape vault boundary
+        try {
+            const realPath = realpathSync(fullPath);
+            const realRelative = relative(this.vaultPath, realPath);
+            if (realRelative.startsWith('..')) {
+                throw new Error(`Symlink target is outside vault: ${relativePath}. Symbolic links must resolve to a path within the vault directory.`);
+            }
+        }
+        catch (err) {
+            if (err instanceof Error && 'code' in err) {
+                const code = err.code;
+                if (code === 'ENOENT') {
+                    // File doesn't exist yet (e.g. writing a new note). Verify the parent directory resolves inside vault.
+                    try {
+                        const parentReal = realpathSync(dirname(fullPath));
+                        const parentRelative = relative(this.vaultPath, parentReal);
+                        if (parentRelative.startsWith('..')) {
+                            throw new Error(`Symlink target is outside vault: ${relativePath}. Symbolic links must resolve to a path within the vault directory.`);
+                        }
+                    }
+                    catch (parentErr) {
+                        // Parent doesn't exist either (will be created by mkdir). Lexical check above is sufficient.
+                        if (parentErr instanceof Error && parentErr.message.includes('outside vault')) {
+                            throw parentErr;
+                        }
+                    }
+                }
+                else if (code === 'ELOOP') {
+                    throw new Error(`Circular symlink detected: ${relativePath}. The symbolic link chain forms a loop.`);
+                }
+                else if (code === 'EACCES') {
+                    throw new Error(`Permission denied resolving symlink: ${relativePath}. Cannot verify the symbolic link target is within the vault.`);
+                }
+                else {
+                    throw err;
+                }
+            }
+            else {
+                throw err;
+            }
+        }
         return fullPath;
     }
     async readNote(path) {
@@ -219,13 +267,33 @@ export class FileSystemService {
                 if (!this.pathFilter.isAllowedForListing(entryPath)) {
                     continue;
                 }
-                if (entry.isDirectory()) {
+                if (entry.isSymbolicLink()) {
+                    // Follow symlinks that resolve inside the vault
+                    try {
+                        const entryFullPath = join(fullPath, entry.name);
+                        const realPath = realpathSync(entryFullPath);
+                        const realRelative = relative(this.vaultPath, realPath);
+                        if (realRelative.startsWith('..')) {
+                            continue; // Symlink target outside vault, skip silently
+                        }
+                        const targetStat = await stat(entryFullPath);
+                        if (targetStat.isDirectory()) {
+                            directories.push(entry.name);
+                        }
+                        else if (targetStat.isFile()) {
+                            files.push(entry.name);
+                        }
+                    }
+                    catch {
+                        continue; // Broken/circular/inaccessible symlink, skip silently
+                    }
+                }
+                else if (entry.isDirectory()) {
                     directories.push(entry.name);
                 }
                 else if (entry.isFile()) {
                     files.push(entry.name);
                 }
-                // Skip other types (symlinks, etc.)
             }
             return {
                 files: files.sort(),

package/dist/src/frontmatter.d.ts

@@ -0,0 +1,16 @@
+import type { ParsedNote, FrontmatterValidationResult } from './types.js';
+/**
+ * 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 declare function parseFrontmatter(value: any): Record<string, any> | undefined;
+export declare class FrontmatterHandler {
+    parse(content: string): ParsedNote;
+    stringify(frontmatterData: Record<string, any>, content: string): string;
+    validate(frontmatterData: Record<string, any>): FrontmatterValidationResult;
+    private checkForProblematicValues;
+    extractFrontmatter(content: string): Record<string, any>;
+    updateFrontmatter(content: string, updates: Record<string, any>): string;
+}
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/src/frontmatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontmatter.d.ts","sourceRoot":"","sources":["../../src/frontmatter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAE1E;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAmB5E;AAED,qBAAa,kBAAkB;IAC7B,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;IAkBlC,SAAS,CAAC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM;IAaxE,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,2BAA2B;IAqB3E,OAAO,CAAC,yBAAyB;IAmDjC,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAKxD,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM;CAWzE"}

package/dist/src/index.d.ts

@@ -0,0 +1,8 @@
+export { createServer } from './createServer.js';
+export type { CreateServerOptions } from './createServer.js';
+export { FileSystemService } from './filesystem.js';
+export { FrontmatterHandler, parseFrontmatter } from './frontmatter.js';
+export { PathFilter } from './pathfilter.js';
+export { SearchService } from './search.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,YAAY,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACxE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,cAAc,YAAY,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,6 @@
+export { createServer } from './createServer.js';
+export { FileSystemService } from './filesystem.js';
+export { FrontmatterHandler, parseFrontmatter } from './frontmatter.js';
+export { PathFilter } from './pathfilter.js';
+export { SearchService } from './search.js';
+export * from './types.js';

package/dist/src/pathfilter.d.ts

@@ -0,0 +1,13 @@
+import type { PathFilterConfig } from "./types.js";
+export declare class PathFilter {
+    private ignoredPatterns;
+    private allowedExtensions;
+    constructor(config?: Partial<PathFilterConfig>);
+    private simpleGlobMatch;
+    isAllowed(path: string): boolean;
+    isAllowedForListing(path: string): boolean;
+    private isIgnoredPath;
+    private isFile;
+    filterPaths(paths: string[]): string[];
+}
+//# sourceMappingURL=pathfilter.d.ts.map

package/dist/src/pathfilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathfilter.d.ts","sourceRoot":"","sources":["../../src/pathfilter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,qBAAa,UAAU;IACrB,OAAO,CAAC,eAAe,CAAW;IAClC,OAAO,CAAC,iBAAiB,CAAW;gBAExB,MAAM,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC;IAuB9C,OAAO,CAAC,eAAe;IAkBvB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAqBhC,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAQ1C,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,MAAM;IA0Bd,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;CAGvC"}

package/dist/src/search.d.ts

@@ -0,0 +1,11 @@
+import type { PathFilter } from './pathfilter.js';
+import type { SearchParams, SearchResult } from './types.js';
+export declare class SearchService {
+    private pathFilter;
+    private vaultPath;
+    constructor(vaultPath: string, pathFilter: PathFilter);
+    search(params: SearchParams): Promise<SearchResult[]>;
+    private findMarkdownFiles;
+    private rerank;
+}
+//# sourceMappingURL=search.d.ts.map

package/dist/src/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/search.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAiB,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG5E,qBAAa,aAAa;IAKtB,OAAO,CAAC,UAAU;IAJpB,OAAO,CAAC,SAAS,CAAS;gBAGxB,SAAS,EAAE,MAAM,EACT,UAAU,EAAE,UAAU;IAK1B,MAAM,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;YA8J7C,iBAAiB;IAwB/B,OAAO,CAAC,MAAM;CA0Bf"}