obsidian-mcp-server 1.5.8 → 2.0.2

package/dist/mcp-server/server.js

@@ -0,0 +1,211 @@
+/**
+ * @fileoverview Main entry point for the MCP (Model Context Protocol) server.
+ * This file orchestrates the server's lifecycle:
+ * 1. Initializes the core `McpServer` instance (from `@modelcontextprotocol/sdk`) with its identity and capabilities.
+ * 2. Registers available resources and tools, making them discoverable and usable by clients.
+ * 3. Selects and starts the appropriate communication transport (stdio or Streamable HTTP)
+ *    based on configuration.
+ * 4. Handles top-level error management during startup.
+ *
+ * MCP Specification References:
+ * - Lifecycle: https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/lifecycle.mdx
+ * - Overview (Capabilities): https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/index.mdx
+ * - Transports: https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/transports.mdx
+ * @module src/mcp-server/server
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+// Import validated configuration and environment details.
+import { config, environment } from "../config/index.js";
+// Import core utilities: ErrorHandler, logger, requestContextService.
+import { ErrorHandler, logger, requestContextService } from "../utils/index.js";
+// Import registration functions for specific resources and tools.
+import { registerObsidianDeleteFileTool } from "./tools/obsidianDeleteFileTool/index.js";
+import { registerObsidianGlobalSearchTool } from "./tools/obsidianGlobalSearchTool/index.js";
+import { registerObsidianListFilesTool } from "./tools/obsidianListFilesTool/index.js";
+import { registerObsidianReadFileTool } from "./tools/obsidianReadFileTool/index.js";
+import { registerObsidianSearchReplaceTool } from "./tools/obsidianSearchReplaceTool/index.js";
+import { registerObsidianUpdateFileTool } from "./tools/obsidianUpdateFileTool/index.js";
+import { registerObsidianManageFrontmatterTool } from "./tools/obsidianManageFrontmatterTool/index.js";
+import { registerObsidianManageTagsTool } from "./tools/obsidianManageTagsTool/index.js";
+// Import transport setup functions.
+import { startHttpTransport } from "./transports/httpTransport.js";
+import { connectStdioTransport } from "./transports/stdioTransport.js";
+/**
+ * Creates and configures a new instance of the `McpServer`.
+ *
+ * This function is central to defining the server's identity and functionality
+ * as presented to connecting clients during the MCP initialization phase.
+ * It uses pre-instantiated shared services like Obsidian API and Vault Cache.
+ *
+ * MCP Spec Relevance:
+ * - Server Identity (`serverInfo`): The `name` and `version` provided here are part
+ *   of the `ServerInformation` object returned in the `InitializeResult` message.
+ * - Capabilities Declaration: Declares supported features (logging, dynamic resources/tools).
+ * - Resource/Tool Registration: Calls registration functions, passing necessary service instances.
+ *
+ * Design Note: This factory is called once for 'stdio' transport and per session for 'http' transport.
+ *
+ * @param {ObsidianRestApiService} obsidianService - The shared Obsidian REST API service instance.
+ * @param {VaultCacheService | undefined} vaultCacheService - The shared Vault Cache service instance, which may be undefined if disabled.
+ * @returns {Promise<McpServer>} A promise resolving with the configured `McpServer` instance.
+ * @throws {Error} If any resource or tool registration fails.
+ * @private
+ */
+async function createMcpServerInstance(obsidianService, vaultCacheService) {
+    const context = requestContextService.createRequestContext({
+        operation: "createMcpServerInstance",
+    });
+    logger.info("Initializing MCP server instance with shared services", context);
+    requestContextService.configure({
+        appName: config.mcpServerName,
+        appVersion: config.mcpServerVersion,
+        environment,
+    });
+    logger.debug("Instantiating McpServer with capabilities", {
+        ...context,
+        serverInfo: {
+            name: config.mcpServerName,
+            version: config.mcpServerVersion,
+        },
+        capabilities: {
+            logging: {},
+            resources: { listChanged: true },
+            tools: { listChanged: true },
+        },
+    });
+    const server = new McpServer({ name: config.mcpServerName, version: config.mcpServerVersion }, {
+        capabilities: {
+            logging: {}, // Server can receive logging/setLevel and send notifications/message
+            resources: { listChanged: true }, // Server supports dynamic resource lists
+            tools: { listChanged: true }, // Server supports dynamic tool lists
+        },
+    });
+    try {
+        logger.debug("Registering resources and tools using shared services...", context);
+        // Register all tools, passing the vaultCacheService which may be undefined
+        await registerObsidianListFilesTool(server, obsidianService);
+        await registerObsidianReadFileTool(server, obsidianService);
+        await registerObsidianDeleteFileTool(server, obsidianService, vaultCacheService);
+        if (vaultCacheService) {
+            await registerObsidianGlobalSearchTool(server, obsidianService, vaultCacheService);
+        }
+        else {
+            logger.warning("Skipping registration of 'obsidian_global_search' because the Vault Cache Service is disabled.", context);
+        }
+        await registerObsidianSearchReplaceTool(server, obsidianService, vaultCacheService);
+        await registerObsidianUpdateFileTool(server, obsidianService, vaultCacheService);
+        await registerObsidianManageFrontmatterTool(server, obsidianService, vaultCacheService);
+        await registerObsidianManageTagsTool(server, obsidianService, vaultCacheService);
+        logger.info("Resources and tools registered successfully", context);
+        if (vaultCacheService) {
+            logger.info("Triggering background vault cache build (if not already built/building)...", context);
+            // Intentionally not awaiting this promise to allow server startup to proceed.
+            // Errors are logged within the catch block.
+            vaultCacheService.buildVaultCache().catch((cacheBuildError) => {
+                logger.error("Error occurred during background vault cache build", {
+                    ...context, // Use the initial context for correlation
+                    subOperation: "BackgroundVaultCacheBuild", // Add sub-operation for clarity
+                    error: cacheBuildError instanceof Error
+                        ? cacheBuildError.message
+                        : String(cacheBuildError),
+                    stack: cacheBuildError instanceof Error
+                        ? cacheBuildError.stack
+                        : undefined,
+                });
+            });
+        }
+    }
+    catch (err) {
+        logger.error("Failed to register resources/tools", {
+            ...context,
+            error: err instanceof Error ? err.message : String(err),
+            stack: err instanceof Error ? err.stack : undefined,
+        });
+        throw err; // Re-throw to be caught by the caller (e.g., startTransport)
+    }
+    return server;
+}
+/**
+ * Selects, sets up, and starts the appropriate MCP transport layer based on configuration.
+ * This function acts as the bridge between the core server logic and the communication channel.
+ * It now accepts shared service instances to pass them down the chain.
+ *
+ * MCP Spec Relevance:
+ * - Transport Selection: Uses `config.mcpTransportType` ('stdio' or 'http').
+ * - Transport Connection: Calls dedicated functions for chosen transport.
+ * - Server Instance Lifecycle: Single instance for 'stdio', per-session for 'http'.
+ *
+ * @param {ObsidianRestApiService} obsidianService - The shared Obsidian REST API service instance.
+ * @param {VaultCacheService | undefined} vaultCacheService - The shared Vault Cache service instance.
+ * @returns {Promise<McpServer | void>} Resolves with the `McpServer` instance for 'stdio', or `void` for 'http'.
+ * @throws {Error} If the configured transport type is unsupported or if transport setup fails.
+ * @private
+ */
+async function startTransport(obsidianService, vaultCacheService) {
+    const transportType = config.mcpTransportType;
+    const context = requestContextService.createRequestContext({
+        operation: "startTransport",
+        transport: transportType,
+    });
+    logger.info(`Starting transport: ${transportType}`, context);
+    if (transportType === "http") {
+        logger.debug("Delegating to startHttpTransport with a factory for McpServer instances...", context);
+        // For HTTP, startHttpTransport manages its own lifecycle and server instances per session.
+        // It needs a factory function to create new McpServer instances, passing along the shared services.
+        const mcpServerFactory = async () => createMcpServerInstance(obsidianService, vaultCacheService);
+        const httpServerInstance = await startHttpTransport(mcpServerFactory, context);
+        return httpServerInstance; // Return the http.Server instance.
+    }
+    if (transportType === "stdio") {
+        logger.debug("Creating single McpServer instance for stdio transport using shared services...", context);
+        const server = await createMcpServerInstance(obsidianService, vaultCacheService);
+        logger.debug("Delegating to connectStdioTransport...", context);
+        await connectStdioTransport(server, context);
+        return server; // Return the single server instance for stdio.
+    }
+    // Should not be reached if config validation is effective.
+    logger.fatal(`Unsupported transport type configured: ${transportType}`, context);
+    throw new Error(`Unsupported transport type: ${transportType}. Must be 'stdio' or 'http'.`);
+}
+/**
+ * Main application entry point. Initializes services and starts the MCP server.
+ * Orchestrates server startup, transport selection, and top-level error handling.
+ *
+ * MCP Spec Relevance:
+ * - Manages server startup, leading to a server ready for MCP messages.
+ * - Handles critical startup failures, ensuring appropriate process exit.
+ *
+ * @param {ObsidianRestApiService} obsidianService - The shared Obsidian REST API service instance, instantiated by the caller (e.g., index.ts).
+ * @param {VaultCacheService | undefined} vaultCacheService - The shared Vault Cache service instance, instantiated by the caller (e.g., index.ts).
+ * @returns {Promise<void | McpServer>} For 'stdio', resolves with `McpServer`. For 'http', runs indefinitely.
+ *   Rejects on critical failure, leading to process exit.
+ */
+export async function initializeAndStartServer(obsidianService, vaultCacheService) {
+    const context = requestContextService.createRequestContext({
+        operation: "initializeAndStartServer",
+    });
+    logger.info("MCP Server initialization sequence started (services provided).", context);
+    try {
+        // Services are now provided by the caller (e.g., index.ts)
+        logger.debug("Using provided shared services (ObsidianRestApiService, VaultCacheService).", context);
+        // Initiate the transport setup based on configuration, passing shared services.
+        const result = await startTransport(obsidianService, vaultCacheService);
+        logger.info("MCP Server initialization sequence completed successfully.", context);
+        return result;
+    }
+    catch (err) {
+        logger.fatal("Critical error during MCP server initialization.", {
+            ...context,
+            error: err instanceof Error ? err.message : String(err),
+            stack: err instanceof Error ? err.stack : undefined,
+        });
+        // Ensure the error is handled by our centralized handler, which might log more details or perform cleanup.
+        ErrorHandler.handleError(err, {
+            operation: "initializeAndStartServer", // More specific operation
+            context: context, // Pass the existing context
+            critical: true, // This is a critical failure
+        });
+        logger.info("Exiting process due to critical initialization error.", context);
+        process.exit(1); // Exit with a non-zero code to indicate failure.
+    }
+}

package/dist/mcp-server/tools/obsidianDeleteFileTool/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview Barrel file for the 'obsidian_delete_file' MCP tool.
+ *
+ * This file serves as the public entry point for the obsidian_delete_file tool module.
+ * It re-exports the primary registration function (`registerObsidianDeleteFileTool`)
+ * from the './registration.js' module. This pattern simplifies imports for consumers
+ * of the tool, allowing them to import necessary components from a single location.
+ *
+ * Consumers (like the main server setup) should import the registration function
+ * from this file to integrate the tool into the MCP server instance.
+ */
+export { registerObsidianDeleteFileTool } from "./registration.js";

package/dist/mcp-server/tools/obsidianDeleteFileTool/index.js

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview Barrel file for the 'obsidian_delete_file' MCP tool.
+ *
+ * This file serves as the public entry point for the obsidian_delete_file tool module.
+ * It re-exports the primary registration function (`registerObsidianDeleteFileTool`)
+ * from the './registration.js' module. This pattern simplifies imports for consumers
+ * of the tool, allowing them to import necessary components from a single location.
+ *
+ * Consumers (like the main server setup) should import the registration function
+ * from this file to integrate the tool into the MCP server instance.
+ */
+export { registerObsidianDeleteFileTool } from "./registration.js";

package/dist/mcp-server/tools/obsidianDeleteFileTool/logic.d.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { ObsidianRestApiService, VaultCacheService } from "../../../services/obsidianRestAPI/index.js";
+import { RequestContext } from "../../../utils/index.js";
+/**
+ * Zod schema for validating the input parameters of the 'obsidian_delete_file' tool.
+ */
+export declare const ObsidianDeleteFileInputSchema: z.ZodObject<{
+    /**
+     * The vault-relative path to the file to be permanently deleted.
+     * Must include the file extension (e.g., "Old Notes/Obsolete File.md").
+     * The tool first attempts a case-sensitive match. If not found, it attempts
+     * a case-insensitive fallback search within the same directory.
+     */
+    filePath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    filePath: string;
+}, {
+    filePath: string;
+}>;
+/**
+ * TypeScript type inferred from the input schema (`ObsidianDeleteFileInputSchema`).
+ * Represents the validated input parameters used within the core processing logic.
+ */
+export type ObsidianDeleteFileInput = z.infer<typeof ObsidianDeleteFileInputSchema>;
+/**
+ * Defines the structure of the successful response returned by the `processObsidianDeleteFile` function.
+ * This object is typically serialized to JSON and sent back to the client.
+ */
+export interface ObsidianDeleteFileResponse {
+    /** Indicates whether the deletion operation was successful. */
+    success: boolean;
+    /** A human-readable message confirming the deletion and specifying the path used. */
+    message: string;
+}
+/**
+ * Processes the core logic for deleting a file from the Obsidian vault.
+ *
+ * It attempts to delete the file using the provided path (case-sensitive first).
+ * If that fails with a 'NOT_FOUND' error, it attempts a case-insensitive fallback:
+ * it lists the directory, finds a unique case-insensitive match for the filename,
+ * and retries the deletion with the corrected path.
+ *
+ * @param {ObsidianDeleteFileInput} params - The validated input parameters.
+ * @param {RequestContext} context - The request context for logging and correlation.
+ * @param {ObsidianRestApiService} obsidianService - An instance of the Obsidian REST API service.
+ * @returns {Promise<ObsidianDeleteFileResponse>} A promise resolving to the structured success response
+ *   containing a confirmation message.
+ * @throws {McpError} Throws an McpError if the file cannot be found (even with fallback),
+ *   if there's an ambiguous fallback match, or if any other API interaction fails.
+ */
+export declare const processObsidianDeleteFile: (params: ObsidianDeleteFileInput, context: RequestContext, obsidianService: ObsidianRestApiService, vaultCacheService: VaultCacheService | undefined) => Promise<ObsidianDeleteFileResponse>;

package/dist/mcp-server/tools/obsidianDeleteFileTool/logic.js

@@ -0,0 +1,168 @@
+import path from "node:path"; // node:path provides OS-specific path functions; using path.posix for vault path manipulation.
+import { z } from "zod";
+import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
+import { logger, retryWithDelay, } from "../../../utils/index.js";
+// ====================================================================================
+// Schema Definitions for Input Validation
+// ====================================================================================
+/**
+ * Zod schema for validating the input parameters of the 'obsidian_delete_file' tool.
+ */
+export const ObsidianDeleteFileInputSchema = z
+    .object({
+    /**
+     * The vault-relative path to the file to be permanently deleted.
+     * Must include the file extension (e.g., "Old Notes/Obsolete File.md").
+     * The tool first attempts a case-sensitive match. If not found, it attempts
+     * a case-insensitive fallback search within the same directory.
+     */
+    filePath: z
+        .string()
+        .min(1, "filePath cannot be empty")
+        .describe('The vault-relative path to the file to be deleted (e.g., "archive/old-file.md"). Tries case-sensitive first, then case-insensitive fallback.'),
+})
+    .describe("Input parameters for permanently deleting a specific file within the connected Obsidian vault. Includes a case-insensitive path fallback.");
+// ====================================================================================
+// Core Logic Function
+// ====================================================================================
+/**
+ * Processes the core logic for deleting a file from the Obsidian vault.
+ *
+ * It attempts to delete the file using the provided path (case-sensitive first).
+ * If that fails with a 'NOT_FOUND' error, it attempts a case-insensitive fallback:
+ * it lists the directory, finds a unique case-insensitive match for the filename,
+ * and retries the deletion with the corrected path.
+ *
+ * @param {ObsidianDeleteFileInput} params - The validated input parameters.
+ * @param {RequestContext} context - The request context for logging and correlation.
+ * @param {ObsidianRestApiService} obsidianService - An instance of the Obsidian REST API service.
+ * @returns {Promise<ObsidianDeleteFileResponse>} A promise resolving to the structured success response
+ *   containing a confirmation message.
+ * @throws {McpError} Throws an McpError if the file cannot be found (even with fallback),
+ *   if there's an ambiguous fallback match, or if any other API interaction fails.
+ */
+export const processObsidianDeleteFile = async (params, context, obsidianService, vaultCacheService) => {
+    const { filePath: originalFilePath } = params;
+    let effectiveFilePath = originalFilePath; // Track the path actually used for deletion
+    logger.debug(`Processing obsidian_delete_file request for path: ${originalFilePath}`, context);
+    const shouldRetryNotFound = (err) => err instanceof McpError && err.code === BaseErrorCode.NOT_FOUND;
+    try {
+        // --- Attempt 1: Delete using the provided path (case-sensitive) ---
+        const deleteContext = {
+            ...context,
+            operation: "deleteFileAttempt",
+            caseSensitive: true,
+        };
+        logger.debug(`Attempting to delete file (case-sensitive): ${originalFilePath}`, deleteContext);
+        await retryWithDelay(() => obsidianService.deleteFile(originalFilePath, deleteContext), {
+            operationName: "deleteFile",
+            context: deleteContext,
+            maxRetries: 3,
+            delayMs: 300,
+            shouldRetry: shouldRetryNotFound,
+        });
+        // If the above call succeeds, the file was deleted using the exact path.
+        logger.debug(`Successfully deleted file using exact path: ${originalFilePath}`, deleteContext);
+        if (vaultCacheService) {
+            await vaultCacheService.updateCacheForFile(originalFilePath, deleteContext);
+        }
+        return {
+            success: true,
+            message: `File '${originalFilePath}' deleted successfully.`,
+        };
+    }
+    catch (error) {
+        // --- Attempt 2: Case-insensitive fallback if initial delete failed with NOT_FOUND ---
+        if (error instanceof McpError && error.code === BaseErrorCode.NOT_FOUND) {
+            logger.info(`File not found with exact path: ${originalFilePath}. Attempting case-insensitive fallback for deletion.`, context);
+            const fallbackContext = { ...context, operation: "deleteFileFallback" };
+            try {
+                // Use POSIX path functions for vault path manipulation
+                const dirname = path.posix.dirname(originalFilePath);
+                const filenameLower = path.posix
+                    .basename(originalFilePath)
+                    .toLowerCase();
+                // Handle case where the file is in the vault root (dirname is '.')
+                const dirToList = dirname === "." ? "/" : dirname;
+                logger.debug(`Listing directory for fallback deletion: ${dirToList}`, fallbackContext);
+                const filesInDir = await retryWithDelay(() => obsidianService.listFiles(dirToList, fallbackContext), {
+                    operationName: "listFilesForDeleteFallback",
+                    context: fallbackContext,
+                    maxRetries: 3,
+                    delayMs: 300,
+                    shouldRetry: shouldRetryNotFound,
+                });
+                // Filter directory listing for files matching the lowercase filename
+                const matches = filesInDir.filter((f) => !f.endsWith("/") && // Ensure it's a file
+                    path.posix.basename(f).toLowerCase() === filenameLower);
+                if (matches.length === 1) {
+                    // Found exactly one case-insensitive match
+                    const correctFilename = path.posix.basename(matches[0]);
+                    effectiveFilePath = path.posix.join(dirname, correctFilename); // Update the path to use
+                    logger.info(`Found case-insensitive match: ${effectiveFilePath}. Retrying delete.`, fallbackContext);
+                    // Retry deleting with the correctly cased path
+                    const retryContext = {
+                        ...fallbackContext,
+                        subOperation: "retryDelete",
+                        effectiveFilePath,
+                    };
+                    await retryWithDelay(() => obsidianService.deleteFile(effectiveFilePath, retryContext), {
+                        operationName: "deleteFileFallback",
+                        context: retryContext,
+                        maxRetries: 3,
+                        delayMs: 300,
+                        shouldRetry: shouldRetryNotFound,
+                    });
+                    logger.debug(`Successfully deleted file using fallback path: ${effectiveFilePath}`, retryContext);
+                    if (vaultCacheService) {
+                        await vaultCacheService.updateCacheForFile(effectiveFilePath, retryContext);
+                    }
+                    return {
+                        success: true,
+                        message: `File '${effectiveFilePath}' (found via case-insensitive match for '${originalFilePath}') deleted successfully.`,
+                    };
+                }
+                else if (matches.length > 1) {
+                    // Ambiguous match: Multiple files match case-insensitively
+                    const errorMsg = `Deletion failed: Ambiguous case-insensitive matches for '${originalFilePath}'. Found: [${matches.join(", ")}]. Cannot determine which file to delete.`;
+                    logger.error(errorMsg, { ...fallbackContext, matches });
+                    // Use CONFLICT code for ambiguity, as NOT_FOUND isn't quite right anymore.
+                    throw new McpError(BaseErrorCode.CONFLICT, errorMsg, fallbackContext);
+                }
+                else {
+                    // No match found even with fallback
+                    const errorMsg = `Deletion failed: File not found for '${originalFilePath}' (case-insensitive fallback also failed).`;
+                    logger.error(errorMsg, fallbackContext);
+                    // Stick with NOT_FOUND as the original error reason holds.
+                    throw new McpError(BaseErrorCode.NOT_FOUND, errorMsg, fallbackContext);
+                }
+            }
+            catch (fallbackError) {
+                // Catch errors specifically from the fallback logic (e.g., listFiles error, retry delete error)
+                if (fallbackError instanceof McpError) {
+                    // Log and re-throw known errors from fallback
+                    logger.error(`McpError during fallback deletion for ${originalFilePath}: ${fallbackError.message}`, fallbackError, fallbackContext);
+                    throw fallbackError;
+                }
+                else {
+                    // Wrap unexpected fallback errors
+                    const errorMessage = `Unexpected error during case-insensitive fallback deletion for ${originalFilePath}`;
+                    logger.error(errorMessage, fallbackError instanceof Error ? fallbackError : undefined, fallbackContext);
+                    throw new McpError(BaseErrorCode.INTERNAL_ERROR, `${errorMessage}: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`, fallbackContext);
+                }
+            }
+        }
+        else {
+            // Re-throw errors from the initial delete attempt that were not NOT_FOUND or McpError
+            if (error instanceof McpError) {
+                logger.error(`McpError during initial delete attempt for ${originalFilePath}: ${error.message}`, error, context);
+                throw error;
+            }
+            else {
+                const errorMessage = `Unexpected error deleting Obsidian file ${originalFilePath}`;
+                logger.error(errorMessage, error instanceof Error ? error : undefined, context);
+                throw new McpError(BaseErrorCode.INTERNAL_ERROR, `${errorMessage}: ${error instanceof Error ? error.message : String(error)}`, context);
+            }
+        }
+    }
+};

package/dist/mcp-server/tools/obsidianDeleteFileTool/registration.d.ts

@@ -0,0 +1,19 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ObsidianRestApiService, VaultCacheService } from "../../../services/obsidianRestAPI/index.js";
+/**
+ * Registers the 'obsidian_delete_file' tool with the MCP server.
+ *
+ * This tool permanently deletes a specified file from the user's Obsidian vault.
+ * It requires the vault-relative path, including the file extension. The tool
+ * attempts a case-sensitive deletion first, followed by a case-insensitive
+ * fallback search and delete if the initial attempt fails with a 'NOT_FOUND' error.
+ *
+ * The response is a JSON string containing a success status and a confirmation message.
+ *
+ * @param {McpServer} server - The MCP server instance to register the tool with.
+ * @param {ObsidianRestApiService} obsidianService - An instance of the Obsidian REST API service
+ *   used to interact with the user's Obsidian vault.
+ * @returns {Promise<void>} A promise that resolves when the tool registration is complete or rejects on error.
+ * @throws {McpError} Throws an McpError if registration fails critically.
+ */
+export declare const registerObsidianDeleteFileTool: (server: McpServer, obsidianService: ObsidianRestApiService, vaultCacheService: VaultCacheService | undefined) => Promise<void>;

package/dist/mcp-server/tools/obsidianDeleteFileTool/registration.js

@@ -0,0 +1,91 @@
+import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
+import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js";
+import { ObsidianDeleteFileInputSchema, processObsidianDeleteFile, } from "./logic.js";
+/**
+ * Registers the 'obsidian_delete_file' tool with the MCP server.
+ *
+ * This tool permanently deletes a specified file from the user's Obsidian vault.
+ * It requires the vault-relative path, including the file extension. The tool
+ * attempts a case-sensitive deletion first, followed by a case-insensitive
+ * fallback search and delete if the initial attempt fails with a 'NOT_FOUND' error.
+ *
+ * The response is a JSON string containing a success status and a confirmation message.
+ *
+ * @param {McpServer} server - The MCP server instance to register the tool with.
+ * @param {ObsidianRestApiService} obsidianService - An instance of the Obsidian REST API service
+ *   used to interact with the user's Obsidian vault.
+ * @returns {Promise<void>} A promise that resolves when the tool registration is complete or rejects on error.
+ * @throws {McpError} Throws an McpError if registration fails critically.
+ */
+export const registerObsidianDeleteFileTool = async (server, obsidianService, vaultCacheService) => {
+    const toolName = "obsidian_delete_file";
+    // Updated description to accurately reflect the response (no timestamp)
+    const toolDescription = "Permanently deletes a specified file from the Obsidian vault. Tries the exact path first, then attempts a case-insensitive fallback if the file is not found. Requires the vault-relative path including the file extension. Returns a success message.";
+    // Create a context specifically for the registration process.
+    const registrationContext = requestContextService.createRequestContext({
+        operation: "RegisterObsidianDeleteFileTool",
+        toolName: toolName,
+        module: "ObsidianDeleteFileRegistration", // Identify the module
+    });
+    logger.info(`Attempting to register tool: ${toolName}`, registrationContext);
+    // Wrap the registration logic in a tryCatch block for robust error handling during server setup.
+    await ErrorHandler.tryCatch(async () => {
+        // Use the high-level SDK method `server.tool` for registration.
+        server.tool(toolName, toolDescription, ObsidianDeleteFileInputSchema.shape, // Provide the Zod schema shape for input definition.
+        /**
+         * The handler function executed when the 'obsidian_delete_file' tool is called by the client.
+         *
+         * @param {ObsidianDeleteFileInput} params - The input parameters received from the client,
+         *   validated against the ObsidianDeleteFileInputSchema shape.
+         * @returns {Promise<CallToolResult>} A promise resolving to the structured result for the MCP client,
+         *   containing either the successful response data (serialized JSON) or an error indication.
+         */
+        async (params) => {
+            // Type matches the inferred input schema
+            // Create a specific context for this handler invocation.
+            const handlerContext = requestContextService.createRequestContext({
+                parentContext: registrationContext, // Link to registration context
+                operation: "HandleObsidianDeleteFileRequest",
+                toolName: toolName,
+                params: { filePath: params.filePath }, // Log the file path being targeted
+            });
+            logger.debug(`Handling '${toolName}' request`, handlerContext);
+            // Wrap the core logic execution in a tryCatch block.
+            return await ErrorHandler.tryCatch(async () => {
+                // Delegate the actual file deletion logic to the processing function.
+                // Note: Input schema and shape are identical, no separate refinement parse needed here.
+                const response = await processObsidianDeleteFile(params, handlerContext, obsidianService, vaultCacheService);
+                logger.debug(`'${toolName}' processed successfully`, handlerContext);
+                // Format the successful response object from the logic function into the required MCP CallToolResult structure.
+                // The response object (success, message) is serialized to JSON.
+                return {
+                    content: [
+                        {
+                            type: "text", // Standard content type for structured JSON data
+                            text: JSON.stringify(response, null, 2), // Pretty-print JSON
+                        },
+                    ],
+                    isError: false, // Indicate successful execution
+                };
+            }, {
+                // Configuration for the inner error handler (processing logic).
+                operation: `processing ${toolName} handler`,
+                context: handlerContext,
+                input: params, // Log the full input parameters if an error occurs.
+                // Custom error mapping for consistent error reporting.
+                errorMapper: (error) => new McpError(error instanceof McpError
+                    ? error.code
+                    : BaseErrorCode.INTERNAL_ERROR, `Error processing ${toolName} tool: ${error instanceof Error ? error.message : "Unknown error"}`, { ...handlerContext }),
+            }); // End of inner ErrorHandler.tryCatch
+        }); // End of server.tool call
+        logger.info(`Tool registered successfully: ${toolName}`, registrationContext);
+    }, {
+        // Configuration for the outer error handler (registration process).
+        operation: `registering tool ${toolName}`,
+        context: registrationContext,
+        errorCode: BaseErrorCode.INTERNAL_ERROR, // Default error code for registration failure.
+        // Custom error mapping for registration failures.
+        errorMapper: (error) => new McpError(error instanceof McpError ? error.code : BaseErrorCode.INTERNAL_ERROR, `Failed to register tool '${toolName}': ${error instanceof Error ? error.message : "Unknown error"}`, { ...registrationContext }),
+        critical: true, // Treat registration failure as critical.
+    }); // End of outer ErrorHandler.tryCatch
+};

package/dist/mcp-server/tools/obsidianGlobalSearchTool/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview Barrel file for the 'obsidian_global_search' MCP tool.
+ *
+ * This file serves as the public entry point for the obsidian_global_search tool module.
+ * It re-exports the primary registration function (`registerObsidianGlobalSearchTool`)
+ * from the './registration.js' module. This pattern simplifies imports for consumers
+ * of the tool, allowing them to import necessary components from a single location.
+ *
+ * Consumers (like the main server setup) should import the registration function
+ * from this file to integrate the tool into the MCP server instance.
+ */
+export { registerObsidianGlobalSearchTool } from "./registration.js";

package/dist/mcp-server/tools/obsidianGlobalSearchTool/index.js

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview Barrel file for the 'obsidian_global_search' MCP tool.
+ *
+ * This file serves as the public entry point for the obsidian_global_search tool module.
+ * It re-exports the primary registration function (`registerObsidianGlobalSearchTool`)
+ * from the './registration.js' module. This pattern simplifies imports for consumers
+ * of the tool, allowing them to import necessary components from a single location.
+ *
+ * Consumers (like the main server setup) should import the registration function
+ * from this file to integrate the tool into the MCP server instance.
+ */
+export { registerObsidianGlobalSearchTool } from "./registration.js"; // Ensure '.js' extension for ES module resolution