@mauricio.wolff/mcp-obsidian 0.3.0

package/server.ts

@@ -0,0 +1,516 @@
+#!/usr/bin/env bun
+
+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 } from "./src/frontmatter.js";
+import { PathFilter } from "./src/pathfilter.js";
+import { SearchService } from "./src/search.js";
+
+const vaultPath = process.argv[2];
+if (!vaultPath) {
+  console.error("Usage: bun server.ts /path/to/vault");
+  process.exit(1);
+}
+
+// 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: "mcp-obsidian",
+  version: "0.3.0"
+}, {
+  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"
+            }
+          },
+          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: "list_directory",
+        description: "List files and directories in the vault",
+        inputSchema: {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: "Path relative to vault root (default: '/')",
+              default: "/"
+            }
+          }
+        }
+      },
+      {
+        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
+            }
+          },
+          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: "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
+            }
+          },
+          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"
+            }
+          },
+          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"
+            }
+          },
+          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"]
+        }
+      }
+    ]
+  };
+});
+
+// Helper function to trim path arguments
+function trimPaths(args: any): any {
+  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();
+  }
+
+  // Trim path arrays
+  if (trimmed.paths && Array.isArray(trimmed.paths)) {
+    trimmed.paths = trimmed.paths.map((p: any) =>
+      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);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                path: trimmedArgs.path,
+                frontmatter: note.frontmatter,
+                content: note.content
+              }, null, 2)
+            }
+          ]
+        };
+      }
+
+      case "write_note": {
+        await fileSystem.writeNote({
+          path: trimmedArgs.path,
+          content: trimmedArgs.content,
+          frontmatter: trimmedArgs.frontmatter,
+          mode: trimmedArgs.mode || 'overwrite'
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Successfully wrote note: ${trimmedArgs.path} (mode: ${trimmedArgs.mode || 'overwrite'})`
+            }
+          ]
+        };
+      }
+
+      case "list_directory": {
+        const listing = await fileSystem.listDirectory(trimmedArgs.path || '');
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                path: trimmedArgs.path || '/',
+                directories: listing.directories,
+                files: listing.files
+              }, null, 2)
+            }
+          ]
+        };
+      }
+
+      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
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                query: trimmedArgs.query,
+                resultCount: results.length,
+                results: results
+              }, null, 2)
+            }
+          ]
+        };
+      }
+
+      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 "read_multiple_notes": {
+        const result = await fileSystem.readMultipleNotes({
+          paths: trimmedArgs.paths,
+          includeContent: trimmedArgs.includeContent,
+          includeFrontmatter: trimmedArgs.includeFrontmatter
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                successful: result.successful,
+                failed: result.failed,
+                summary: {
+                  successCount: result.successful.length,
+                  failureCount: result.failed.length
+                }
+              }, null, 2)
+            }
+          ]
+        };
+      }
+
+      case "update_frontmatter": {
+        await fileSystem.updateFrontmatter({
+          path: trimmedArgs.path,
+          frontmatter: trimmedArgs.frontmatter,
+          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);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                notes: result,
+                count: result.length
+              }, null, 2)
+            }
+          ]
+        };
+      }
+
+      case "get_frontmatter": {
+        const note = await fileSystem.readNote(trimmedArgs.path);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                path: trimmedArgs.path,
+                frontmatter: note.frontmatter
+              }, null, 2)
+            }
+          ]
+        };
+      }
+
+      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
+        };
+      }
+
+      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 transport = new StdioServerTransport();
+await server.connect(transport);