obsidian-mcp-server 2.0.7 → 3.1.0

package/dist/config/index.js

@@ -1,191 +0,0 @@
-import dotenv from "dotenv";
-import { existsSync, mkdirSync, readFileSync, statSync } from "fs";
-import path, { dirname, join } from "path";
-import { fileURLToPath } from "url";
-import { z } from "zod";
-dotenv.config();
-// --- Determine Project Root ---
-/**
- * Finds the project root directory by searching upwards for package.json.
- * @param startDir The directory to start searching from.
- * @returns The absolute path to the project root, or throws an error if not found.
- */
-const findProjectRoot = (startDir) => {
-    let currentDir = startDir;
-    while (true) {
-        const packageJsonPath = join(currentDir, "package.json");
-        if (existsSync(packageJsonPath)) {
-            return currentDir;
-        }
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir) {
-            // Reached the root of the filesystem without finding package.json
-            throw new Error(`Could not find project root (package.json) starting from ${startDir}`);
-        }
-        currentDir = parentDir;
-    }
-};
-let projectRoot;
-try {
-    // For ESM, __dirname is not available directly.
-    const currentModuleDir = dirname(fileURLToPath(import.meta.url));
-    projectRoot = findProjectRoot(currentModuleDir);
-}
-catch (error) {
-    console.error(`FATAL: Error determining project root: ${error.message}`);
-    projectRoot = process.cwd();
-    console.warn(`Warning: Using process.cwd() (${projectRoot}) as fallback project root.`);
-}
-// --- End Determine Project Root ---
-const pkgPath = join(projectRoot, "package.json");
-let pkg = { name: "obsidian-mcp-server", version: "0.0.0" };
-try {
-    pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-}
-catch (error) {
-    if (process.stderr.isTTY) {
-        console.error("Warning: Could not read package.json for default config values. Using hardcoded defaults.", error);
-    }
-}
-/**
- * Zod schema for validating environment variables.
- * @private
- */
-const EnvSchema = z.object({
-    MCP_SERVER_NAME: z.string().optional(),
-    MCP_SERVER_VERSION: z.string().optional(),
-    MCP_LOG_LEVEL: z.string().default("info"),
-    LOGS_DIR: z.string().default(path.join(projectRoot, "logs")),
-    NODE_ENV: z.string().default("development"),
-    MCP_TRANSPORT_TYPE: z.enum(["stdio", "http"]).default("stdio"),
-    MCP_HTTP_PORT: z.coerce.number().int().positive().default(3010),
-    MCP_HTTP_HOST: z.string().default("127.0.0.1"),
-    MCP_ALLOWED_ORIGINS: z.string().optional(),
-    MCP_AUTH_MODE: z.enum(["jwt", "oauth"]).optional(),
-    MCP_AUTH_SECRET_KEY: z
-        .string()
-        .min(32, "MCP_AUTH_SECRET_KEY must be at least 32 characters long for security")
-        .optional(),
-    OAUTH_ISSUER_URL: z.string().url().optional(),
-    OAUTH_AUDIENCE: z.string().optional(),
-    OAUTH_JWKS_URI: z.string().url().optional(),
-    // --- Obsidian Specific Config ---
-    OBSIDIAN_API_KEY: z.string().min(1, "OBSIDIAN_API_KEY cannot be empty"),
-    OBSIDIAN_BASE_URL: z.string().url().default("http://127.0.0.1:27123"),
-    OBSIDIAN_VERIFY_SSL: z
-        .string()
-        .transform((val) => val.toLowerCase() === "true")
-        .default("false"),
-    OBSIDIAN_CACHE_REFRESH_INTERVAL_MIN: z.coerce
-        .number()
-        .int()
-        .positive()
-        .default(10),
-    OBSIDIAN_ENABLE_CACHE: z
-        .string()
-        .transform((val) => val.toLowerCase() === "true")
-        .default("true"),
-    OBSIDIAN_API_SEARCH_TIMEOUT_MS: z.coerce
-        .number()
-        .int()
-        .positive()
-        .default(30000),
-});
-const parsedEnv = EnvSchema.safeParse(process.env);
-if (!parsedEnv.success) {
-    const errorDetails = parsedEnv.error.flatten().fieldErrors;
-    if (process.stderr.isTTY) {
-        console.error("❌ Invalid environment variables:", errorDetails);
-    }
-    throw new Error(`Invalid environment configuration. Please check your .env file or environment variables. Details: ${JSON.stringify(errorDetails)}`);
-}
-const env = parsedEnv.data;
-// --- Directory Ensurance Function ---
-const ensureDirectory = (dirPath, rootDir, dirName) => {
-    const resolvedDirPath = path.isAbsolute(dirPath)
-        ? dirPath
-        : path.resolve(rootDir, dirPath);
-    if (!resolvedDirPath.startsWith(rootDir + path.sep) &&
-        resolvedDirPath !== rootDir) {
-        if (process.stderr.isTTY) {
-            console.error(`Error: ${dirName} path "${dirPath}" resolves to "${resolvedDirPath}", which is outside the project boundary "${rootDir}".`);
-        }
-        return null;
-    }
-    if (!existsSync(resolvedDirPath)) {
-        try {
-            mkdirSync(resolvedDirPath, { recursive: true });
-        }
-        catch (err) {
-            if (process.stderr.isTTY) {
-                console.error(`Error creating ${dirName} directory at ${resolvedDirPath}: ${err instanceof Error ? err.message : String(err)}`);
-            }
-            return null;
-        }
-    }
-    else {
-        try {
-            if (!statSync(resolvedDirPath).isDirectory()) {
-                if (process.stderr.isTTY) {
-                    console.error(`Error: ${dirName} path ${resolvedDirPath} exists but is not a directory.`);
-                }
-                return null;
-            }
-        }
-        catch (statError) {
-            if (process.stderr.isTTY) {
-                console.error(`Error accessing ${dirName} path ${resolvedDirPath}: ${statError.message}`);
-            }
-            return null;
-        }
-    }
-    return resolvedDirPath;
-};
-// --- End Directory Ensurance Function ---
-const validatedLogsPath = ensureDirectory(env.LOGS_DIR, projectRoot, "logs");
-if (!validatedLogsPath) {
-    if (process.stderr.isTTY) {
-        console.error("FATAL: Logs directory configuration is invalid or could not be created. Please check permissions and path. Exiting.");
-    }
-    process.exit(1);
-}
-/**
- * Main application configuration object.
- */
-export const config = {
-    pkg,
-    mcpServerName: env.MCP_SERVER_NAME || pkg.name,
-    mcpServerVersion: env.MCP_SERVER_VERSION || pkg.version,
-    logLevel: env.MCP_LOG_LEVEL,
-    logsPath: validatedLogsPath,
-    environment: env.NODE_ENV,
-    mcpTransportType: env.MCP_TRANSPORT_TYPE,
-    mcpHttpPort: env.MCP_HTTP_PORT,
-    mcpHttpHost: env.MCP_HTTP_HOST,
-    mcpAllowedOrigins: env.MCP_ALLOWED_ORIGINS?.split(",")
-        .map((origin) => origin.trim())
-        .filter(Boolean),
-    mcpAuthMode: env.MCP_AUTH_MODE,
-    mcpAuthSecretKey: env.MCP_AUTH_SECRET_KEY,
-    oauthIssuerUrl: env.OAUTH_ISSUER_URL,
-    oauthAudience: env.OAUTH_AUDIENCE,
-    oauthJwksUri: env.OAUTH_JWKS_URI,
-    obsidianApiKey: env.OBSIDIAN_API_KEY,
-    obsidianBaseUrl: env.OBSIDIAN_BASE_URL,
-    obsidianVerifySsl: env.OBSIDIAN_VERIFY_SSL,
-    obsidianCacheRefreshIntervalMin: env.OBSIDIAN_CACHE_REFRESH_INTERVAL_MIN,
-    obsidianEnableCache: env.OBSIDIAN_ENABLE_CACHE,
-    obsidianApiSearchTimeoutMs: env.OBSIDIAN_API_SEARCH_TIMEOUT_MS,
-};
-/**
- * The configured logging level for the application.
- * Exported separately for convenience (e.g., logger initialization).
- * @type {string}
- */
-export const logLevel = config.logLevel;
-/**
- * The configured runtime environment for the application.
- * Exported separately for convenience.
- * @type {string}
- */
-export const environment = config.environment;

package/dist/mcp-server/server.d.ts

@@ -1,33 +0,0 @@
-/**
- * @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 { ServerType } from "@hono/node-server";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { ObsidianRestApiService } from "../services/obsidianRestAPI/index.js";
-import { VaultCacheService } from "../services/obsidianRestAPI/vaultCache/index.js";
-/**
- * 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 declare function initializeAndStartServer(obsidianService: ObsidianRestApiService, vaultCacheService: VaultCacheService | undefined): Promise<void | McpServer | ServerType>;

package/dist/mcp-server/server.js

@@ -1,211 +0,0 @@
-/**
- * @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 { registerObsidianDeleteNoteTool } from "./tools/obsidianDeleteNoteTool/index.js";
-import { registerObsidianGlobalSearchTool } from "./tools/obsidianGlobalSearchTool/index.js";
-import { registerObsidianListNotesTool } from "./tools/obsidianListNotesTool/index.js";
-import { registerObsidianReadNoteTool } from "./tools/obsidianReadNoteTool/index.js";
-import { registerObsidianSearchReplaceTool } from "./tools/obsidianSearchReplaceTool/index.js";
-import { registerObsidianUpdateNoteTool } from "./tools/obsidianUpdateNoteTool/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 registerObsidianListNotesTool(server, obsidianService);
-        await registerObsidianReadNoteTool(server, obsidianService);
-        await registerObsidianDeleteNoteTool(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 registerObsidianUpdateNoteTool(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/obsidianDeleteNoteTool/index.d.ts

@@ -1,12 +0,0 @@
-/**
- * @fileoverview Barrel file for the 'obsidian_delete_note' MCP tool.
- *
- * This file serves as the public entry point for the obsidian_delete_note tool module.
- * It re-exports the primary registration function (`registerObsidianDeleteNoteTool`)
- * 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 { registerObsidianDeleteNoteTool } from "./registration.js";

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

@@ -1,12 +0,0 @@
-/**
- * @fileoverview Barrel file for the 'obsidian_delete_note' MCP tool.
- *
- * This file serves as the public entry point for the obsidian_delete_note tool module.
- * It re-exports the primary registration function (`registerObsidianDeleteNoteTool`)
- * 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 { registerObsidianDeleteNoteTool } from "./registration.js";

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

@@ -1,51 +0,0 @@
-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_note' tool.
- */
-export declare const ObsidianDeleteNoteInputSchema: 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 (`ObsidianDeleteNoteInputSchema`).
- * Represents the validated input parameters used within the core processing logic.
- */
-export type ObsidianDeleteNoteInput = z.infer<typeof ObsidianDeleteNoteInputSchema>;
-/**
- * Defines the structure of the successful response returned by the `processObsidianDeleteNote` function.
- * This object is typically serialized to JSON and sent back to the client.
- */
-export interface ObsidianDeleteNoteResponse {
-    /** 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 {ObsidianDeleteNoteInput} 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<ObsidianDeleteNoteResponse>} 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 processObsidianDeleteNote: (params: ObsidianDeleteNoteInput, context: RequestContext, obsidianService: ObsidianRestApiService, vaultCacheService: VaultCacheService | undefined) => Promise<ObsidianDeleteNoteResponse>;