obsidian-mcp-server 1.3.0 → 1.4.0

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

package/build/{properties.js → tools/properties/manager.js}

@@ -1,6 +1,15 @@
+/**
+ * Property manager for Obsidian notes
+ */
 import { parse, stringify } from 'yaml';
 import { EOL } from 'os';
-import { ObsidianPropertiesSchema, PropertyUpdateSchema } from './propertyTypes.js';
+import { createLogger } from '../../utils/logging.js';
+import { ObsidianPropertiesSchema, PropertyUpdateSchema } from './types.js';
+// Create a logger for property operations
+const logger = createLogger('PropertyManager');
+/**
+ * Manages YAML frontmatter properties in Obsidian notes
+ */
 export class PropertyManager {
     client;
     constructor(client) {
@@ -8,15 +17,18 @@ export class PropertyManager {
     }
     /**
      * Parse YAML frontmatter from note content
+     * @param content The note content
+     * @returns Extracted properties
      */
     parseProperties(content) {
         try {
             // Extract frontmatter between --- markers (handles both \n and \r\n)
-            const match = content.match(/^---(\r?\n)([\s\S]*?)\r?\n---/);
+            const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
             if (!match) {
+                logger.debug('No frontmatter found in content');
                 return {};
             }
-            const frontmatter = match[2];
+            const frontmatter = match[1];
             const properties = parse(frontmatter);
             // Handle tags - don't add # prefix in frontmatter
             if (properties.tags && Array.isArray(properties.tags)) {
@@ -25,19 +37,21 @@ export class PropertyManager {
             // Validate against schema
             const result = ObsidianPropertiesSchema.safeParse(properties);
             if (!result.success) {
-                console.warn('Property validation warnings:', result.error);
+                logger.warn('Property validation warnings:', result.error);
                 // Return the properties with fixed tags
                 return properties;
             }
             return result.data;
         }
         catch (error) {
-            console.error('Error parsing properties:', error);
+            logger.error('Error parsing properties:', error);
             return {};
         }
     }
     /**
      * Generate YAML frontmatter from properties
+     * @param properties The properties to convert to YAML
+     * @returns YAML frontmatter string
      */
     generateProperties(properties) {
         try {
@@ -48,12 +62,14 @@ export class PropertyManager {
             return `---${EOL}${yaml}---${EOL}`;
         }
         catch (error) {
-            console.error('Error generating properties:', error);
+            logger.error('Error generating properties:', error);
             throw error;
         }
     }
     /**
-     * Validate property values
+     * Validate property values against schema
+     * @param properties The properties to validate
+     * @returns Validation result
      */
     validateProperties(properties) {
         const result = PropertyUpdateSchema.safeParse(properties);
@@ -67,6 +83,10 @@ export class PropertyManager {
     }
     /**
      * Merge new properties with existing ones
+     * @param existing The existing properties
+     * @param updates The new properties to merge
+     * @param replace Whether to replace arrays instead of merging them
+     * @returns The merged properties
      */
     mergeProperties(existing, updates, replace = false) {
         const merged = { ...existing };
@@ -99,9 +119,12 @@ export class PropertyManager {
     }
     /**
      * Get properties from a note
+     * @param filepath Path to the note
+     * @returns The properties from the note
      */
     async getProperties(filepath) {
         try {
+            logger.debug(`Getting properties from file: ${filepath}`);
             const content = await this.client.getFileContents(filepath);
             const properties = this.parseProperties(content);
             return {
@@ -111,6 +134,7 @@ export class PropertyManager {
             };
         }
         catch (error) {
+            logger.error(`Failed to get properties from ${filepath}:`, error);
             return {
                 success: false,
                 message: `Failed to get properties: ${error instanceof Error ? error.message : String(error)}`,
@@ -120,12 +144,17 @@ export class PropertyManager {
     }
     /**
      * Update properties of a note
+     * @param filepath Path to the note
+     * @param newProperties The new properties to apply
+     * @param replace Whether to replace arrays instead of merging them
+     * @returns The result of the update operation
      */
     async updateProperties(filepath, newProperties, replace = false) {
         try {
             // Validate new properties
             const validation = this.validateProperties(newProperties);
             if (!validation.valid) {
+                logger.warn(`Invalid properties for ${filepath}:`, validation.errors);
                 return {
                     success: false,
                     message: 'Invalid properties',
@@ -133,6 +162,7 @@ export class PropertyManager {
                 };
             }
             // Get existing content and properties
+            logger.debug(`Updating properties for file: ${filepath}`);
             const content = await this.client.getFileContents(filepath);
             const existingProperties = this.parseProperties(content);
             // Merge properties
@@ -144,6 +174,7 @@ export class PropertyManager {
             const updatedContent = newFrontmatter + newContent;
             // Update file
             await this.client.updateContent(filepath, updatedContent);
+            logger.debug(`Successfully updated properties for ${filepath}`);
             return {
                 success: true,
                 message: 'Properties updated successfully',
@@ -151,6 +182,7 @@ export class PropertyManager {
             };
         }
         catch (error) {
+            logger.error(`Failed to update properties for ${filepath}:`, error);
             return {
                 success: false,
                 message: `Failed to update properties: ${error instanceof Error ? error.message : String(error)}`,
@@ -159,4 +191,4 @@ export class PropertyManager {
         }
     }
 }
-//# sourceMappingURL=properties.js.map
+//# sourceMappingURL=manager.js.map

package/build/{propertyTools.js → tools/properties/tools.js}

@@ -1,13 +1,22 @@
-import { BaseToolHandler } from "./tools.js";
-import { PropertyManager } from "./properties.js";
-const TOOL_NAMES = {
+import { BaseToolHandler } from "../base.js";
+import { PropertyManager } from "./manager.js";
+import { createLogger } from "../../utils/logging.js";
+// Create a logger for property tools
+const logger = createLogger('PropertyTools');
+/**
+ * Tool names for property operations
+ */
+export const PROPERTY_TOOL_NAMES = {
     GET_PROPERTIES: "obsidian_get_properties",
     UPDATE_PROPERTIES: "obsidian_update_properties"
 };
+/**
+ * Tool handler for getting properties from a note
+ */
 export class GetPropertiesToolHandler extends BaseToolHandler {
     propertyManager;
     constructor(client) {
-        super(TOOL_NAMES.GET_PROPERTIES, client);
+        super(PROPERTY_TOOL_NAMES.GET_PROPERTIES, client);
         this.propertyManager = new PropertyManager(client);
     }
     getToolDescription() {
@@ -43,18 +52,23 @@ export class GetPropertiesToolHandler extends BaseToolHandler {
     }
     async runTool(args) {
         try {
+            logger.debug(`Getting properties from: ${args.filepath}`);
             const result = await this.propertyManager.getProperties(args.filepath);
             return this.createResponse(result);
         }
         catch (error) {
+            logger.error(`Error getting properties from ${args.filepath}:`, error);
             return this.handleError(error);
         }
     }
 }
+/**
+ * Tool handler for updating properties in a note
+ */
 export class UpdatePropertiesToolHandler extends BaseToolHandler {
     propertyManager;
     constructor(client) {
-        super(TOOL_NAMES.UPDATE_PROPERTIES, client);
+        super(PROPERTY_TOOL_NAMES.UPDATE_PROPERTIES, client);
         this.propertyManager = new PropertyManager(client);
     }
     getToolDescription() {
@@ -164,12 +178,14 @@ export class UpdatePropertiesToolHandler extends BaseToolHandler {
     }
     async runTool(args) {
         try {
+            logger.debug(`Updating properties for: ${args.filepath}`);
             const result = await this.propertyManager.updateProperties(args.filepath, args.properties, args.replace);
             return this.createResponse(result);
         }
         catch (error) {
+            logger.error(`Error updating properties for ${args.filepath}:`, error);
             return this.handleError(error);
         }
     }
 }
-//# sourceMappingURL=propertyTools.js.map
+//# sourceMappingURL=tools.js.map