obsidian-mcp-server 1.2.2 → 1.2.4

package/build/server.js

@@ -1,10 +1,11 @@
 import { config } from "dotenv";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { ObsidianClient } from "./obsidian.js";
 import { ObsidianError, DEFAULT_RATE_LIMIT_CONFIG } from "./types.js";
-import { ListFilesInVaultToolHandler, ListFilesInDirToolHandler, GetFileContentsToolHandler, FindInFileToolHandler, AppendContentToolHandler, PatchContentToolHandler, ComplexSearchToolHandler } from "./tools.js";
+import { TagResource } from "./resources.js";
+import { ListFilesInVaultToolHandler, ListFilesInDirToolHandler, GetFileContentsToolHandler, FindInFileToolHandler, AppendContentToolHandler, PatchContentToolHandler, ComplexSearchToolHandler, GetTagsToolHandler } from "./tools.js";
 import { GetPropertiesToolHandler, UpdatePropertiesToolHandler } from "./propertyTools.js";
 // Load environment variables
 config();
@@ -60,9 +61,12 @@ const handlers = [
     new PatchContentToolHandler(client),
     new ComplexSearchToolHandler(client),
     new GetPropertiesToolHandler(client),
-    new UpdatePropertiesToolHandler(client)
+    new UpdatePropertiesToolHandler(client),
+    new GetTagsToolHandler(client)
 ];
 handlers.forEach(handler => toolHandlers.set(handler.name, handler));
+// Initialize resources
+const tagResource = new TagResource(client);
 // Create MCP server
 const server = new Server({
     name: "obsidian-mcp-server",
@@ -70,10 +74,26 @@ const server = new Server({
 }, {
     capabilities: {
         tools: {},
-        resources: {}
+        resources: {
+            [tagResource.getResourceDescription().uri]: tagResource
+        }
+    }
+});
+// Set up resource handlers
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return {
+        resources: [tagResource.getResourceDescription()]
+    };
+});
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    if (request.params.uri === tagResource.getResourceDescription().uri) {
+        return {
+            contents: await tagResource.getContent()
+        };
     }
+    throw new ObsidianError(`Resource not found: ${request.params.uri}`, 40400); // 40400 = Not found
 });
-// Set up request handlers
+// Set up tool handlers
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     const tools = [];
     for (const handler of toolHandlers.values()) {
@@ -141,17 +161,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     const handler = toolHandlers.get(name);
     if (!handler) {
-        throw new ObsidianError(`Unknown tool: ${name}`, 404);
+        throw new ObsidianError(`Unknown tool: ${name}`, 40400); // 40400 = Not found
     }
     // Check rate limit
     if (!checkRateLimit(name)) {
-        throw new ObsidianError(`Rate limit exceeded for tool: ${name}. Please try again later.`, 429);
+        throw new ObsidianError(`Rate limit exceeded for tool: ${name}. Please try again later.`, 42900 // 42900 = Rate limit exceeded
+        );
     }
     // Add timeout handling
     const timeoutMs = parseInt(process.env.TOOL_TIMEOUT_MS ?? '60000'); // 60 second default timeout
     const timeoutPromise = new Promise((_, reject) => {
         setTimeout(() => {
-            reject(new ObsidianError(`Tool execution timed out after ${timeoutMs}ms`, 408));
+            reject(new ObsidianError(`Tool execution timed out after ${timeoutMs}ms`, 40800)); // 40800 = Request timeout
         }, timeoutMs);
     });
     try {
@@ -159,7 +180,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const toolDescription = handler.getToolDescription();
         const validationResult = validateToolArguments(args, toolDescription.inputSchema);
         if (!validationResult.valid) {
-            throw new ObsidianError(`Invalid tool arguments: ${validationResult.errors.join(', ')}`, 400);
+            throw new ObsidianError(`Invalid tool arguments: ${validationResult.errors.join(', ')}`, 40000 // 40000 = Bad request
+            );
         }
         // Race between tool execution and timeout
         const content = await Promise.race([
@@ -171,7 +193,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     catch (error) {
         if (error instanceof ObsidianError) {
             // Check if the operation actually succeeded despite the error
-            if (error.code === 204) {
+            if (error.errorCode === 20400) { // 20400 = Success with no content
                 return {
                     content: [{
                             type: "text",
@@ -190,9 +212,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             args
         });
         if (error instanceof Error) {
-            throw new ObsidianError(`Tool '${name}' execution failed: ${error.message}`, 500, { originalError: error.stack });
+            throw new ObsidianError(`Tool '${name}' execution failed: ${error.message}`, 50000, // 50000 = Internal server error
+            { originalError: error.stack });
         }
-        throw new ObsidianError("Tool execution failed with unknown error", 500, { error });
+        throw new ObsidianError("Tool execution failed with unknown error", 50000, // 50000 = Internal server error
+        { error });
     }
 });
 // Error handler

package/build/tools.js

@@ -1,5 +1,6 @@
 import { encoding_for_model } from "tiktoken";
 import { ObsidianError } from "./types.js";
+import { PropertyManager } from "./properties.js";
 const TOOL_NAMES = {
     LIST_FILES_IN_VAULT: "obsidian_list_files_in_vault",
     LIST_FILES_IN_DIR: "obsidian_list_files_in_dir",
@@ -7,7 +8,8 @@ const TOOL_NAMES = {
     FIND_IN_FILE: "obsidian_find_in_file",
     APPEND_CONTENT: "obsidian_append_content",
     PATCH_CONTENT: "obsidian_patch_content",
-    COMPLEX_SEARCH: "obsidian_complex_search"
+    COMPLEX_SEARCH: "obsidian_complex_search",
+    GET_TAGS: "obsidian_get_tags"
 };
 // Load token limits from environment or use defaults
 const MAX_TOKENS = parseInt(process.env.MAX_TOKENS ?? '20000');
@@ -259,7 +261,7 @@ export class FindInFileToolHandler extends BaseToolHandler {
     getToolDescription() {
         return {
             name: this.name,
-            description: "Full-text search across all files in the vault. Returns matching files with surrounding context for each match. Useful for finding specific content, references, or patterns across notes.",
+            description: "Full-text search across all files in the vault. Returns matching files with surrounding context for each match. For results with more than 5 matching files, returns only file names and match counts to prevent overwhelming responses. Useful for finding specific content, references, or patterns across notes.",
             examples: [
                 {
                     description: "Search for a specific term",
@@ -273,17 +275,39 @@ export class FindInFileToolHandler extends BaseToolHandler {
                     args: {
                         query: "#todo"
                     },
-                    response: [
-                        {
-                            "filename": "Projects/AI.md",
-                            "matches": [
-                                {
-                                    "context": "Research needed:\n#todo Implement transformer architecture\nDeadline: Next week",
-                                    "match": { "start": 15, "end": 45 }
-                                }
-                            ]
-                        }
-                    ]
+                    response: {
+                        "message": "Found 1 file with matches:",
+                        "results": [
+                            {
+                                "filename": "Projects/AI.md",
+                                "matches": [
+                                    {
+                                        "context": "Research needed:\n#todo Implement transformer architecture\nDeadline: Next week",
+                                        "match": { "start": 15, "end": 45 }
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                },
+                {
+                    description: "Example response with many matches (file-only format)",
+                    args: {
+                        query: "API"
+                    },
+                    response: {
+                        "message": "Found 92 files with matches. Showing file names only:",
+                        "results": [
+                            {
+                                "filename": "Developer/Documentation/API.md",
+                                "matchCount": 43
+                            },
+                            {
+                                "filename": "Projects/API_Design.md",
+                                "matchCount": 34
+                            }
+                        ]
+                    }
                 }
             ],
             inputSchema: {
@@ -305,10 +329,34 @@ export class FindInFileToolHandler extends BaseToolHandler {
     }
     async runTool(args) {
         try {
-            const results = await this.client.search(args.query, args.contextLength);
-            // Extract only unique filenames from search results
-            const filenames = [...new Set(results.map(result => result.filename))].sort();
-            return this.createResponse(filenames);
+            const results = await this.client.search(args.query, args.contextLength ?? 100);
+            // If more than 5 results, only return filenames
+            if (results.length > 5) {
+                const fileOnlyResults = results.map(result => ({
+                    filename: result.filename,
+                    matchCount: result.matches.length
+                }));
+                return this.createResponse({
+                    message: `Found ${results.length} files with matches. Showing file names only:`,
+                    results: fileOnlyResults
+                });
+            }
+            // Otherwise return full context as before
+            const formattedResults = results.map(result => ({
+                filename: result.filename,
+                matches: result.matches.map(match => ({
+                    context: match.context,
+                    match: {
+                        text: match.context.substring(match.match.start, match.match.end),
+                        position: {
+                            start: match.match.start,
+                            end: match.match.end
+                        }
+                    }
+                })),
+                score: result.score
+            }));
+            return this.createResponse(formattedResults);
         }
         catch (error) {
             return this.handleError(error);
@@ -417,46 +465,21 @@ export class ComplexSearchToolHandler extends BaseToolHandler {
     getToolDescription() {
         return {
             name: this.name,
-            description: "Advanced search functionality using JsonLogic queries. Enables complex file filtering based on paths, metadata, modification times, and content patterns. Supports logical operations, date comparisons, and pattern matching.",
+            description: "File path pattern matching using JsonLogic queries. Supported operations:\n- glob: Pattern matching for paths (e.g., \"*.md\")\n- Variable access: {\"var\": \"path\"}\n\nNote: For full-text content search, date-based searches, or other advanced queries, use obsidian_find_in_file instead.",
             examples: [
                 {
-                    description: "Find markdown files in a specific folder",
+                    description: "Find markdown files in Projects folder",
                     args: {
                         query: {
-                            "and": [
-                                { "glob": ["Projects/*.md", { "var": "path" }] },
-                                { "contains": [{ "var": "content" }, "#active"] }
-                            ]
+                            "glob": ["Projects/*.md", { "var": "path" }]
                         }
                     }
                 },
                 {
-                    description: "Find recently modified documentation",
+                    description: "Find files in a specific subfolder",
                     args: {
                         query: {
-                            "and": [
-                                { "glob": ["docs/*.md", { "var": "path" }] },
-                                { ">=": [
-                                        { "var": "mtime" },
-                                        { "date": "-7 days" }
-                                    ] },
-                                { "!=": [{ "var": "size" }, 0] }
-                            ]
-                        }
-                    }
-                },
-                {
-                    description: "Find files by multiple criteria",
-                    args: {
-                        query: {
-                            "and": [
-                                { "or": [
-                                        { "glob": ["*.md", { "var": "path" }] },
-                                        { "glob": ["*.txt", { "var": "path" }] }
-                                    ] },
-                                { "contains": [{ "var": "content" }, "TODO"] },
-                                { "<": [{ "var": "size" }, 10000] }
-                            ]
+                            "glob": ["**/Test/*.md", { "var": "path" }]
                         }
                     }
                 }
@@ -475,12 +498,365 @@ export class ComplexSearchToolHandler extends BaseToolHandler {
     }
     async runTool(args) {
         try {
+            // Perform search
             const results = await this.client.searchJson(args.query);
-            return this.createResponse(results);
+            console.debug('Search results:', results);
+            // Format response based on result type
+            const formattedResults = results.map(result => {
+                if ('matches' in result) {
+                    // SimpleSearchResult
+                    return {
+                        filename: result.filename,
+                        matches: result.matches,
+                        score: result.score
+                    };
+                }
+                else {
+                    // SearchResult
+                    return {
+                        filename: result.filename,
+                        result: result.result
+                    };
+                }
+            });
+            return this.createResponse(formattedResults);
+        }
+        catch (error) {
+            console.error('Complex search error:', error);
+            return this.handleError(error);
+        }
+    }
+}
+export class GetTagsToolHandler extends BaseToolHandler {
+    static TAG_PATTERN = /#[a-zA-Z0-9_-]+/g;
+    propertyManager;
+    constructor(client) {
+        super(TOOL_NAMES.GET_TAGS, client);
+        this.propertyManager = new PropertyManager(client);
+    }
+    getToolDescription() {
+        return {
+            name: this.name,
+            description: "Get all tags used across the Obsidian vault with their usage counts. Optionally filter tags within a specific folder.",
+            examples: [
+                {
+                    description: "Get all tags in vault",
+                    args: {}
+                },
+                {
+                    description: "Get tags in Projects folder",
+                    args: {
+                        path: "Projects"
+                    }
+                },
+                {
+                    description: "Example response",
+                    args: {},
+                    response: {
+                        "tags": [
+                            {
+                                "name": "#project",
+                                "count": 15,
+                                "files": [
+                                    "Projects/ProjectA.md",
+                                    "Projects/ProjectB.md"
+                                ]
+                            }
+                        ],
+                        "metadata": {
+                            "totalOccurrences": 45,
+                            "uniqueTags": 12,
+                            "scannedFiles": 30
+                        }
+                    }
+                }
+            ],
+            inputSchema: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "Optional path to limit tag search to specific folder",
+                        format: "path"
+                    }
+                }
+            }
+        };
+    }
+    async processFiles(files, basePath, tagMap) {
+        let scannedFiles = 0;
+        for (const file of files) {
+            const fullPath = basePath ? `${basePath}/${file.path}` : file.path;
+            if (file.type === "folder" && file.children) {
+                // Recursively process subdirectories
+                scannedFiles += await this.processFiles(file.children, fullPath, tagMap);
+            }
+            else if (file.type === "file" && file.path.endsWith('.md')) {
+                // Process markdown files
+                scannedFiles++;
+                const content = await this.client.getFileContents(fullPath);
+                // Extract tags from frontmatter
+                const properties = this.propertyManager.parseProperties(content);
+                if (properties.tags) {
+                    properties.tags.forEach((tag) => {
+                        if (!tagMap.has(tag)) {
+                            tagMap.set(tag, new Set());
+                        }
+                        tagMap.get(tag).add(fullPath);
+                    });
+                }
+                // Extract inline tags using regex
+                const inlineTags = content.match(GetTagsToolHandler.TAG_PATTERN) || [];
+                inlineTags.forEach(tag => {
+                    if (!tagMap.has(tag)) {
+                        tagMap.set(tag, new Set());
+                    }
+                    tagMap.get(tag).add(fullPath);
+                });
+            }
+        }
+        return scannedFiles;
+    }
+    async runTool(args) {
+        try {
+            const tagMap = new Map();
+            const basePath = args.path || '';
+            // Get files from vault or specific directory
+            const files = args.path
+                ? await this.client.listFilesInDir(args.path)
+                : await this.client.listFilesInVault();
+            // Process files recursively
+            const scannedFiles = await this.processFiles(files, basePath, tagMap);
+            // Calculate total occurrences
+            const totalOccurrences = Array.from(tagMap.values())
+                .reduce((sum, files) => sum + files.size, 0);
+            const response = {
+                tags: Array.from(tagMap.entries())
+                    .map(([name, files]) => ({
+                    name,
+                    count: files.size,
+                    files: Array.from(files).sort()
+                }))
+                    .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name)),
+                metadata: {
+                    totalOccurrences,
+                    uniqueTags: tagMap.size,
+                    scannedFiles
+                }
+            };
+            return this.createResponse(response);
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+// Export all handlers
+export class ListCommandsToolHandler extends BaseToolHandler {
+    constructor(client) {
+        super("obsidian_list_commands", client);
+    }
+    getToolDescription() {
+        return {
+            name: this.name,
+            description: "Get a list of available commands that can be executed in Obsidian.",
+            examples: [
+                {
+                    description: "List all available commands",
+                    args: {}
+                }
+            ],
+            inputSchema: {
+                type: "object",
+                properties: {},
+                required: []
+            }
+        };
+    }
+    async runTool() {
+        try {
+            const commands = await this.client.listCommands();
+            return this.createResponse(commands);
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+export class ExecuteCommandToolHandler extends BaseToolHandler {
+    constructor(client) {
+        super("obsidian_execute_command", client);
+    }
+    getToolDescription() {
+        return {
+            name: this.name,
+            description: "Execute a specific command in Obsidian by its ID.",
+            examples: [
+                {
+                    description: "Execute the graph view command",
+                    args: {
+                        commandId: "graph:open"
+                    }
+                }
+            ],
+            inputSchema: {
+                type: "object",
+                properties: {
+                    commandId: {
+                        type: "string",
+                        description: "The ID of the command to execute"
+                    }
+                },
+                required: ["commandId"]
+            }
+        };
+    }
+    async runTool(args) {
+        try {
+            await this.client.executeCommand(args.commandId);
+            return this.createResponse({ message: `Successfully executed command: ${args.commandId}` });
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+export class OpenFileToolHandler extends BaseToolHandler {
+    constructor(client) {
+        super("obsidian_open_file", client);
+    }
+    getToolDescription() {
+        return {
+            name: this.name,
+            description: "Open a specific file in Obsidian, optionally in a new leaf.",
+            examples: [
+                {
+                    description: "Open a file in the current leaf",
+                    args: {
+                        filepath: "Projects/research.md"
+                    }
+                },
+                {
+                    description: "Open a file in a new leaf",
+                    args: {
+                        filepath: "Projects/research.md",
+                        newLeaf: true
+                    }
+                }
+            ],
+            inputSchema: {
+                type: "object",
+                properties: {
+                    filepath: {
+                        type: "string",
+                        description: "Path to the file to open (relative to vault root)",
+                        format: "path"
+                    },
+                    newLeaf: {
+                        type: "boolean",
+                        description: "Whether to open the file in a new leaf",
+                        default: false
+                    }
+                },
+                required: ["filepath"]
+            }
+        };
+    }
+    async runTool(args) {
+        try {
+            await this.client.openFile(args.filepath, args.newLeaf);
+            return this.createResponse({
+                message: `Successfully opened ${args.filepath}${args.newLeaf ? ' in new leaf' : ''}`
+            });
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+export class GetActiveFileToolHandler extends BaseToolHandler {
+    constructor(client) {
+        super("obsidian_get_active_file", client);
+    }
+    getToolDescription() {
+        return {
+            name: this.name,
+            description: "Get the content and metadata of the currently active file in Obsidian.",
+            examples: [
+                {
+                    description: "Get active file content",
+                    args: {}
+                }
+            ],
+            inputSchema: {
+                type: "object",
+                properties: {},
+                required: []
+            }
+        };
+    }
+    async runTool() {
+        try {
+            const activeFile = await this.client.getActiveFile();
+            return this.createResponse(activeFile);
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+export class GetPeriodicNoteToolHandler extends BaseToolHandler {
+    constructor(client) {
+        super("obsidian_get_periodic_note", client);
+    }
+    getToolDescription() {
+        return {
+            name: this.name,
+            description: "Get the content and metadata of a periodic note (daily, weekly, monthly, quarterly, or yearly).",
+            examples: [
+                {
+                    description: "Get today's daily note",
+                    args: {
+                        period: "daily"
+                    }
+                }
+            ],
+            inputSchema: {
+                type: "object",
+                properties: {
+                    period: {
+                        type: "string",
+                        enum: ["daily", "weekly", "monthly", "quarterly", "yearly"],
+                        description: "The type of periodic note to retrieve"
+                    }
+                },
+                required: ["period"]
+            }
+        };
+    }
+    async runTool(args) {
+        try {
+            const note = await this.client.getPeriodicNote(args.period);
+            return this.createResponse(note);
         }
         catch (error) {
             return this.handleError(error);
         }
     }
 }
+export const handlers = [
+    ListFilesInVaultToolHandler,
+    ListFilesInDirToolHandler,
+    GetFileContentsToolHandler,
+    FindInFileToolHandler,
+    AppendContentToolHandler,
+    PatchContentToolHandler,
+    ComplexSearchToolHandler,
+    GetTagsToolHandler,
+    ListCommandsToolHandler,
+    ExecuteCommandToolHandler,
+    OpenFileToolHandler,
+    GetActiveFileToolHandler,
+    GetPeriodicNoteToolHandler
+];
 //# sourceMappingURL=tools.js.map

package/build/types.js

@@ -8,13 +8,30 @@ export const DEFAULT_RATE_LIMIT_CONFIG = {
     maxRequests: 200
 };
 export class ObsidianError extends Error {
-    code;
     details;
-    constructor(message, code, details) {
+    errorCode;
+    constructor(message, errorCode = 50000, // Default server error code
+    details) {
         super(message);
-        this.code = code;
         this.details = details;
         this.name = "ObsidianError";
+        // Ensure 5-digit error code
+        if (errorCode < 10000 || errorCode > 99999) {
+            // Convert HTTP status codes to 5-digit codes
+            // 4xx -> 4xxxx
+            // 5xx -> 5xxxx
+            this.errorCode = errorCode < 1000 ? errorCode * 100 : 50000;
+        }
+        else {
+            this.errorCode = errorCode;
+        }
+    }
+    // Convert to API error format
+    toApiError() {
+        return {
+            errorCode: this.errorCode,
+            message: this.message
+        };
     }
 }
 //# sourceMappingURL=types.js.map