obsidian-mcp-server 1.2.3 → 1.2.5

package/build/resources.js

@@ -0,0 +1,111 @@
+import { PropertyManager } from "./properties.js";
+export class TagResource {
+    client;
+    static TAG_PATTERN = /#[a-zA-Z0-9_-]+/g;
+    tagCache = new Map();
+    propertyManager;
+    isInitialized = false;
+    lastUpdate = 0;
+    updateInterval = 5000; // 5 seconds
+    constructor(client) {
+        this.client = client;
+        this.propertyManager = new PropertyManager(client);
+        this.initializeCache();
+    }
+    getResourceDescription() {
+        return {
+            uri: "obsidian://tags",
+            name: "Obsidian Tags",
+            description: "List of all tags used across the Obsidian vault with their usage counts",
+            mimeType: "application/json"
+        };
+    }
+    async initializeCache() {
+        try {
+            // Get all markdown files
+            const query = {
+                "glob": ["**/*.md", { "var": "path" }]
+            };
+            const results = await this.client.searchJson(query);
+            this.tagCache.clear();
+            // Process each file
+            for (const result of results) {
+                if (!('filename' in result))
+                    continue;
+                try {
+                    const content = await this.client.getFileContents(result.filename);
+                    // Extract tags from frontmatter
+                    const properties = this.propertyManager.parseProperties(content);
+                    if (properties.tags) {
+                        properties.tags.forEach((tag) => {
+                            this.addTag(tag, result.filename);
+                        });
+                    }
+                    // Extract inline tags
+                    const inlineTags = content.match(TagResource.TAG_PATTERN) || [];
+                    inlineTags.forEach(tag => {
+                        this.addTag(tag, result.filename);
+                    });
+                }
+                catch (error) {
+                    console.error(`Failed to process file ${result.filename}:`, error);
+                }
+            }
+            this.isInitialized = true;
+            this.lastUpdate = Date.now();
+        }
+        catch (error) {
+            console.error("Failed to initialize tag cache:", error);
+            throw error;
+        }
+    }
+    addTag(tag, filepath) {
+        if (!this.tagCache.has(tag)) {
+            this.tagCache.set(tag, new Set());
+        }
+        this.tagCache.get(tag).add(filepath);
+    }
+    async updateCacheIfNeeded() {
+        const now = Date.now();
+        if (now - this.lastUpdate > this.updateInterval) {
+            await this.initializeCache();
+        }
+    }
+    async getContent() {
+        try {
+            if (!this.isInitialized) {
+                await this.initializeCache();
+            }
+            else {
+                await this.updateCacheIfNeeded();
+            }
+            const response = {
+                tags: Array.from(this.tagCache.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: Array.from(this.tagCache.values())
+                        .reduce((sum, files) => sum + files.size, 0),
+                    uniqueTags: this.tagCache.size,
+                    scannedFiles: new Set(Array.from(this.tagCache.values())
+                        .flatMap(files => Array.from(files))).size,
+                    lastUpdate: this.lastUpdate
+                }
+            };
+            return [{
+                    type: "text",
+                    text: JSON.stringify(response, null, 2),
+                    uri: this.getResourceDescription().uri
+                }];
+        }
+        catch (error) {
+            console.error("Failed to get tags:", error);
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=resources.js.map

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