obsidian-mcp-server 1.2.6 → 1.4.0

package/build/{resources.js → resources/tags.js}

@@ -1,7 +1,13 @@
-import { PropertyManager } from "./properties.js";
+import { PropertyManager } from "../tools/properties/manager.js";
+import { sep } from "path";
+import { createLogger } from "../utils/logging.js";
+// Create a logger for tag resources
+const logger = createLogger('TagResource');
+/**
+ * Resource for providing tags used in the Obsidian vault
+ */
 export class TagResource {
     client;
-    static TAG_PATTERN = /#[a-zA-Z0-9_-]+/g;
     tagCache = new Map();
     propertyManager;
     isInitialized = false;
@@ -12,6 +18,9 @@ export class TagResource {
         this.propertyManager = new PropertyManager(client);
         this.initializeCache();
     }
+    /**
+     * Get resource description for the MCP server
+     */
     getResourceDescription() {
         return {
             uri: "obsidian://tags",
@@ -20,11 +29,15 @@ export class TagResource {
             mimeType: "application/json"
         };
     }
+    /**
+     * Initialize the tag cache
+     */
     async initializeCache() {
         try {
-            // Get all markdown files
+            logger.info('Initializing tag cache');
+            // Get all markdown files using platform-agnostic path pattern
             const query = {
-                "glob": ["**/*.md", { "var": "path" }]
+                "glob": [`**${sep}*.md`.replace(/\\/g, '/'), { "var": "path" }]
             };
             const results = await this.client.searchJson(query);
             this.tagCache.clear();
@@ -34,46 +47,53 @@ export class TagResource {
                     continue;
                 try {
                     const content = await this.client.getFileContents(result.filename);
-                    // Extract tags from frontmatter
+                    // Only extract tags from frontmatter YAML
                     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);
+                    logger.error(`Failed to process file ${result.filename}:`, error);
                 }
             }
             this.isInitialized = true;
             this.lastUpdate = Date.now();
+            logger.info(`Tag cache initialized with ${this.tagCache.size} unique tags`);
         }
         catch (error) {
-            console.error("Failed to initialize tag cache:", error);
+            logger.error("Failed to initialize tag cache:", error);
             throw error;
         }
     }
+    /**
+     * Add a tag to the cache
+     */
     addTag(tag, filepath) {
         if (!this.tagCache.has(tag)) {
             this.tagCache.set(tag, new Set());
         }
         this.tagCache.get(tag).add(filepath);
     }
+    /**
+     * Update the cache if needed
+     */
     async updateCacheIfNeeded() {
         const now = Date.now();
         if (now - this.lastUpdate > this.updateInterval) {
+            logger.debug('Tag cache needs update, refreshing...');
             await this.initializeCache();
         }
     }
+    /**
+     * Get the content for the resource
+     */
     async getContent() {
         try {
             if (!this.isInitialized) {
+                logger.info('Tag cache not initialized, initializing now');
                 await this.initializeCache();
             }
             else {
@@ -96,6 +116,7 @@ export class TagResource {
                     lastUpdate: this.lastUpdate
                 }
             };
+            logger.debug(`Returning tag resource with ${response.tags.length} tags`);
             return [{
                     type: "text",
                     text: JSON.stringify(response, null, 2),
@@ -103,9 +124,9 @@ export class TagResource {
                 }];
         }
         catch (error) {
-            console.error("Failed to get tags:", error);
+            logger.error("Failed to get tags:", error);
             throw error;
         }
     }
 }
-//# sourceMappingURL=resources.js.map
+//# sourceMappingURL=tags.js.map

package/build/resources/types.js

@@ -0,0 +1,5 @@
+/**
+ * Resource types for the MCP server
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/build/tools/base.js

@@ -0,0 +1,78 @@
+import { ObsidianError } from "../utils/errors.js";
+import { tokenCounter } from "../utils/tokenization.js";
+import { createLogger } from "../utils/logging.js";
+// Create a logger for tool operations
+const logger = createLogger('Tools');
+/**
+ * Base class for all tool handlers with common functionality
+ */
+export class BaseToolHandler {
+    name;
+    client;
+    /**
+     * Create a new tool handler
+     * @param name The name of the tool
+     * @param client The ObsidianClient instance
+     */
+    constructor(name, client) {
+        this.name = name;
+        this.client = client;
+    }
+    /**
+     * Create a standardized response from any content type
+     * @param content The content to format for response
+     * @returns An array of TextContent objects
+     */
+    createResponse(content) {
+        let text;
+        // Handle different content types
+        if (typeof content === 'string') {
+            text = content;
+        }
+        else if (content instanceof Buffer) {
+            text = content.toString('utf-8');
+        }
+        else if (Array.isArray(content) && content.every(item => typeof item === 'string')) {
+            text = content.join('\n');
+        }
+        else if (content instanceof Error) {
+            text = `Error: ${content.message}\n${content.stack || ''}`;
+        }
+        else {
+            try {
+                text = JSON.stringify(content, null, 2);
+            }
+            catch (error) {
+                text = String(content);
+            }
+        }
+        // Count tokens and truncate if necessary
+        const originalTokenCount = tokenCounter.countTokens(text);
+        const truncatedText = tokenCounter.truncateToTokenLimit(text);
+        const finalTokenCount = tokenCounter.countTokens(truncatedText);
+        if (originalTokenCount > finalTokenCount) {
+            logger.debug(`[${this.name}] Response truncated:`, `original tokens=${originalTokenCount}`, `truncated tokens=${finalTokenCount}`);
+        }
+        return [{
+                type: "text",
+                text: truncatedText
+            }];
+    }
+    /**
+     * Standard error handling for tool execution
+     * @param error The error to handle
+     * @throws ObsidianError
+     */
+    handleError(error) {
+        if (error instanceof ObsidianError) {
+            throw error;
+        }
+        if (error instanceof Error) {
+            throw new ObsidianError(`Tool '${this.name}' execution failed: ${error.message}`, 50000, // Internal server error
+            { originalError: error.stack });
+        }
+        throw new ObsidianError(`Tool '${this.name}' execution failed with unknown error`, 50000, // Internal server error
+        { error });
+    }
+}
+//# sourceMappingURL=base.js.map

package/build/tools/files/content.js

@@ -0,0 +1,171 @@
+import { BaseToolHandler } from "../base.js";
+import { createLogger } from "../../utils/logging.js";
+// Create a logger for file content operations
+const logger = createLogger('FileContentTools');
+/**
+ * Tool names for file content operations
+ */
+export const FILE_CONTENT_TOOL_NAMES = {
+    GET_FILE_CONTENTS: "obsidian_get_file_contents",
+    APPEND_CONTENT: "obsidian_append_content",
+    PATCH_CONTENT: "obsidian_patch_content"
+};
+/**
+ * Tool handler for getting file contents
+ */
+export class GetFileContentsToolHandler extends BaseToolHandler {
+    constructor(client) {
+        super(FILE_CONTENT_TOOL_NAMES.GET_FILE_CONTENTS, client);
+    }
+    getToolDescription() {
+        return {
+            name: this.name,
+            description: "Return the content of a single file in your vault. Supports markdown files, text files, and other readable formats. Returns the raw content including any YAML frontmatter.",
+            examples: [
+                {
+                    description: "Get content of a markdown note",
+                    args: {
+                        filepath: "Projects/research.md"
+                    }
+                },
+                {
+                    description: "Get content of a configuration file",
+                    args: {
+                        filepath: "configs/settings.yml"
+                    }
+                }
+            ],
+            inputSchema: {
+                type: "object",
+                properties: {
+                    filepath: {
+                        type: "string",
+                        description: "Path to the relevant file (relative to your vault root).",
+                        format: "path"
+                    }
+                },
+                required: ["filepath"]
+            }
+        };
+    }
+    async runTool(args) {
+        try {
+            logger.debug(`Getting contents of file: ${args.filepath}`);
+            const content = await this.client.getFileContents(args.filepath);
+            return this.createResponse(content);
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+/**
+ * Tool handler for appending content to a file
+ */
+export class AppendContentToolHandler extends BaseToolHandler {
+    constructor(client) {
+        super(FILE_CONTENT_TOOL_NAMES.APPEND_CONTENT, client);
+    }
+    getToolDescription() {
+        return {
+            name: this.name,
+            description: "Append content to a new or existing file in the vault.",
+            examples: [
+                {
+                    description: "Append a new task",
+                    args: {
+                        filepath: "tasks.md",
+                        content: "- [ ] New task to complete"
+                    }
+                },
+                {
+                    description: "Append meeting notes",
+                    args: {
+                        filepath: "meetings/2025-01-23.md",
+                        content: "## Meeting Notes\n\n- Discussed project timeline\n- Assigned tasks"
+                    }
+                }
+            ],
+            inputSchema: {
+                type: "object",
+                properties: {
+                    filepath: {
+                        type: "string",
+                        description: "Path to the file (relative to vault root)",
+                        format: "path"
+                    },
+                    content: {
+                        type: "string",
+                        description: "Content to append to the file"
+                    }
+                },
+                required: ["filepath", "content"]
+            }
+        };
+    }
+    async runTool(args) {
+        try {
+            logger.debug(`Appending content to file: ${args.filepath}`);
+            await this.client.appendContent(args.filepath, args.content);
+            return this.createResponse({
+                message: `Successfully appended content to ${args.filepath}`,
+                success: true
+            });
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+/**
+ * Tool handler for updating file content
+ */
+export class PatchContentToolHandler extends BaseToolHandler {
+    constructor(client) {
+        super(FILE_CONTENT_TOOL_NAMES.PATCH_CONTENT, client);
+    }
+    getToolDescription() {
+        return {
+            name: this.name,
+            description: "Update the entire content of an existing note or create a new one.",
+            examples: [
+                {
+                    description: "Update a note's content",
+                    args: {
+                        filepath: "project.md",
+                        content: "# Project Notes\n\nThis will replace the entire content of the note."
+                    }
+                }
+            ],
+            inputSchema: {
+                type: "object",
+                properties: {
+                    filepath: {
+                        type: "string",
+                        description: "Path to the file (relative to vault root)",
+                        format: "path"
+                    },
+                    content: {
+                        type: "string",
+                        description: "New content for the note (replaces existing content)"
+                    }
+                },
+                required: ["filepath", "content"]
+            }
+        };
+    }
+    async runTool(args) {
+        try {
+            logger.debug(`Updating content of file: ${args.filepath}`);
+            await this.client.updateContent(args.filepath, args.content);
+            return this.createResponse({
+                message: `Successfully updated content in ${args.filepath}`,
+                success: true
+            });
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+//# sourceMappingURL=content.js.map

package/build/tools/files/index.js

@@ -0,0 +1,22 @@
+/**
+ * File operation tools exports
+ */
+export * from './list.js';
+export * from './content.js';
+import { ListFilesInVaultToolHandler, ListFilesInDirToolHandler } from './list.js';
+import { GetFileContentsToolHandler, AppendContentToolHandler, PatchContentToolHandler } from './content.js';
+/**
+ * Create all file-related tool handlers
+ * @param client The ObsidianClient instance
+ * @returns Array of file tool handlers
+ */
+export function createFileToolHandlers(client) {
+    return [
+        new ListFilesInVaultToolHandler(client),
+        new ListFilesInDirToolHandler(client),
+        new GetFileContentsToolHandler(client),
+        new AppendContentToolHandler(client),
+        new PatchContentToolHandler(client)
+    ];
+}
+//# sourceMappingURL=index.js.map

package/build/tools/files/list.js

@@ -0,0 +1,133 @@
+import { BaseToolHandler } from "../base.js";
+import { createLogger } from "../../utils/logging.js";
+// Create a logger for file operations
+const logger = createLogger('FileTools');
+/**
+ * Tool names for file listing operations
+ */
+export const FILE_TOOL_NAMES = {
+    LIST_FILES_IN_VAULT: "obsidian_list_files_in_vault",
+    LIST_FILES_IN_DIR: "obsidian_list_files_in_dir"
+};
+/**
+ * Tool handler for listing all files in the vault
+ */
+export class ListFilesInVaultToolHandler extends BaseToolHandler {
+    constructor(client) {
+        super(FILE_TOOL_NAMES.LIST_FILES_IN_VAULT, client);
+    }
+    getToolDescription() {
+        return {
+            name: this.name,
+            description: "Lists all files and directories in the root directory of your Obsidian vault. Returns a hierarchical structure of files and folders, including metadata like file type.",
+            examples: [
+                {
+                    description: "List all files in vault",
+                    args: {}
+                },
+                {
+                    description: "Example response",
+                    args: {},
+                    response: [
+                        {
+                            "path": "Daily Notes",
+                            "type": "folder",
+                            "children": [
+                                { "path": "Daily Notes/2025-01-24.md", "type": "file" }
+                            ]
+                        },
+                        {
+                            "path": "Projects",
+                            "type": "folder",
+                            "children": [
+                                { "path": "Projects/MCP.md", "type": "file" }
+                            ]
+                        }
+                    ]
+                }
+            ],
+            inputSchema: {
+                type: "object",
+                properties: {},
+                required: []
+            }
+        };
+    }
+    async runTool() {
+        try {
+            logger.debug('Listing all files in vault');
+            const files = await this.client.listFilesInVault();
+            return this.createResponse(files);
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+/**
+ * Tool handler for listing files in a specific directory
+ */
+export class ListFilesInDirToolHandler extends BaseToolHandler {
+    constructor(client) {
+        super(FILE_TOOL_NAMES.LIST_FILES_IN_DIR, client);
+    }
+    getToolDescription() {
+        return {
+            name: this.name,
+            description: "Lists all files and directories that exist in a specific Obsidian directory. Returns a hierarchical structure showing files, folders, and their relationships. Useful for exploring vault organization and finding specific files.",
+            examples: [
+                {
+                    description: "List files in Documents folder",
+                    args: {
+                        dirpath: "Documents"
+                    }
+                },
+                {
+                    description: "Example response structure",
+                    args: {
+                        dirpath: "Projects"
+                    },
+                    response: [
+                        {
+                            "path": "Projects/Active",
+                            "type": "folder",
+                            "children": [
+                                { "path": "Projects/Active/ProjectA.md", "type": "file" },
+                                { "path": "Projects/Active/ProjectB.md", "type": "file" }
+                            ]
+                        },
+                        {
+                            "path": "Projects/Archive",
+                            "type": "folder",
+                            "children": [
+                                { "path": "Projects/Archive/OldProject.md", "type": "file" }
+                            ]
+                        }
+                    ]
+                }
+            ],
+            inputSchema: {
+                type: "object",
+                properties: {
+                    dirpath: {
+                        type: "string",
+                        description: "Path to list files from (relative to your vault root). Note that empty directories will not be returned.",
+                        format: "path"
+                    }
+                },
+                required: ["dirpath"]
+            }
+        };
+    }
+    async runTool(args) {
+        try {
+            logger.debug(`Listing files in directory: ${args.dirpath}`);
+            const files = await this.client.listFilesInDir(args.dirpath);
+            return this.createResponse(files);
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+//# sourceMappingURL=list.js.map

package/build/tools/index.js

@@ -0,0 +1,31 @@
+import { createFileToolHandlers } from './files/index.js';
+import { createSearchToolHandlers } from './search/index.js';
+import { createPropertyToolHandlers } from './properties/index.js';
+// Export the base handler and all submodules
+export * from './base.js';
+export * from './files/index.js';
+export * from './search/index.js';
+export * from './properties/index.js';
+/**
+ * Create all tool handlers
+ * @param client The ObsidianClient instance
+ * @returns Array of all tool handlers
+ */
+export function createToolHandlers(client) {
+    return [
+        ...createFileToolHandlers(client),
+        ...createSearchToolHandlers(client),
+        ...createPropertyToolHandlers(client)
+    ];
+}
+/**
+ * Get a tool handler map by name
+ * @param handlers Array of tool handlers
+ * @returns Map of tool names to handlers
+ */
+export function createToolHandlerMap(handlers) {
+    const toolHandlerMap = new Map();
+    handlers.forEach(handler => toolHandlerMap.set(handler.name, handler));
+    return toolHandlerMap;
+}
+//# sourceMappingURL=index.js.map

package/build/tools/properties/index.js

@@ -0,0 +1,19 @@
+/**
+ * Properties module exports
+ */
+export * from './types.js';
+export * from './manager.js';
+export * from './tools.js';
+import { GetPropertiesToolHandler, UpdatePropertiesToolHandler } from './tools.js';
+/**
+ * Create all property-related tool handlers
+ * @param client The ObsidianClient instance
+ * @returns Array of property tool handlers
+ */
+export function createPropertyToolHandlers(client) {
+    return [
+        new GetPropertiesToolHandler(client),
+        new UpdatePropertiesToolHandler(client)
+    ];
+}
+//# sourceMappingURL=index.js.map