@bitbonsai/mcpvault 0.9.0 → 0.10.0

package/dist/server.js

@@ -1,11 +1,6 @@
 #!/usr/bin/env node
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { FileSystemService } from "./src/filesystem.js";
-import { FrontmatterHandler, parseFrontmatter } from "./src/frontmatter.js";
-import { PathFilter } from "./src/pathfilter.js";
-import { SearchService } from "./src/search.js";
+import { createServer } from "./src/createServer.js";
 import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
 import { dirname, join, resolve } from "path";
@@ -51,640 +46,6 @@ Examples:
 // When omitted, default to current working directory.
 const vaultPathArg = cliArgs.join(' ').trim();
 const vaultPath = resolve(vaultPathArg || process.cwd());
-// Initialize services
-const pathFilter = new PathFilter();
-const frontmatterHandler = new FrontmatterHandler();
-const fileSystem = new FileSystemService(vaultPath, pathFilter, frontmatterHandler);
-const searchService = new SearchService(vaultPath, pathFilter);
-const server = new Server({
-    name: "mcpvault",
-    version: 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
-                        }
-                    }
-                }
-            }
-        ]
-    };
-});
-// Helper function to trim path arguments
-function trimPaths(args) {
-    const trimmed = { ...args };
-    // Trim single path properties
-    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();
-    }
-    // Trim path arrays
-    if (trimmed.paths && Array.isArray(trimmed.paths)) {
-        trimmed.paths = trimmed.paths.map((p) => typeof p === 'string' ? p.trim() : p);
-    }
-    return trimmed;
-}
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    const trimmedArgs = trimPaths(args);
-    try {
-        switch (name) {
-            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: ${name}`);
-        }
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`
-                }
-            ],
-            isError: true
-        };
-    }
-});
+const server = createServer(vaultPath, { version: VERSION });
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/dist/src/createServer.d.ts

@@ -0,0 +1,11 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { FrontmatterHandler } from "./frontmatter.js";
+import { PathFilter } from "./pathfilter.js";
+export interface CreateServerOptions {
+    name?: string;
+    version?: string;
+    pathFilter?: PathFilter;
+    frontmatterHandler?: FrontmatterHandler;
+}
+export declare function createServer(vaultPath: string, options?: CreateServerOptions): Server;
+//# sourceMappingURL=createServer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createServer.d.ts","sourceRoot":"","sources":["../../src/createServer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAMnE,OAAO,EAAE,kBAAkB,EAAoB,MAAM,kBAAkB,CAAC;AACxE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAI7C,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;CACzC;AAED,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB,GAAG,MAAM,CA4XzF"}