obsidian-mcp-server 2.0.6 → 3.0.0

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

@@ -1,111 +0,0 @@
-import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
-import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js";
-import { ObsidianSearchReplaceInputSchema, ObsidianSearchReplaceInputSchemaShape, processObsidianSearchReplace, } from "./logic.js";
-/**
- * Registers the 'obsidian_search_replace' tool with the MCP server.
- *
- * This tool performs one or more search-and-replace operations within a specified
- * Obsidian note (identified by file path, the active file, or a periodic note).
- * It reads the note content, applies the replacements sequentially based on the
- * provided options (regex, case sensitivity, etc.), writes the modified content
- * back to the vault, and returns the operation results.
- *
- * The response includes success status, a summary message, the total number of
- * replacements made, formatted file statistics (timestamp, token count), and
- * optionally the final content of the note.
- *
- * @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 registerObsidianSearchReplaceTool = async (server, obsidianService, vaultCacheService) => {
-    const toolName = "obsidian_search_replace";
-    const toolDescription = "Performs one or more search-and-replace operations within a target Obsidian note (file path, active, or periodic). Reads the file, applies replacements sequentially in memory, and writes the modified content back, overwriting the original. Supports string/regex search, case sensitivity toggle, replacing first/all occurrences, flexible whitespace matching (non-regex), and whole word matching. Returns success status, message, replacement count, a formatted timestamp string, file stats (stats), and optionally the final file content.";
-    // Create a context specifically for the registration process.
-    const registrationContext = requestContextService.createRequestContext({
-        operation: "RegisterObsidianSearchReplaceTool",
-        toolName: toolName,
-        module: "ObsidianSearchReplaceRegistration", // 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.
-        // It handles schema generation from the shape, basic validation, and routing.
-        server.tool(toolName, toolDescription, ObsidianSearchReplaceInputSchemaShape, // Provide the base Zod schema shape for input definition.
-        /**
-         * The handler function executed when the 'obsidian_search_replace' tool is called by the client.
-         *
-         * @param {ObsidianSearchReplaceRegistrationInput} params - The raw input parameters received from the client,
-         *   matching the structure defined by ObsidianSearchReplaceInputSchemaShape.
-         * @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) => {
-            // Create a specific context for this handler invocation, linked to the registration context.
-            const handlerContext = requestContextService.createRequestContext({
-                parentContext: registrationContext,
-                operation: "HandleObsidianSearchReplaceRequest",
-                toolName: toolName,
-                params: {
-                    // Log key parameters for debugging (excluding potentially large replacements array)
-                    targetType: params.targetType,
-                    targetIdentifier: params.targetIdentifier,
-                    replacementCount: params.replacements?.length ?? 0, // Log count instead of full array
-                    useRegex: params.useRegex,
-                    replaceAll: params.replaceAll,
-                    caseSensitive: params.caseSensitive,
-                    flexibleWhitespace: params.flexibleWhitespace,
-                    wholeWord: params.wholeWord,
-                    returnContent: params.returnContent,
-                },
-            });
-            logger.debug(`Handling '${toolName}' request`, handlerContext);
-            // Wrap the core logic execution in a tryCatch block for handling errors during processing.
-            return await ErrorHandler.tryCatch(async () => {
-                // **Crucial Step:** Explicitly parse and validate the raw input parameters using the
-                // *refined* Zod schema (`ObsidianSearchReplaceInputSchema`). This applies stricter rules
-                // and cross-field validations defined in logic.ts.
-                const validatedParams = ObsidianSearchReplaceInputSchema.parse(params);
-                logger.debug(`Input parameters successfully validated against refined schema.`, handlerContext);
-                // Delegate the actual search/replace logic to the dedicated processing function.
-                // Pass the *validated* parameters, the handler context, and the Obsidian service instance.
-                const response = await processObsidianSearchReplace(validatedParams, 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 entire response object (containing success, message, count, stat, etc.) is serialized to JSON.
-                return {
-                    content: [
-                        {
-                            type: "text", // Standard content type for structured JSON data
-                            text: JSON.stringify(response, null, 2), // Pretty-print JSON for readability
-                        },
-                    ],
-                    isError: false, // Indicate successful execution to the client
-                };
-            }, {
-                // Configuration for the inner error handler (processing logic).
-                operation: `processing ${toolName} handler`,
-                context: handlerContext,
-                input: params, // Log the full raw input parameters if an error occurs during processing.
-                // Custom error mapping to ensure consistent McpError format is returned to the client.
-                errorMapper: (error) => new McpError(
-                // Use the specific code from McpError if available, otherwise default to INTERNAL_ERROR.
-                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, potentially halting server startup.
-    }); // End of outer ErrorHandler.tryCatch
-};

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

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

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

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

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

@@ -1,183 +0,0 @@
-import { z } from "zod";
-import { ObsidianRestApiService, VaultCacheService } from "../../../services/obsidianRestAPI/index.js";
-import { RequestContext } from "../../../utils/index.js";
-/**
- * Zod schema used for registering the tool with the MCP SDK (`server.tool`).
- * This schema defines the expected input structure from the client's perspective.
- * It flattens the structure slightly by making mode-specific fields optional at this stage,
- * relying on the refined schema (`ObsidianUpdateFileInputSchema`) for stricter validation
- * within the handler logic.
- */
-declare const ObsidianUpdateNoteRegistrationSchema: z.ZodObject<{
-    /** Specifies the target note: 'filePath' (requires targetIdentifier), 'activeFile' (currently open file), or 'periodicNote' (requires targetIdentifier with period like 'daily'). */
-    targetType: z.ZodEnum<["filePath", "activeFile", "periodicNote"]>;
-    /** The content for the modification. Must be a string for whole-file operations. */
-    content: z.ZodString;
-    /** Identifier for the target when targetType is 'filePath' (vault-relative path, e.g., 'Notes/My File.md') or 'periodicNote' (period string: 'daily', 'weekly', etc.). Not used for 'activeFile'. */
-    targetIdentifier: z.ZodOptional<z.ZodString>;
-    /** Determines the modification strategy: must be 'wholeFile'. */
-    modificationType: z.ZodLiteral<"wholeFile">;
-    /** For 'wholeFile' mode: 'append', 'prepend', or 'overwrite'. Required if modificationType is 'wholeFile'. */
-    wholeFileMode: z.ZodOptional<z.ZodEnum<["append", "prepend", "overwrite"]>>;
-    /** For 'wholeFile' mode: If true (default), creates the target file/note if it doesn't exist before modifying. If false, fails if the target doesn't exist. */
-    createIfNeeded: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** For 'wholeFile' mode with 'overwrite': If false (default), the operation fails if the target file already exists. If true, allows overwriting the existing file. */
-    overwriteIfExists: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** If true, returns the final content of the file in the response. Defaults to false. */
-    returnContent: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    content: string;
-    targetType: "filePath" | "activeFile" | "periodicNote";
-    returnContent: boolean;
-    modificationType: "wholeFile";
-    createIfNeeded: boolean;
-    overwriteIfExists: boolean;
-    targetIdentifier?: string | undefined;
-    wholeFileMode?: "append" | "prepend" | "overwrite" | undefined;
-}, {
-    content: string;
-    targetType: "filePath" | "activeFile" | "periodicNote";
-    modificationType: "wholeFile";
-    targetIdentifier?: string | undefined;
-    returnContent?: boolean | undefined;
-    wholeFileMode?: "append" | "prepend" | "overwrite" | undefined;
-    createIfNeeded?: boolean | undefined;
-    overwriteIfExists?: boolean | undefined;
-}>;
-/**
- * The shape of the registration schema, used by `server.tool` for basic validation.
- * @see ObsidianUpdateFileRegistrationSchema
- */
-export declare const ObsidianUpdateNoteInputSchemaShape: {
-    /** Specifies the target note: 'filePath' (requires targetIdentifier), 'activeFile' (currently open file), or 'periodicNote' (requires targetIdentifier with period like 'daily'). */
-    targetType: z.ZodEnum<["filePath", "activeFile", "periodicNote"]>;
-    /** The content for the modification. Must be a string for whole-file operations. */
-    content: z.ZodString;
-    /** Identifier for the target when targetType is 'filePath' (vault-relative path, e.g., 'Notes/My File.md') or 'periodicNote' (period string: 'daily', 'weekly', etc.). Not used for 'activeFile'. */
-    targetIdentifier: z.ZodOptional<z.ZodString>;
-    /** Determines the modification strategy: must be 'wholeFile'. */
-    modificationType: z.ZodLiteral<"wholeFile">;
-    /** For 'wholeFile' mode: 'append', 'prepend', or 'overwrite'. Required if modificationType is 'wholeFile'. */
-    wholeFileMode: z.ZodOptional<z.ZodEnum<["append", "prepend", "overwrite"]>>;
-    /** For 'wholeFile' mode: If true (default), creates the target file/note if it doesn't exist before modifying. If false, fails if the target doesn't exist. */
-    createIfNeeded: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** For 'wholeFile' mode with 'overwrite': If false (default), the operation fails if the target file already exists. If true, allows overwriting the existing file. */
-    overwriteIfExists: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** If true, returns the final content of the file in the response. Defaults to false. */
-    returnContent: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-};
-/**
- * TypeScript type inferred from the registration schema. Represents the raw input
- * received by the tool handler *before* refinement.
- * @see ObsidianUpdateFileRegistrationSchema
- */
-export type ObsidianUpdateNoteRegistrationInput = z.infer<typeof ObsidianUpdateNoteRegistrationSchema>;
-/**
- * Refined Zod schema used internally within the tool's logic for strict validation.
- * It builds upon `WholeFileUpdateSchema` and adds cross-field validation rules using `.refine()`.
- * This ensures that `targetIdentifier` is provided and valid when required by `targetType`.
- */
-export declare const ObsidianUpdateNoteInputSchema: z.ZodEffects<z.ZodObject<{
-    /** Specifies the type of target note. */
-    targetType: z.ZodEnum<["filePath", "activeFile", "periodicNote"]>;
-    /** The content to use for the modification. Must be a string for whole-file operations. */
-    content: z.ZodString;
-    /**
-     * Identifier for the target. Required and must be a vault-relative path if targetType is 'filePath'.
-     * Required and must be a valid period string (e.g., 'daily') if targetType is 'periodicNote'.
-     * Not used if targetType is 'activeFile'.
-     */
-    targetIdentifier: z.ZodOptional<z.ZodString>;
-} & {
-    /** The modification type, fixed to 'wholeFile'. */
-    modificationType: z.ZodLiteral<"wholeFile">;
-    /** The specific whole-file operation ('append', 'prepend', 'overwrite'). */
-    wholeFileMode: z.ZodEnum<["append", "prepend", "overwrite"]>;
-    /** If true (default), creates the target file/note if it doesn't exist before applying the modification. If false, the operation fails if the target doesn't exist. */
-    createIfNeeded: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** Only relevant for 'overwrite' mode. If true, allows overwriting an existing file. If false (default) and the file exists, the 'overwrite' operation fails. */
-    overwriteIfExists: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** If true, includes the final content of the modified file in the response. Defaults to false. */
-    returnContent: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    content: string;
-    targetType: "filePath" | "activeFile" | "periodicNote";
-    returnContent: boolean;
-    modificationType: "wholeFile";
-    wholeFileMode: "append" | "prepend" | "overwrite";
-    createIfNeeded: boolean;
-    overwriteIfExists: boolean;
-    targetIdentifier?: string | undefined;
-}, {
-    content: string;
-    targetType: "filePath" | "activeFile" | "periodicNote";
-    modificationType: "wholeFile";
-    wholeFileMode: "append" | "prepend" | "overwrite";
-    targetIdentifier?: string | undefined;
-    returnContent?: boolean | undefined;
-    createIfNeeded?: boolean | undefined;
-    overwriteIfExists?: boolean | undefined;
-}>, {
-    content: string;
-    targetType: "filePath" | "activeFile" | "periodicNote";
-    returnContent: boolean;
-    modificationType: "wholeFile";
-    wholeFileMode: "append" | "prepend" | "overwrite";
-    createIfNeeded: boolean;
-    overwriteIfExists: boolean;
-    targetIdentifier?: string | undefined;
-}, {
-    content: string;
-    targetType: "filePath" | "activeFile" | "periodicNote";
-    modificationType: "wholeFile";
-    wholeFileMode: "append" | "prepend" | "overwrite";
-    targetIdentifier?: string | undefined;
-    returnContent?: boolean | undefined;
-    createIfNeeded?: boolean | undefined;
-    overwriteIfExists?: boolean | undefined;
-}>;
-/**
- * TypeScript type inferred from the *refined* input schema (`ObsidianUpdateFileInputSchema`).
- * This type represents the validated and structured input used within the core processing logic.
- */
-export type ObsidianUpdateNoteInput = z.infer<typeof ObsidianUpdateNoteInputSchema>;
-/**
- * Represents the structure of file statistics after formatting, including
- * human-readable timestamps and an estimated token count.
- */
-type FormattedStat = {
-    /** Creation time formatted as a standard date-time string. */
-    createdTime: string;
-    /** Last modified time formatted as a standard date-time string. */
-    modifiedTime: string;
-    /** Estimated token count of the file content (using tiktoken 'gpt-4o'). */
-    tokenCountEstimate: number;
-};
-/**
- * Defines the structure of the successful response returned by the `processObsidianUpdateFile` function.
- * This object is typically serialized to JSON and sent back to the client.
- */
-export interface ObsidianUpdateNoteResponse {
-    /** Indicates whether the operation was successful. */
-    success: boolean;
-    /** A human-readable message describing the outcome of the operation. */
-    message: string;
-    /** Optional file statistics (creation/modification times, token count) if the file could be read after the update. */
-    stats?: FormattedStat;
-    /** Optional final content of the file, included only if `returnContent` was true in the request and the file could be read. */
-    finalContent?: string;
-}
-/**
- * Processes the core logic for the 'obsidian_update_file' tool when using the 'wholeFile'
- * modification type (append, prepend, overwrite). It handles pre-checks, performs the
- * update via the Obsidian REST API, retrieves the final state, and constructs the response.
- *
- * @param {ObsidianUpdateFileInput} params - The validated input parameters conforming to the refined schema.
- * @param {RequestContext} context - The request context for logging and correlation.
- * @param {ObsidianRestApiService} obsidianService - The instance of the Obsidian REST API service.
- * @returns {Promise<ObsidianUpdateFileResponse>} A promise resolving to the structured success response.
- * @throws {McpError} Throws an McpError if validation fails or the API interaction results in an error.
- */
-export declare const processObsidianUpdateNote: (params: ObsidianUpdateNoteInput, // Use the refined, validated type
-context: RequestContext, obsidianService: ObsidianRestApiService, vaultCacheService: VaultCacheService | undefined) => Promise<ObsidianUpdateNoteResponse>;
-export {};