obsidian-mcp-server 2.0.7 → 3.1.0

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

@@ -1,101 +0,0 @@
-import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
-import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js";
-import { ObsidianReadNoteInputSchema, processObsidianReadNote, } from "./logic.js";
-/**
- * Registers the 'obsidian_read_note' tool with the MCP server.
- *
- * This tool retrieves the content and optionally metadata of a specified file
- * within the user's Obsidian vault. It supports specifying the output format
- * ('markdown' or 'json') and includes a case-insensitive fallback mechanism
- * if the exact file path is not found initially.
- *
- * The response is a JSON string containing the file content in the requested format
- * and optionally formatted file statistics (timestamps, token count).
- *
- * @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 registerObsidianReadNoteTool = async (server, obsidianService) => {
-    const toolName = "obsidian_read_note";
-    const toolDescription = "Retrieves the content and metadata of a specified file within the Obsidian vault. Tries the exact path first, then attempts a case-insensitive fallback. Returns an object containing the content (markdown string or full NoteJson object based on 'format'), and optionally formatted file stats ('stats' object with creationTime, modifiedTime, tokenCountEstimate). Use 'includeStat: true' with 'format: markdown' to include stats; stats are always included with 'format: json'.";
-    // Create a context specifically for the registration process.
-    const registrationContext = requestContextService.createRequestContext({
-        operation: "RegisterObsidianReadNoteTool",
-        toolName: toolName,
-        module: "ObsidianReadNoteRegistration", // 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, ObsidianReadNoteInputSchema.shape, // Provide the Zod schema shape for input definition.
-        /**
-         * The handler function executed when the 'obsidian_read_note' tool is called by the client.
-         *
-         * @param {ObsidianReadNoteInput} params - The input parameters received from the client,
-         *   validated against the ObsidianReadNoteInputSchema shape. Note: The handler receives the raw input;
-         *   stricter validation against the full schema should happen inside if needed, though in this case,
-         *   the shape and the full schema are identical.
-         * @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: "HandleObsidianReadNoteRequest",
-                toolName: toolName,
-                params: {
-                    // Log key parameters for debugging
-                    filePath: params.filePath,
-                    format: params.format,
-                    includeStat: params.includeStat,
-                },
-            });
-            logger.debug(`Handling '${toolName}' request`, handlerContext);
-            // Wrap the core logic execution in a tryCatch block.
-            return await ErrorHandler.tryCatch(async () => {
-                // Delegate the actual file reading logic to the dedicated processing function.
-                // Pass the (already shape-validated) parameters, context, and the Obsidian service.
-                // The process function handles the refined validation internally if needed, but here shape = refined.
-                const response = await processObsidianReadNote(params, // Pass params directly as shape matches refined schema
-                handlerContext, obsidianService);
-                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 content and optional stat) 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/obsidianSearchReplaceTool/index.d.ts

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

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

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

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

@@ -1,255 +0,0 @@
-import { z } from "zod";
-import { ObsidianRestApiService, VaultCacheService } from "../../../services/obsidianRestAPI/index.js";
-import { RequestContext } from "../../../utils/index.js";
-/**
- * Base Zod schema object containing fields common to the search/replace tool input.
- * This is used as the foundation for both the registration shape and the refined internal schema.
- */
-declare const BaseObsidianSearchReplaceInputSchema: z.ZodObject<{
-    /** Specifies the target note: 'filePath', 'activeFile', or 'periodicNote'. */
-    targetType: z.ZodEnum<["filePath", "activeFile", "periodicNote"]>;
-    /**
-     * 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'. The tool attempts a case-insensitive fallback if the exact filePath is not found.
-     */
-    targetIdentifier: z.ZodOptional<z.ZodString>;
-    /** An array of one or more search/replace operations to perform sequentially on the note content. */
-    replacements: z.ZodArray<z.ZodObject<{
-        /** The exact string or regex pattern to search for within the note content. Cannot be empty. */
-        search: z.ZodString;
-        /** The string to replace each match with. An empty string effectively deletes the matched text. */
-        replace: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        replace: string;
-        search: string;
-    }, {
-        replace: string;
-        search: string;
-    }>, "many">;
-    /** If true, treats the 'search' field in each replacement block as a JavaScript regular expression pattern. Defaults to false (exact string matching). */
-    useRegex: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** If true (default), replaces all occurrences matching each search pattern within the note. If false, replaces only the first occurrence of each pattern. */
-    replaceAll: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** If true (default), the search operation is case-sensitive. If false, it's case-insensitive. Applies to both string and regex searches. */
-    caseSensitive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** If true (and useRegex is false), treats sequences of whitespace in the search string as matching one or more whitespace characters (\s+). Defaults to false. Cannot be true if useRegex is true. */
-    flexibleWhitespace: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** If true, ensures the search term matches only whole words by implicitly adding word boundaries (\b) around the pattern (unless boundaries already exist in regex). Applies to both regex and non-regex modes. Defaults to false. */
-    wholeWord: 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, {
-    caseSensitive: boolean;
-    useRegex: boolean;
-    targetType: "filePath" | "activeFile" | "periodicNote";
-    replacements: {
-        replace: string;
-        search: string;
-    }[];
-    replaceAll: boolean;
-    flexibleWhitespace: boolean;
-    wholeWord: boolean;
-    returnContent: boolean;
-    targetIdentifier?: string | undefined;
-}, {
-    targetType: "filePath" | "activeFile" | "periodicNote";
-    replacements: {
-        replace: string;
-        search: string;
-    }[];
-    caseSensitive?: boolean | undefined;
-    useRegex?: boolean | undefined;
-    targetIdentifier?: string | undefined;
-    replaceAll?: boolean | undefined;
-    flexibleWhitespace?: boolean | undefined;
-    wholeWord?: boolean | undefined;
-    returnContent?: boolean | undefined;
-}>;
-/**
- * Refined Zod schema used internally within the tool's logic for strict validation.
- * It builds upon `BaseObsidianSearchReplaceInputSchema` and adds cross-field validation rules:
- * 1. Ensures `targetIdentifier` is provided and valid when required by `targetType`.
- * 2. Ensures `flexibleWhitespace` is not used concurrently with `useRegex`.
- */
-export declare const ObsidianSearchReplaceInputSchema: z.ZodEffects<z.ZodObject<{
-    /** Specifies the target note: 'filePath', 'activeFile', or 'periodicNote'. */
-    targetType: z.ZodEnum<["filePath", "activeFile", "periodicNote"]>;
-    /**
-     * 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'. The tool attempts a case-insensitive fallback if the exact filePath is not found.
-     */
-    targetIdentifier: z.ZodOptional<z.ZodString>;
-    /** An array of one or more search/replace operations to perform sequentially on the note content. */
-    replacements: z.ZodArray<z.ZodObject<{
-        /** The exact string or regex pattern to search for within the note content. Cannot be empty. */
-        search: z.ZodString;
-        /** The string to replace each match with. An empty string effectively deletes the matched text. */
-        replace: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        replace: string;
-        search: string;
-    }, {
-        replace: string;
-        search: string;
-    }>, "many">;
-    /** If true, treats the 'search' field in each replacement block as a JavaScript regular expression pattern. Defaults to false (exact string matching). */
-    useRegex: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** If true (default), replaces all occurrences matching each search pattern within the note. If false, replaces only the first occurrence of each pattern. */
-    replaceAll: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** If true (default), the search operation is case-sensitive. If false, it's case-insensitive. Applies to both string and regex searches. */
-    caseSensitive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** If true (and useRegex is false), treats sequences of whitespace in the search string as matching one or more whitespace characters (\s+). Defaults to false. Cannot be true if useRegex is true. */
-    flexibleWhitespace: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** If true, ensures the search term matches only whole words by implicitly adding word boundaries (\b) around the pattern (unless boundaries already exist in regex). Applies to both regex and non-regex modes. Defaults to false. */
-    wholeWord: 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, {
-    caseSensitive: boolean;
-    useRegex: boolean;
-    targetType: "filePath" | "activeFile" | "periodicNote";
-    replacements: {
-        replace: string;
-        search: string;
-    }[];
-    replaceAll: boolean;
-    flexibleWhitespace: boolean;
-    wholeWord: boolean;
-    returnContent: boolean;
-    targetIdentifier?: string | undefined;
-}, {
-    targetType: "filePath" | "activeFile" | "periodicNote";
-    replacements: {
-        replace: string;
-        search: string;
-    }[];
-    caseSensitive?: boolean | undefined;
-    useRegex?: boolean | undefined;
-    targetIdentifier?: string | undefined;
-    replaceAll?: boolean | undefined;
-    flexibleWhitespace?: boolean | undefined;
-    wholeWord?: boolean | undefined;
-    returnContent?: boolean | undefined;
-}>, {
-    caseSensitive: boolean;
-    useRegex: boolean;
-    targetType: "filePath" | "activeFile" | "periodicNote";
-    replacements: {
-        replace: string;
-        search: string;
-    }[];
-    replaceAll: boolean;
-    flexibleWhitespace: boolean;
-    wholeWord: boolean;
-    returnContent: boolean;
-    targetIdentifier?: string | undefined;
-}, {
-    targetType: "filePath" | "activeFile" | "periodicNote";
-    replacements: {
-        replace: string;
-        search: string;
-    }[];
-    caseSensitive?: boolean | undefined;
-    useRegex?: boolean | undefined;
-    targetIdentifier?: string | undefined;
-    replaceAll?: boolean | undefined;
-    flexibleWhitespace?: boolean | undefined;
-    wholeWord?: boolean | undefined;
-    returnContent?: boolean | undefined;
-}>;
-/**
- * The shape of the base input schema, used by `server.tool` for registration and initial validation.
- * @see BaseObsidianSearchReplaceInputSchema
- */
-export declare const ObsidianSearchReplaceInputSchemaShape: {
-    /** Specifies the target note: 'filePath', 'activeFile', or 'periodicNote'. */
-    targetType: z.ZodEnum<["filePath", "activeFile", "periodicNote"]>;
-    /**
-     * 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'. The tool attempts a case-insensitive fallback if the exact filePath is not found.
-     */
-    targetIdentifier: z.ZodOptional<z.ZodString>;
-    /** An array of one or more search/replace operations to perform sequentially on the note content. */
-    replacements: z.ZodArray<z.ZodObject<{
-        /** The exact string or regex pattern to search for within the note content. Cannot be empty. */
-        search: z.ZodString;
-        /** The string to replace each match with. An empty string effectively deletes the matched text. */
-        replace: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        replace: string;
-        search: string;
-    }, {
-        replace: string;
-        search: string;
-    }>, "many">;
-    /** If true, treats the 'search' field in each replacement block as a JavaScript regular expression pattern. Defaults to false (exact string matching). */
-    useRegex: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** If true (default), replaces all occurrences matching each search pattern within the note. If false, replaces only the first occurrence of each pattern. */
-    replaceAll: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** If true (default), the search operation is case-sensitive. If false, it's case-insensitive. Applies to both string and regex searches. */
-    caseSensitive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** If true (and useRegex is false), treats sequences of whitespace in the search string as matching one or more whitespace characters (\s+). Defaults to false. Cannot be true if useRegex is true. */
-    flexibleWhitespace: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** If true, ensures the search term matches only whole words by implicitly adding word boundaries (\b) around the pattern (unless boundaries already exist in regex). Applies to both regex and non-regex modes. Defaults to false. */
-    wholeWord: 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>>;
-};
-/**
- * TypeScript type inferred from the base registration schema. Represents the raw input
- * received by the tool handler *before* refinement.
- * @see BaseObsidianSearchReplaceInputSchema
- */
-export type ObsidianSearchReplaceRegistrationInput = z.infer<typeof BaseObsidianSearchReplaceInputSchema>;
-/**
- * TypeScript type inferred from the *refined* input schema (`ObsidianSearchReplaceInputSchema`).
- * This type represents the validated and structured input used within the core processing logic.
- */
-export type ObsidianSearchReplaceInput = z.infer<typeof ObsidianSearchReplaceInputSchema>;
-/**
- * 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 `processObsidianSearchReplace` function.
- * This object is typically serialized to JSON and sent back to the client.
- */
-export interface ObsidianSearchReplaceResponse {
-    /** Indicates whether the operation was successful. */
-    success: boolean;
-    /** A human-readable message describing the outcome of the operation (e.g., number of replacements). */
-    message: string;
-    /** The total number of replacements made across all search/replace blocks. */
-    totalReplacementsMade: number;
-    /** 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. */
-    finalContent?: string;
-}
-/**
- * Processes the core logic for the 'obsidian_search_replace' tool.
- * Reads the target note content, performs a sequence of search and replace operations
- * based on the provided parameters (handling regex, case sensitivity, etc.),
- * writes the modified content back to Obsidian, retrieves the final state,
- * and constructs the response object.
- *
- * @param {ObsidianSearchReplaceInput} 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<ObsidianSearchReplaceResponse>} A promise resolving to the structured success response.
- * @throws {McpError} Throws an McpError if validation fails, reading/writing fails, or an unexpected error occurs during processing.
- */
-export declare const processObsidianSearchReplace: (params: ObsidianSearchReplaceInput, // Use the refined, validated type
-context: RequestContext, obsidianService: ObsidianRestApiService, vaultCacheService: VaultCacheService | undefined) => Promise<ObsidianSearchReplaceResponse>;
-export {};