obsidian-mcp-server 1.4.0 → 1.5.0

package/build/mcp/server.js

@@ -4,12 +4,13 @@
 import { config } from "dotenv";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { createLogger } from "../utils/logging.js";
+import { createLogger, ErrorCategoryType } from "../utils/logging.js";
 import { rateLimiter } from "../utils/rate-limiting.js";
 import { createTagResource } from "../resources/index.js";
 import { createToolHandlers, createToolHandlerMap } from "../tools/index.js";
 import { ObsidianClient } from "../obsidian/client.js";
 import { setupToolListingHandler, setupToolCallingHandler, setupResourceListingHandler, setupResourceReadingHandler } from "./handlers.js";
+import { McpErrorCode } from "./types.js";
 // Create a logger for the server
 const logger = createLogger('McpServer');
 // Load environment variables
@@ -18,52 +19,116 @@ config();
  * Initialize MCP server components
  */
 export async function initializeServer() {
-    // Verify API key exists
-    const API_KEY = process.env.OBSIDIAN_API_KEY;
-    if (!API_KEY) {
-        throw new Error("OBSIDIAN_API_KEY environment variable is required");
-    }
-    // Initialize Obsidian client with environment configuration
-    logger.info('Initializing Obsidian client');
-    const client = new ObsidianClient({
-        apiKey: API_KEY,
-        verifySSL: process.env.VERIFY_SSL === 'true',
-        timeout: parseInt(process.env.REQUEST_TIMEOUT || '5000'),
-        maxContentLength: parseInt(process.env.MAX_CONTENT_LENGTH || String(50 * 1024 * 1024)),
-        maxBodyLength: parseInt(process.env.MAX_BODY_LENGTH || String(50 * 1024 * 1024))
-    });
-    // Initialize tool handlers
-    logger.info('Initializing tool handlers');
-    const toolHandlers = createToolHandlers(client);
-    const toolHandlerMap = createToolHandlerMap(toolHandlers);
-    // Initialize resources
-    logger.info('Initializing resources');
-    const tagResource = createTagResource(client);
-    const resources = {
-        [tagResource.getResourceDescription().uri]: tagResource
-    };
-    // Create MCP server
-    const serverConfig = {
-        name: "obsidian-mcp-server",
-        version: process.env.npm_package_version ?? "1.1.0" // Use version from package.json
-    };
-    logger.info(`Creating MCP server: ${serverConfig.name} v${serverConfig.version}`);
-    const server = new Server(serverConfig, {
-        capabilities: {
-            tools: {},
-            resources
+    // Start initialization timer
+    logger.startTimer('server_init');
+    try {
+        // Verify API key exists
+        const API_KEY = process.env.OBSIDIAN_API_KEY;
+        if (!API_KEY) {
+            logger.error("Missing API key", {
+                errorCategory: ErrorCategoryType.CATEGORY_AUTHENTICATION,
+                errorCode: McpErrorCode.UNAUTHORIZED
+            });
+            throw new Error("OBSIDIAN_API_KEY environment variable is required");
         }
-    });
-    // Set up request handlers
-    setupToolListingHandler(server, toolHandlerMap);
-    setupToolCallingHandler(server, toolHandlerMap);
-    setupResourceListingHandler(server, resources);
-    setupResourceReadingHandler(server, resources);
-    // Set up error handler
-    server.onerror = (error) => {
-        logger.error("[MCP Error]", error);
-    };
-    return server;
+        // Initialize Obsidian client with environment configuration
+        logger.info('Initializing Obsidian client', {
+            verifySSL: process.env.VERIFY_SSL === 'true',
+            timeout: parseInt(process.env.REQUEST_TIMEOUT || '5000'),
+            maxContentLength: parseInt(process.env.MAX_CONTENT_LENGTH || String(50 * 1024 * 1024)),
+            maxBodyLength: parseInt(process.env.MAX_BODY_LENGTH || String(50 * 1024 * 1024))
+        });
+        const client = new ObsidianClient({
+            apiKey: API_KEY,
+            verifySSL: process.env.VERIFY_SSL === 'true',
+            timeout: parseInt(process.env.REQUEST_TIMEOUT || '5000'),
+            maxContentLength: parseInt(process.env.MAX_CONTENT_LENGTH || String(50 * 1024 * 1024)),
+            maxBodyLength: parseInt(process.env.MAX_BODY_LENGTH || String(50 * 1024 * 1024))
+        });
+        // Initialize tool handlers
+        logger.startTimer('init_tools');
+        logger.info('Initializing tool handlers');
+        const toolHandlers = createToolHandlers(client);
+        const toolHandlerMap = createToolHandlerMap(toolHandlers);
+        const toolsElapsedMs = logger.endTimer('init_tools');
+        logger.info(`Initialized ${toolHandlerMap.size} tool handlers`, {
+            processingTimeMs: toolsElapsedMs,
+            toolCount: toolHandlerMap.size
+        });
+        // Initialize resources
+        logger.startTimer('init_resources');
+        logger.info('Initializing resources');
+        const tagResource = createTagResource(client);
+        const resources = {
+            [tagResource.getResourceDescription().uri]: tagResource
+        };
+        const resourcesElapsedMs = logger.endTimer('init_resources');
+        logger.info(`Initialized ${Object.keys(resources).length} resources`, {
+            processingTimeMs: resourcesElapsedMs,
+            resourceCount: Object.keys(resources).length
+        });
+        // Create MCP server
+        const serverConfig = {
+            name: "obsidian-mcp-server",
+            version: process.env.npm_package_version ?? "1.1.0" // Use version from package.json
+        };
+        logger.info(`Creating MCP server: ${serverConfig.name} v${serverConfig.version}`, {
+            serverName: serverConfig.name,
+            serverVersion: serverConfig.version
+        });
+        const server = new Server(serverConfig, {
+            capabilities: {
+                tools: {},
+                resources
+            }
+        });
+        // Set up request handlers
+        logger.startTimer('setup_handlers');
+        setupToolListingHandler(server, toolHandlerMap);
+        setupToolCallingHandler(server, toolHandlerMap);
+        setupResourceListingHandler(server, resources);
+        setupResourceReadingHandler(server, resources);
+        const handlersElapsedMs = logger.endTimer('setup_handlers');
+        logger.info('Request handlers configured', { processingTimeMs: handlersElapsedMs });
+        // Set up enhanced error handler
+        server.onerror = (error) => {
+            if (error instanceof Error) {
+                logger.error("MCP Server Error", {
+                    name: error.name,
+                    message: error.message,
+                    stack: error.stack,
+                    errorCategory: ErrorCategoryType.CATEGORY_SYSTEM
+                });
+            }
+            else {
+                logger.error("MCP Server Error (Unknown)", {
+                    error: String(error),
+                    errorCategory: ErrorCategoryType.CATEGORY_UNKNOWN
+                });
+            }
+        };
+        // Log successful initialization
+        const totalElapsedMs = logger.endTimer('server_init');
+        logger.logOperationResult(true, 'server_initialization', totalElapsedMs, {
+            toolCount: toolHandlerMap.size,
+            resourceCount: Object.keys(resources).length
+        });
+        return server;
+    }
+    catch (error) {
+        // Log initialization failure
+        const totalElapsedMs = logger.endTimer('server_init');
+        logger.logOperationResult(false, 'server_initialization', totalElapsedMs);
+        // Enhance error reporting
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorStack = error instanceof Error ? error.stack : undefined;
+        logger.error("Failed to initialize server", {
+            error: errorMessage,
+            stack: errorStack,
+            errorCategory: ErrorCategoryType.CATEGORY_SYSTEM
+        });
+        throw error;
+    }
 }
 /**
  * Set up graceful shutdown handling
@@ -72,43 +137,78 @@ export async function initializeServer() {
  */
 export function setupShutdownHandling(server, cleanupHandlers = []) {
     // Cleanup function for graceful shutdown
-    const cleanup = async () => {
-        logger.info('Shutting down server...');
-        // Run cleanup handlers
-        for (const handler of cleanupHandlers) {
-            try {
-                await handler();
-            }
-            catch (error) {
-                logger.error('Error during cleanup:', error);
+    const cleanup = async (signal) => {
+        logger.startTimer('server_shutdown');
+        logger.info('Shutting down server...', { signal });
+        try {
+            // Run cleanup handlers
+            logger.debug('Running cleanup handlers', { handlersCount: cleanupHandlers.length });
+            for (const handler of cleanupHandlers) {
+                try {
+                    await handler();
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    logger.error('Error during cleanup handler execution', {
+                        error: errorMessage,
+                        stack: error instanceof Error ? error.stack : undefined,
+                        errorCategory: ErrorCategoryType.CATEGORY_SYSTEM
+                    });
+                }
             }
+            // Dispose rate limiter
+            logger.debug('Disposing rate limiter');
+            rateLimiter.dispose();
+            // Close server
+            logger.debug('Closing MCP server connection');
+            await server.close();
+            const elapsedMs = logger.endTimer('server_shutdown');
+            logger.logOperationResult(true, 'server_shutdown', elapsedMs);
+            logger.info('Server shutdown completed successfully');
+            process.exit(0);
+        }
+        catch (error) {
+            const elapsedMs = logger.endTimer('server_shutdown');
+            logger.logOperationResult(false, 'server_shutdown', elapsedMs);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('Failed to shut down server gracefully', {
+                error: errorMessage,
+                stack: error instanceof Error ? error.stack : undefined,
+                errorCategory: ErrorCategoryType.CATEGORY_SYSTEM
+            });
+            process.exit(1);
         }
-        // Dispose rate limiter
-        rateLimiter.dispose();
-        // Close server
-        await server.close();
-        process.exit(0);
     };
     // Handle various termination signals
-    process.on('SIGINT', cleanup); // Ctrl+C on all platforms
-    process.on('SIGTERM', cleanup); // Termination request
+    process.on('SIGINT', () => cleanup('SIGINT')); // Ctrl+C on all platforms
+    process.on('SIGTERM', () => cleanup('SIGTERM')); // Termination request
     if (process.platform === 'win32') {
         // Windows-specific handling
-        process.on('SIGHUP', cleanup); // Terminal closed
+        process.on('SIGHUP', () => cleanup('SIGHUP')); // Terminal closed
     }
     else {
         // Unix-specific signals
-        process.on('SIGUSR1', cleanup);
-        process.on('SIGUSR2', cleanup);
+        process.on('SIGUSR1', () => cleanup('SIGUSR1'));
+        process.on('SIGUSR2', () => cleanup('SIGUSR2'));
     }
     // Handle uncaught errors
     process.on('uncaughtException', async (error) => {
-        logger.error('Uncaught exception:', error);
-        await cleanup();
+        logger.error('Uncaught exception', {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+            errorCategory: ErrorCategoryType.CATEGORY_SYSTEM
+        });
+        await cleanup('uncaughtException');
     });
-    process.on('unhandledRejection', async (error) => {
-        logger.error('Unhandled rejection:', error);
-        await cleanup();
+    process.on('unhandledRejection', async (reason, promise) => {
+        const errorMessage = reason instanceof Error ? reason.message : String(reason);
+        logger.error('Unhandled promise rejection', {
+            reason: errorMessage,
+            stack: reason instanceof Error ? reason.stack : undefined,
+            errorCategory: ErrorCategoryType.CATEGORY_SYSTEM
+        });
+        await cleanup('unhandledRejection');
     });
 }
 /**
@@ -116,15 +216,31 @@ export function setupShutdownHandling(server, cleanupHandlers = []) {
  */
 export async function run() {
     try {
+        logger.info("Starting Obsidian MCP server");
+        logger.startTimer('server_startup');
         const server = await initializeServer();
         setupShutdownHandling(server, []);
         // Connect to transport
+        logger.debug("Connecting to stdio transport");
         const transport = new StdioServerTransport();
         await server.connect(transport);
-        logger.info("Obsidian MCP server running on stdio");
+        const elapsedMs = logger.endTimer('server_startup');
+        logger.logOperationResult(true, 'server_startup', elapsedMs);
+        logger.info("Obsidian MCP server running on stdio", {
+            serverName: "obsidian-mcp-server",
+            serverVersion: process.env.npm_package_version ?? "1.1.0",
+            transport: "stdio"
+        });
     }
     catch (error) {
-        logger.error("Failed to start server:", error);
+        const elapsedMs = logger.endTimer('server_startup', 'Server startup failed');
+        logger.logOperationResult(false, 'server_startup', elapsedMs);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error("Failed to start server", {
+            error: errorMessage,
+            stack: error instanceof Error ? error.stack : undefined,
+            errorCategory: ErrorCategoryType.CATEGORY_SYSTEM
+        });
         process.exit(1);
     }
 }

package/build/mcp/types.js

@@ -1,7 +1,49 @@
+import { ErrorCategoryType, LogLevel } from "../utils/logging.js";
+/**
+ * Error codes used in the MCP server
+ */
+export var McpErrorCode;
+(function (McpErrorCode) {
+    // Server errors (5xxxx)
+    McpErrorCode[McpErrorCode["INTERNAL_SERVER_ERROR"] = 50000] = "INTERNAL_SERVER_ERROR";
+    McpErrorCode[McpErrorCode["SERVICE_UNAVAILABLE"] = 50300] = "SERVICE_UNAVAILABLE";
+    McpErrorCode[McpErrorCode["TIMEOUT"] = 50800] = "TIMEOUT";
+    // Client errors (4xxxx)
+    McpErrorCode[McpErrorCode["BAD_REQUEST"] = 40000] = "BAD_REQUEST";
+    McpErrorCode[McpErrorCode["UNAUTHORIZED"] = 40100] = "UNAUTHORIZED";
+    McpErrorCode[McpErrorCode["FORBIDDEN"] = 40300] = "FORBIDDEN";
+    McpErrorCode[McpErrorCode["NOT_FOUND"] = 40400] = "NOT_FOUND";
+    McpErrorCode[McpErrorCode["METHOD_NOT_ALLOWED"] = 40500] = "METHOD_NOT_ALLOWED";
+    McpErrorCode[McpErrorCode["RATE_LIMIT_EXCEEDED"] = 40900] = "RATE_LIMIT_EXCEEDED";
+    // Success with special handling
+    McpErrorCode[McpErrorCode["SUCCESS_NO_CONTENT"] = 20400] = "SUCCESS_NO_CONTENT";
+})(McpErrorCode || (McpErrorCode = {}));
 /**
  * Default timeout configuration
  */
 export const DEFAULT_TIMEOUT_CONFIG = {
     toolExecutionMs: parseInt(process.env.TOOL_TIMEOUT_MS ?? '60000') // 60 second default timeout
 };
+/**
+ * Helper functions for creating operation results
+ */
+export function createSuccessResult(data) {
+    return {
+        resultSuccessful: true,
+        resultData: data
+    };
+}
+export function createFailureResult(message, code, category = ErrorCategoryType.CATEGORY_UNKNOWN, context) {
+    return {
+        resultSuccessful: false,
+        resultError: {
+            errorMessage: message,
+            errorCode: typeof code === 'string' ? code : String(code),
+            errorCategory: category,
+            errorSeverity: LogLevel.ERROR,
+            errorTimestamp: new Date().toISOString(),
+            errorContext: context
+        }
+    };
+}
 //# sourceMappingURL=types.js.map

package/build/resources/tags.js

@@ -1,8 +1,30 @@
 import { PropertyManager } from "../tools/properties/manager.js";
 import { sep } from "path";
-import { createLogger } from "../utils/logging.js";
+import { createLogger, ErrorCategoryType } from "../utils/logging.js";
 // Create a logger for tag resources
 const logger = createLogger('TagResource');
+/**
+ * Helper function to safely convert any error to an object
+ */
+function errorToObject(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+            errorCategory: ErrorCategoryType.CATEGORY_SYSTEM
+        };
+    }
+    else if (typeof error === 'object' && error !== null) {
+        return error;
+    }
+    else {
+        return {
+            error: String(error),
+            errorCategory: ErrorCategoryType.CATEGORY_UNKNOWN
+        };
+    }
+}
 /**
  * Resource for providing tags used in the Obsidian vault
  */
@@ -33,6 +55,7 @@ export class TagResource {
      * Initialize the tag cache
      */
     async initializeCache() {
+        logger.startTimer('init_tag_cache');
         try {
             logger.info('Initializing tag cache');
             // Get all markdown files using platform-agnostic path pattern
@@ -56,15 +79,22 @@ export class TagResource {
                     }
                 }
                 catch (error) {
-                    logger.error(`Failed to process file ${result.filename}:`, error);
+                    logger.error(`Failed to process file ${result.filename}:`, errorToObject(error));
                 }
             }
             this.isInitialized = true;
             this.lastUpdate = Date.now();
+            const elapsedMs = logger.endTimer('init_tag_cache');
+            logger.logOperationResult(true, 'initialize_tag_cache', elapsedMs, {
+                tagCount: this.tagCache.size,
+                fileCount: results.length
+            });
             logger.info(`Tag cache initialized with ${this.tagCache.size} unique tags`);
         }
         catch (error) {
-            logger.error("Failed to initialize tag cache:", error);
+            const elapsedMs = logger.endTimer('init_tag_cache');
+            logger.logOperationResult(false, 'initialize_tag_cache', elapsedMs);
+            logger.error("Failed to initialize tag cache:", errorToObject(error));
             throw error;
         }
     }
@@ -91,6 +121,7 @@ export class TagResource {
      * Get the content for the resource
      */
     async getContent() {
+        logger.startTimer('get_tags_content');
         try {
             if (!this.isInitialized) {
                 logger.info('Tag cache not initialized, initializing now');
@@ -117,6 +148,13 @@ export class TagResource {
                 }
             };
             logger.debug(`Returning tag resource with ${response.tags.length} tags`);
+            const elapsedMs = logger.endTimer('get_tags_content');
+            logger.logOperationResult(true, 'get_tags', elapsedMs, {
+                tagCount: response.tags.length,
+                totalOccurrences: response.metadata.totalOccurrences,
+                uniqueTags: response.metadata.uniqueTags,
+                scannedFiles: response.metadata.scannedFiles
+            });
             return [{
                     type: "text",
                     text: JSON.stringify(response, null, 2),
@@ -124,7 +162,9 @@ export class TagResource {
                 }];
         }
         catch (error) {
-            logger.error("Failed to get tags:", error);
+            const elapsedMs = logger.endTimer('get_tags_content');
+            logger.logOperationResult(false, 'get_tags', elapsedMs);
+            logger.error("Failed to get tags:", errorToObject(error));
             throw error;
         }
     }

package/build/tools/base.js

@@ -1,6 +1,7 @@
 import { ObsidianError } from "../utils/errors.js";
 import { tokenCounter } from "../utils/tokenization.js";
-import { createLogger } from "../utils/logging.js";
+import { createLogger, ErrorCategoryType } from "../utils/logging.js";
+import { McpErrorCode } from "../mcp/types.js";
 // Create a logger for tool operations
 const logger = createLogger('Tools');
 /**
@@ -51,7 +52,12 @@ export class BaseToolHandler {
         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}`);
+            logger.debug(`[${this.name}] Response truncated`, {
+                toolName: this.name,
+                originalTokens: originalTokenCount,
+                truncatedTokens: finalTokenCount,
+                truncationPercent: Math.round((1 - finalTokenCount / originalTokenCount) * 100)
+            });
         }
         return [{
                 type: "text",
@@ -67,12 +73,16 @@ export class BaseToolHandler {
         if (error instanceof ObsidianError) {
             throw error;
         }
+        logger.error(`Tool '${this.name}' execution failed`, {
+            toolName: this.name,
+            errorMessage: error instanceof Error ? error.message : String(error),
+            errorStack: error instanceof Error ? error.stack : undefined,
+            errorCategory: ErrorCategoryType.CATEGORY_SYSTEM
+        });
         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: ${error.message}`, McpErrorCode.INTERNAL_SERVER_ERROR, { originalError: error.stack });
         }
-        throw new ObsidianError(`Tool '${this.name}' execution failed with unknown error`, 50000, // Internal server error
-        { error });
+        throw new ObsidianError(`Tool '${this.name}' execution failed with unknown error`, McpErrorCode.INTERNAL_SERVER_ERROR, { error: String(error) });
     }
 }
 //# sourceMappingURL=base.js.map

package/build/tools/properties/manager.js

@@ -1,8 +1,8 @@
 /**
  * Property manager for Obsidian notes
  */
-import { parse, stringify } from 'yaml';
 import { EOL } from 'os';
+import { parse, stringify } from 'yaml';
 import { createLogger } from '../../utils/logging.js';
 import { ObsidianPropertiesSchema, PropertyUpdateSchema } from './types.js';
 // Create a logger for property operations
@@ -37,14 +37,14 @@ export class PropertyManager {
             // Validate against schema
             const result = ObsidianPropertiesSchema.safeParse(properties);
             if (!result.success) {
-                logger.warn('Property validation warnings:', result.error);
+                logger.warn('Property validation warnings:', { validationError: result.error });
                 // Return the properties with fixed tags
                 return properties;
             }
             return result.data;
         }
         catch (error) {
-            logger.error('Error parsing properties:', error);
+            logger.error('Error parsing properties:', error instanceof Error ? error : { error: String(error) });
             return {};
         }
     }
@@ -62,7 +62,7 @@ export class PropertyManager {
             return `---${EOL}${yaml}---${EOL}`;
         }
         catch (error) {
-            logger.error('Error generating properties:', error);
+            logger.error('Error generating properties:', error instanceof Error ? error : { error: String(error) });
             throw error;
         }
     }
@@ -134,7 +134,7 @@ export class PropertyManager {
             };
         }
         catch (error) {
-            logger.error(`Failed to get properties from ${filepath}:`, error);
+            logger.error(`Failed to get properties from ${filepath}:`, error instanceof Error ? error : { error: String(error) });
             return {
                 success: false,
                 message: `Failed to get properties: ${error instanceof Error ? error.message : String(error)}`,
@@ -154,7 +154,7 @@ export class PropertyManager {
             // Validate new properties
             const validation = this.validateProperties(newProperties);
             if (!validation.valid) {
-                logger.warn(`Invalid properties for ${filepath}:`, validation.errors);
+                logger.warn(`Invalid properties for ${filepath}:`, { errors: validation.errors });
                 return {
                     success: false,
                     message: 'Invalid properties',
@@ -182,7 +182,7 @@ export class PropertyManager {
             };
         }
         catch (error) {
-            logger.error(`Failed to update properties for ${filepath}:`, error);
+            logger.error(`Failed to update properties for ${filepath}:`, error instanceof Error ? error : { error: String(error) });
             return {
                 success: false,
                 message: `Failed to update properties: ${error instanceof Error ? error.message : String(error)}`,

package/build/tools/properties/tools.js

@@ -1,8 +1,30 @@
 import { BaseToolHandler } from "../base.js";
 import { PropertyManager } from "./manager.js";
-import { createLogger } from "../../utils/logging.js";
+import { createLogger, ErrorCategoryType } from "../../utils/logging.js";
 // Create a logger for property tools
 const logger = createLogger('PropertyTools');
+/**
+ * Helper function to safely convert any error to an object
+ */
+function errorToObject(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+            errorCategory: ErrorCategoryType.CATEGORY_SYSTEM
+        };
+    }
+    else if (typeof error === 'object' && error !== null) {
+        return error;
+    }
+    else {
+        return {
+            error: String(error),
+            errorCategory: ErrorCategoryType.CATEGORY_UNKNOWN
+        };
+    }
+}
 /**
  * Tool names for property operations
  */
@@ -51,13 +73,23 @@ export class GetPropertiesToolHandler extends BaseToolHandler {
         };
     }
     async runTool(args) {
+        logger.startTimer(`get_properties_${args.filepath}`);
         try {
             logger.debug(`Getting properties from: ${args.filepath}`);
             const result = await this.propertyManager.getProperties(args.filepath);
+            const elapsedMs = logger.endTimer(`get_properties_${args.filepath}`);
+            logger.logOperationResult(true, 'get_properties', elapsedMs, {
+                filepath: args.filepath,
+                propertyCount: Object.keys(result.properties || {}).length
+            });
             return this.createResponse(result);
         }
         catch (error) {
-            logger.error(`Error getting properties from ${args.filepath}:`, error);
+            const elapsedMs = logger.endTimer(`get_properties_${args.filepath}`);
+            logger.logOperationResult(false, 'get_properties', elapsedMs, {
+                filepath: args.filepath
+            });
+            logger.error(`Error getting properties from ${args.filepath}:`, errorToObject(error));
             return this.handleError(error);
         }
     }
@@ -177,13 +209,28 @@ export class UpdatePropertiesToolHandler extends BaseToolHandler {
         };
     }
     async runTool(args) {
+        logger.startTimer(`update_properties_${args.filepath}`);
         try {
-            logger.debug(`Updating properties for: ${args.filepath}`);
+            logger.debug(`Updating properties for: ${args.filepath}`, {
+                filepath: args.filepath,
+                propertyCount: Object.keys(args.properties || {}).length,
+                replace: args.replace || false
+            });
             const result = await this.propertyManager.updateProperties(args.filepath, args.properties, args.replace);
+            const elapsedMs = logger.endTimer(`update_properties_${args.filepath}`);
+            logger.logOperationResult(true, 'update_properties', elapsedMs, {
+                filepath: args.filepath,
+                propertyCount: Object.keys(args.properties || {}).length,
+                success: result.success
+            });
             return this.createResponse(result);
         }
         catch (error) {
-            logger.error(`Error updating properties for ${args.filepath}:`, error);
+            const elapsedMs = logger.endTimer(`update_properties_${args.filepath}`);
+            logger.logOperationResult(false, 'update_properties', elapsedMs, {
+                filepath: args.filepath
+            });
+            logger.error(`Error updating properties for ${args.filepath}:`, errorToObject(error));
             return this.handleError(error);
         }
     }