@mauricio.wolff/mcp-obsidian 0.4.1 → 0.5.1

package/README.md

@@ -6,16 +6,17 @@ A lightweight Model Context Protocol (MCP) server for safe Obsidian vault access
 
 ## Quick Start (5 minutes)
 
-1. **Install Bun runtime:**
+1. **Install Node.js runtime:**
    ```bash
-   curl -fsSL https://bun.sh/install | bash
+   # Download from https://nodejs.org (v18.0.0 or later)
+   # or use a package manager like nvm, brew, apt, etc.
    ```
 
 2. **Test the server:**
 
    If using the published package:
    ```bash
-   bunx @modelcontextprotocol/inspector bunx @mauricio.wolff/mcp-obsidian /path/to/your/vault
+   npx @modelcontextprotocol/inspector npx @mauricio.wolff/mcp-obsidian /path/to/your/vault
    ```
 
 3. **Configure your AI client:**
@@ -25,7 +26,7 @@ A lightweight Model Context Protocol (MCP) server for safe Obsidian vault access
    {
      "mcpServers": {
        "obsidian": {
-         "command": "bunx",
+         "command": "npx",
          "args": ["@mauricio.wolff/mcp-obsidian", "/path/to/your/vault"]
        }
      }
@@ -37,7 +38,7 @@ A lightweight Model Context Protocol (MCP) server for safe Obsidian vault access
    {
      "mcpServers": {
        "obsidian": {
-         "command": "bunx",
+         "command": "npx",
          "args": ["@mauricio.wolff/mcp-obsidian", "/path/to/your/vault"],
          "env": {}
        }
@@ -71,12 +72,12 @@ A lightweight Model Context Protocol (MCP) server for safe Obsidian vault access
 - ✅ **NEW:** Tag management: add, remove, and list tags in notes
 - ✅ Safe deletion with confirmation requirement to prevent accidents
 - ✅ Automatic path trimming to handle whitespace in inputs
-- ✅ TypeScript support with Bun runtime (no compilation needed)
+- ✅ TypeScript support with Node.js runtime (using tsx for execution)
 - ✅ Comprehensive error handling and validation
 
 ## Prerequisites
 
-- [Bun](https://bun.sh) runtime (v1.0.0 or later)
+- [Node.js](https://nodejs.org) runtime (v18.0.0 or later)
 - An Obsidian vault (local directory with `.md` files)
 - MCP-compatible AI client (Claude Desktop, ChatGPT Desktop, Claude Code, etc.)
 
@@ -84,23 +85,23 @@ A lightweight Model Context Protocol (MCP) server for safe Obsidian vault access
 
 ### For End Users (Recommended)
 
-No installation needed! Use `bunx` to run directly:
+No installation needed! Use `npx` to run directly:
 
 ```bash
-bunx @mauricio.wolff/mcp-obsidian /path/to/your/obsidian/vault
+npx @mauricio.wolff/mcp-obsidian /path/to/your/obsidian/vault
 ```
 
 ### For Developers
 
 1. Clone this repository
-2. Install dependencies with Bun:
+2. Install dependencies with npm:
 ```bash
-bun install
+npm install
 ```
 
 3. Test locally with MCP inspector:
 ```bash
-bunx @modelcontextprotocol/inspector bun server.ts /path/to/your/vault
+npx @modelcontextprotocol/inspector npm start /path/to/your/vault
 ```
 
 ## Usage
@@ -109,12 +110,12 @@ bunx @modelcontextprotocol/inspector bun server.ts /path/to/your/vault
 
 **End users:**
 ```bash
-bunx @mauricio.wolff/mcp-obsidian /path/to/your/obsidian/vault
+npx @mauricio.wolff/mcp-obsidian /path/to/your/obsidian/vault
 ```
 
 **Developers:**
 ```bash
-bun server.ts /path/to/your/obsidian/vault
+npm start /path/to/your/obsidian/vault
 ```
 
 ### AI Client Configuration
@@ -128,7 +129,7 @@ Add to your Claude Desktop configuration file:
 {
   "mcpServers": {
     "obsidian": {
-      "command": "bunx",
+      "command": "npx",
       "args": ["@mauricio.wolff/mcp-obsidian", "/Users/yourname/Documents/MyVault"]
     }
   }
@@ -140,11 +141,11 @@ Add to your Claude Desktop configuration file:
 {
   "mcpServers": {
     "obsidian-personal": {
-      "command": "bunx",
+      "command": "npx",
       "args": ["@mauricio.wolff/mcp-obsidian", "/Users/yourname/Documents/PersonalVault"]
     },
     "obsidian-work": {
-      "command": "bunx",
+      "command": "npx",
       "args": ["@mauricio.wolff/mcp-obsidian", "/Users/yourname/Documents/WorkVault"]
     }
   }
@@ -180,7 +181,7 @@ Edit `~/.claude.json`:
 {
   "mcpServers": {
     "obsidian": {
-      "command": "bunx",
+      "command": "npx",
       "args": ["@mauricio.wolff/mcp-obsidian", "/path/to/your/vault"],
       "env": {}
     }
@@ -196,7 +197,7 @@ Edit `.claude.json` in your project or add to the projects section:
     "/path/to/your/project": {
       "mcpServers": {
         "obsidian": {
-          "command": "bunx",
+          "command": "npx",
           "args": ["@mauricio.wolff/mcp-obsidian", "/path/to/your/vault"]
         }
       }
@@ -207,7 +208,7 @@ Edit `.claude.json` in your project or add to the projects section:
 
 **Using Claude Code CLI:**
 ```bash
-claude mcp add obsidian --scope user bunx @mauricio.wolff/mcp-obsidian /path/to/your/vault
+claude mcp add obsidian --scope user npx @mauricio.wolff/mcp-obsidian /path/to/your/vault
 ```
 
 #### Other MCP-Compatible Clients (2025)
@@ -241,11 +242,11 @@ Most modern MCP clients use similar JSON configuration patterns. Refer to your s
 
 ### Common Issues
 
-#### "command not found: bunx"
-- **Solution:** Install Bun runtime from [bun.sh](https://bun.sh)
-- **Alternative:** Use npm: `npx @mauricio.wolff/mcp-obsidian /path/to/vault`
+#### "command not found: npx"
+- **Solution:** Install Node.js runtime from [nodejs.org](https://nodejs.org)
+- **Alternative:** Use global install: `npm install -g @mauricio.wolff/mcp-obsidian`
 
-#### "Usage: bun server.ts /path/to/vault"
+#### "Usage: node server.ts /path/to/vault"
 - **Cause:** No vault path provided
 - **Solution:** Specify the full path to your Obsidian vault directory
 
@@ -272,20 +273,20 @@ Most modern MCP clients use similar JSON configuration patterns. Refer to your s
 
 Run with error logging:
 ```bash
-bunx @mauricio.wolff/mcp-obsidian /path/to/vault 2>debug.log
+npx @mauricio.wolff/mcp-obsidian /path/to/vault 2>debug.log
 ```
 
 ### Getting Help
 
 - [Open an issue](https://github.com/bitbonsai/mcp-obsidian/issues) on GitHub
-- Include your OS, Bun version, and error messages
+- Include your OS, Node.js version, and error messages
 - Provide the vault directory structure (without sensitive content)
 
 ## Testing
 
 Run the test suite:
 ```bash
-bun test
+npm test
 ```
 
 ## API Methods
@@ -691,7 +692,7 @@ This MCP server implements several security measures to protect your Obsidian va
 1. Fork the repository
 2. Create a feature branch: `git checkout -b feature-name`
 3. Make your changes and add tests
-4. Ensure all tests pass: `bun test`
+4. Ensure all tests pass: `npm test`
 5. Submit a pull request
 
 ## License

package/dist/server.js

@@ -0,0 +1,489 @@
+#!/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 } 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: npx @mauricio.wolff/mcp-obsidian /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.5.1"
+}, {
+    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) {
+    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) => 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);