obsidian-mcp-server 1.2.3 → 1.2.5

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,366 @@ 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,
+                    lastUpdate: Date.now()
+                }
+            };
+            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

@@ -1,5 +1,5 @@
 export const DEFAULT_OBSIDIAN_CONFIG = {
-    protocol: "https",
+    protocol: "https", // HTTPS required by default in Obsidian REST API plugin
     host: "127.0.0.1",
     port: 27124
 };
@@ -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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-mcp-server",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "Model Context Protocol server for Obsidian integration with token-aware response handling",
   "main": "build/index.js",
   "type": "module",
@@ -18,7 +18,7 @@
     "format": "prettier --write \"src/**/*.ts\""
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.4.0",
+    "@modelcontextprotocol/sdk": "^1.4.1",
     "axios": "^1.7.9",
     "dotenv": "^16.4.7",
     "tiktoken": "^1.0.18",
@@ -29,7 +29,7 @@
     "@types/node": "^22.10.10",
     "@typescript-eslint/eslint-plugin": "^8.21.0",
     "@typescript-eslint/parser": "^8.21.0",
-    "eslint": "^9.18.0",
+    "eslint": "^9.19.0",
     "eslint-config-prettier": "^10.0.1",
     "eslint-plugin-prettier": "^5.2.3",
     "prettier": "^3.4.2",