obsidian-mcp-server 2.0.6 → 3.0.0

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

@@ -1,583 +0,0 @@
-import path from "node:path"; // For file path fallback logic using POSIX separators
-import { z } from "zod";
-import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
-import { createFormattedStatWithTokenCount, logger, retryWithDelay, } from "../../../utils/index.js";
-// ====================================================================================
-// Schema Definitions for Input Validation
-// ====================================================================================
-/** Defines the possible types of targets for the search/replace operation. */
-const TargetTypeSchema = z
-    .enum(["filePath", "activeFile", "periodicNote"])
-    .describe("Specifies the target note: 'filePath', 'activeFile', or 'periodicNote'.");
-/** Defines the valid periods for periodic notes. */
-const PeriodicNotePeriodSchema = z
-    .enum(["daily", "weekly", "monthly", "quarterly", "yearly"])
-    .describe("Valid periods for 'periodicNote' target type.");
-/**
- * Defines the structure for a single search and replace operation block.
- */
-const ReplacementBlockSchema = z.object({
-    /** The exact string or regex pattern to search for within the note content. Cannot be empty. */
-    search: z
-        .string()
-        .min(1, "Search pattern cannot be empty.")
-        .describe("The exact string or regex pattern to search for."),
-    /** The string to replace each match with. An empty string effectively deletes the matched text. */
-    replace: z.string().describe("The string to replace matches with."),
-});
-/**
- * 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.
- */
-const BaseObsidianSearchReplaceInputSchema = z.object({
-    /** Specifies the target note: 'filePath', 'activeFile', or 'periodicNote'. */
-    targetType: TargetTypeSchema,
-    /**
-     * 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
-        .string()
-        .optional()
-        .describe("Required if targetType is 'filePath' (vault-relative path) or 'periodicNote' (period string: 'daily', etc.). Tries case-insensitive fallback for filePath."),
-    /** An array of one or more search/replace operations to perform sequentially on the note content. */
-    replacements: z
-        .array(ReplacementBlockSchema)
-        .min(1, "Replacements array cannot be empty.")
-        .describe("An array of search/replace operations to perform sequentially."),
-    /** If true, treats the 'search' field in each replacement block as a JavaScript regular expression pattern. Defaults to false (exact string matching). */
-    useRegex: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("If true, treat the 'search' field in replacements as JavaScript regex patterns. Defaults to false (exact string matching)."),
-    /** 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
-        .boolean()
-        .optional()
-        .default(true)
-        .describe("If true (default), replace all occurrences for each search pattern. If false, replace only the first occurrence."),
-    /** If true (default), the search operation is case-sensitive. If false, it's case-insensitive. Applies to both string and regex searches. */
-    caseSensitive: z
-        .boolean()
-        .optional()
-        .default(true)
-        .describe("If true (default), the search is case-sensitive. If false, it's case-insensitive. Applies to both string and regex search."),
-    /** 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
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("If true (and useRegex=false), treats sequences of whitespace in the search string as matching one or more whitespace characters (\\s+). Defaults to false."),
-    /** 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
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("If true, ensures the search term matches only whole words using word boundaries (\\b). Applies to both regex and non-regex modes. Defaults to false."),
-    /** If true, includes the final content of the modified file in the response. Defaults to false. */
-    returnContent: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("If true, returns the final content of the file in the response. Defaults to false."),
-});
-// ====================================================================================
-// Refined Schema for Internal Logic and Strict Validation
-// ====================================================================================
-/**
- * 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 const ObsidianSearchReplaceInputSchema = BaseObsidianSearchReplaceInputSchema.refine((data) => {
-    // Rule 1: Validate targetIdentifier based on targetType
-    if ((data.targetType === "filePath" ||
-        data.targetType === "periodicNote") &&
-        !data.targetIdentifier) {
-        return false; // Missing targetIdentifier
-    }
-    if (data.targetType === "periodicNote" &&
-        data.targetIdentifier &&
-        !PeriodicNotePeriodSchema.safeParse(data.targetIdentifier).success) {
-        return false; // Invalid period
-    }
-    // Rule 2: flexibleWhitespace cannot be true if useRegex is true
-    if (data.flexibleWhitespace && data.useRegex) {
-        return false; // Conflicting options
-    }
-    return true; // All checks passed
-}, {
-    // Custom error message for refinement failures
-    message: "Validation failed: targetIdentifier is required and must be valid for 'filePath' or 'periodicNote'. Also, 'flexibleWhitespace' cannot be true if 'useRegex' is true.",
-    // Point error reporting to potentially problematic fields
-    path: ["targetIdentifier", "flexibleWhitespace", "useRegex"],
-}).describe("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.");
-// ====================================================================================
-// Schema Shape and Type Exports for Registration and Logic
-// ====================================================================================
-/**
- * The shape of the base input schema, used by `server.tool` for registration and initial validation.
- * @see BaseObsidianSearchReplaceInputSchema
- */
-export const ObsidianSearchReplaceInputSchemaShape = BaseObsidianSearchReplaceInputSchema.shape;
-// ====================================================================================
-// Helper Functions
-// ====================================================================================
-/**
- * Escapes characters that have special meaning in regular expressions.
- * This allows treating a literal string as a pattern in a regex.
- *
- * @param {string} str - The input string to escape.
- * @returns {string} The string with regex special characters escaped.
- */
-function escapeRegex(str) {
-    // Escape characters: . * + ? ^ $ { } ( ) | [ ] \ -
-    return str.replace(/[.*+?^${}()|[\]\\-]/g, "\\$&"); // $& inserts the matched character
-}
-/**
- * Attempts to retrieve the final state (content and stats) of the target note after a search/replace operation.
- * Uses the appropriate Obsidian API method based on the target type and the potentially corrected file path.
- * Logs a warning and returns null if fetching the final state fails, preventing failure of the entire operation.
- *
- * @param {z.infer<typeof TargetTypeSchema>} targetType - The type of the target note.
- * @param {string | undefined} effectiveFilePath - The vault-relative path (potentially corrected by case-insensitive fallback). Undefined for non-filePath targets.
- * @param {z.infer<typeof PeriodicNotePeriodSchema> | undefined} period - The parsed period if targetType is 'periodicNote'.
- * @param {ObsidianRestApiService} obsidianService - The Obsidian API service instance.
- * @param {RequestContext} context - The request context for logging and correlation.
- * @returns {Promise<NoteJson | null>} A promise resolving to the NoteJson object or null if retrieval fails.
- */
-async function getFinalState(targetType, effectiveFilePath, period, obsidianService, context) {
-    const operation = "getFinalStateAfterSearchReplace";
-    const targetDesc = effectiveFilePath ?? (period ? `periodic ${period}` : "active file");
-    logger.debug(`Attempting to retrieve final state for target: ${targetDesc}`, {
-        ...context,
-        operation,
-    });
-    try {
-        let noteJson = null;
-        // Call the appropriate API method
-        if (targetType === "filePath" && effectiveFilePath) {
-            noteJson = (await obsidianService.getFileContent(effectiveFilePath, "json", context));
-        }
-        else if (targetType === "activeFile") {
-            noteJson = (await obsidianService.getActiveFile("json", context));
-        }
-        else if (targetType === "periodicNote" && period) {
-            noteJson = (await obsidianService.getPeriodicNote(period, "json", context));
-        }
-        logger.debug(`Successfully retrieved final state for ${targetDesc}`, {
-            ...context,
-            operation,
-        });
-        return noteJson;
-    }
-    catch (error) {
-        // Log the error but return null to avoid failing the main operation.
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        logger.warning(`Could not retrieve final state after search/replace for target: ${targetDesc}. Error: ${errorMsg}`, { ...context, operation, error: errorMsg });
-        return null;
-    }
-}
-// ====================================================================================
-// Core Logic Function
-// ====================================================================================
-/**
- * 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 const processObsidianSearchReplace = async (params, // Use the refined, validated type
-context, obsidianService, vaultCacheService) => {
-    // Destructure validated parameters for easier access
-    const { targetType, targetIdentifier, replacements, useRegex: initialUseRegex, // Rename to avoid shadowing loop variable
-    replaceAll, caseSensitive, flexibleWhitespace, // Note: Cannot be true if initialUseRegex is true (enforced by schema)
-    wholeWord, returnContent, } = params;
-    let effectiveFilePath = targetIdentifier; // Store the path used (might be updated by fallback)
-    let targetDescription = targetIdentifier ?? "active file"; // For logging and error messages
-    let targetPeriod;
-    logger.debug(`Processing obsidian_search_replace request`, {
-        ...context,
-        targetType,
-        targetIdentifier,
-        initialUseRegex,
-        flexibleWhitespace,
-        wholeWord,
-        returnContent,
-    });
-    // --- Step 1: Read Initial Content (with case-insensitive fallback for filePath) ---
-    let originalContent;
-    const readContext = { ...context, operation: "readFileContent" };
-    try {
-        if (targetType === "filePath") {
-            if (!targetIdentifier) {
-                // Should be caught by schema, but double-check
-                throw new McpError(BaseErrorCode.VALIDATION_ERROR, "targetIdentifier is required for targetType 'filePath'.", readContext);
-            }
-            targetDescription = targetIdentifier; // Initial description
-            try {
-                // Attempt 1: Case-sensitive read
-                logger.debug(`Attempting to read file (case-sensitive): ${targetIdentifier}`, readContext);
-                originalContent = (await obsidianService.getFileContent(targetIdentifier, "markdown", readContext));
-                effectiveFilePath = targetIdentifier; // Confirm exact path worked
-                logger.debug(`Successfully read file using exact path: ${targetIdentifier}`, readContext);
-            }
-            catch (readError) {
-                // Attempt 2: Case-insensitive fallback if NOT_FOUND
-                if (readError instanceof McpError &&
-                    readError.code === BaseErrorCode.NOT_FOUND) {
-                    logger.info(`File not found with exact path: ${targetIdentifier}. Attempting case-insensitive fallback.`, readContext);
-                    const dirname = path.posix.dirname(targetIdentifier);
-                    const filenameLower = path.posix
-                        .basename(targetIdentifier)
-                        .toLowerCase();
-                    // List directory contents (use root '/' if dirname is '.')
-                    const dirToList = dirname === "." ? "/" : dirname;
-                    const filesInDir = await obsidianService.listFiles(dirToList, readContext);
-                    // Filter for files matching the lowercase basename
-                    const matches = filesInDir.filter((f) => !f.endsWith("/") &&
-                        path.posix.basename(f).toLowerCase() === filenameLower);
-                    if (matches.length === 1) {
-                        // Found exactly one match
-                        const correctFilename = path.posix.basename(matches[0]);
-                        effectiveFilePath = path.posix.join(dirname, correctFilename); // Construct the correct path
-                        targetDescription = effectiveFilePath; // Update description for subsequent logs/errors
-                        logger.info(`Found case-insensitive match: ${effectiveFilePath}. Reading content.`, readContext);
-                        originalContent = (await obsidianService.getFileContent(effectiveFilePath, "markdown", readContext));
-                        logger.debug(`Successfully read file using fallback path: ${effectiveFilePath}`, readContext);
-                    }
-                    else {
-                        // Handle ambiguous (multiple matches) or no match found
-                        const errorMsg = matches.length > 1
-                            ? `Read failed: Ambiguous case-insensitive matches found for '${targetIdentifier}' in directory '${dirToList}'. Matches: [${matches.join(", ")}]`
-                            : `Read failed: File not found for '${targetIdentifier}' (case-insensitive fallback also failed in directory '${dirToList}').`;
-                        logger.error(errorMsg, { ...readContext, matches });
-                        // Use NOT_FOUND for no match, CONFLICT for ambiguity
-                        throw new McpError(matches.length > 1
-                            ? BaseErrorCode.CONFLICT
-                            : BaseErrorCode.NOT_FOUND, errorMsg, readContext);
-                    }
-                }
-                else {
-                    // Re-throw errors other than NOT_FOUND during the initial read attempt
-                    throw readError;
-                }
-            }
-        }
-        else if (targetType === "activeFile") {
-            logger.debug(`Reading content from active file.`, readContext);
-            originalContent = (await obsidianService.getActiveFile("markdown", readContext));
-            targetDescription = "the active file";
-            effectiveFilePath = undefined; // Not applicable
-            logger.debug(`Successfully read active file content.`, readContext);
-        }
-        else {
-            // periodicNote
-            if (!targetIdentifier) {
-                // Should be caught by schema
-                throw new McpError(BaseErrorCode.VALIDATION_ERROR, "targetIdentifier is required for targetType 'periodicNote'.", readContext);
-            }
-            // Parse period (already validated by refined schema)
-            targetPeriod = PeriodicNotePeriodSchema.parse(targetIdentifier);
-            targetDescription = `periodic note '${targetPeriod}'`;
-            effectiveFilePath = undefined; // Not applicable
-            logger.debug(`Reading content from ${targetDescription}.`, readContext);
-            originalContent = (await obsidianService.getPeriodicNote(targetPeriod, "markdown", readContext));
-            logger.debug(`Successfully read ${targetDescription} content.`, readContext);
-        }
-    }
-    catch (error) {
-        // Catch and handle errors during the initial read phase
-        if (error instanceof McpError)
-            throw error; // Re-throw known McpErrors
-        const errorMessage = `Unexpected error reading target ${targetDescription} before search/replace.`;
-        logger.error(errorMessage, error instanceof Error ? error : undefined, readContext);
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `${errorMessage}: ${error instanceof Error ? error.message : String(error)}`, readContext);
-    }
-    // --- Step 2: Perform Sequential Replacements ---
-    let modifiedContent = originalContent;
-    let totalReplacementsMade = 0;
-    const replaceContext = { ...context, operation: "performReplacements" };
-    logger.debug(`Starting ${replacements.length} replacement operations.`, replaceContext);
-    for (let i = 0; i < replacements.length; i++) {
-        const rep = replacements[i];
-        const repContext = {
-            ...replaceContext,
-            replacementIndex: i,
-            searchPattern: rep.search,
-        };
-        let currentReplacementsInBlock = 0;
-        let finalSearchPattern = rep.search; // Start with the raw search string
-        let useRegexForThisRep = initialUseRegex; // Use the overall setting initially
-        try {
-            // --- 2a: Prepare the Search Pattern (Apply options) ---
-            const patternPrepContext = {
-                ...repContext,
-                subOperation: "prepareSearchPattern",
-            };
-            if (!initialUseRegex) {
-                // Handle non-regex specific options: flexibleWhitespace and wholeWord
-                let searchStr = rep.search; // Work with a mutable string
-                if (flexibleWhitespace) {
-                    // Convert to a regex string: escape special chars, then replace whitespace sequences with \s+
-                    searchStr = escapeRegex(searchStr).replace(/\s+/g, "\\s+");
-                    useRegexForThisRep = true; // Now treat it as a regex pattern string
-                    logger.debug(`Applying flexibleWhitespace: "${rep.search}" -> /${searchStr}/`, patternPrepContext);
-                }
-                if (wholeWord) {
-                    // Add word boundaries (\b) to the pattern string
-                    // If flexibleWhitespace was applied, searchStr is already a regex string.
-                    // Otherwise, escape the original search string first.
-                    const basePattern = useRegexForThisRep
-                        ? searchStr
-                        : escapeRegex(searchStr);
-                    searchStr = `\\b${basePattern}\\b`;
-                    useRegexForThisRep = true; // Definitely treat as a regex pattern string now
-                    logger.debug(`Applying wholeWord: "${rep.search}" -> /${searchStr}/`, patternPrepContext);
-                }
-                finalSearchPattern = searchStr; // Update the pattern to use
-            }
-            else if (wholeWord) {
-                // Initial useRegex is true, but wholeWord is also requested.
-                // Apply wholeWord boundaries if the user's regex doesn't obviously have them.
-                let searchStr = rep.search;
-                // Heuristic check: Does the pattern likely already account for boundaries?
-                // Looks for ^, $, \b at start/end, or patterns matching full lines/non-whitespace sequences.
-                const hasBoundary = /(?:^|\\b)\S.*\S(?:$|\\b)|^\S$|^\S.*\S$|^$/.test(searchStr) ||
-                    /^\^|\\b/.test(searchStr) ||
-                    /\$|\\b$/.test(searchStr);
-                if (!hasBoundary) {
-                    searchStr = `\\b${searchStr}\\b`;
-                    // Log a warning as this might interfere with complex user regex.
-                    logger.warning(`Applying wholeWord=true to user-provided regex. Original: /${rep.search}/, Modified: /${searchStr}/. This might affect complex regex behavior.`, patternPrepContext);
-                    finalSearchPattern = searchStr; // Update the pattern string
-                }
-                else {
-                    logger.debug(`wholeWord=true requested, but user regex /${searchStr}/ appears to already contain boundary anchors. Using original regex.`, patternPrepContext);
-                    finalSearchPattern = rep.search; // Keep original regex string
-                }
-            }
-            // If it's still not treated as regex, finalSearchPattern remains the original rep.search string.
-            // --- 2b: Execute the Replacement ---
-            const execContext = {
-                ...repContext,
-                subOperation: "executeReplacement",
-                isRegex: useRegexForThisRep,
-            };
-            if (useRegexForThisRep) {
-                // --- Regex Replacement ---
-                let flags = "";
-                if (replaceAll)
-                    flags += "g"; // Global flag for all matches
-                if (!caseSensitive)
-                    flags += "i"; // Ignore case flag
-                const regex = new RegExp(finalSearchPattern, flags); // Create RegExp object
-                logger.debug(`Executing regex replacement: /${finalSearchPattern}/${flags}`, execContext);
-                // Count matches *before* replacing to report accurately
-                const matches = modifiedContent.match(regex);
-                currentReplacementsInBlock = matches ? matches.length : 0;
-                // If replaceAll is false, we only perform/count one replacement, even if regex matches more
-                if (!replaceAll && currentReplacementsInBlock > 0) {
-                    currentReplacementsInBlock = 1;
-                }
-                // Perform the replacement
-                if (currentReplacementsInBlock > 0) {
-                    if (replaceAll) {
-                        modifiedContent = modifiedContent.replace(regex, rep.replace);
-                    }
-                    else {
-                        // Replace only the first occurrence found by the regex
-                        modifiedContent = modifiedContent.replace(regex, rep.replace);
-                    }
-                }
-            }
-            else {
-                // --- Simple String Replacement ---
-                // Note: wholeWord and flexibleWhitespace would have set useRegexForThisRep = true
-                const searchString = finalSearchPattern; // It's just a string here
-                const comparisonString = caseSensitive
-                    ? searchString
-                    : searchString.toLowerCase();
-                let startIndex = 0;
-                logger.debug(`Executing string replacement: "${searchString}" (caseSensitive: ${caseSensitive})`, execContext);
-                while (true) {
-                    const contentToSearch = caseSensitive
-                        ? modifiedContent
-                        : modifiedContent.toLowerCase();
-                    const index = contentToSearch.indexOf(comparisonString, startIndex);
-                    if (index === -1) {
-                        break; // No more occurrences found
-                    }
-                    currentReplacementsInBlock++;
-                    // Perform replacement using original indices and search string length
-                    modifiedContent =
-                        modifiedContent.substring(0, index) +
-                            rep.replace +
-                            modifiedContent.substring(index + searchString.length);
-                    if (!replaceAll) {
-                        break; // Stop after the first replacement
-                    }
-                    // Move start index past the inserted replacement to find the next match
-                    startIndex = index + rep.replace.length;
-                    // Safety break for empty search string or potential infinite loops
-                    if (searchString.length === 0) {
-                        logger.warning(`Search string is empty. Breaking replacement loop to prevent infinite execution.`, execContext);
-                        break;
-                    }
-                    // Basic check if replacement could cause infinite loop (e.g., replacing 'a' with 'ba')
-                    if (rep.replace.includes(searchString) &&
-                        rep.replace.length >= searchString.length) {
-                        // This is a heuristic, might not catch all cases but prevents common ones.
-                        logger.warning(`Replacement string "${rep.replace}" contains search string "${searchString}". Potential infinite loop detected. Breaking loop for this block.`, execContext);
-                        break;
-                    }
-                }
-            }
-            totalReplacementsMade += currentReplacementsInBlock;
-            logger.debug(`Block ${i}: Performed ${currentReplacementsInBlock} replacements for search: "${rep.search}"`, repContext);
-        }
-        catch (error) {
-            // Catch errors during a specific replacement block
-            const errorMessage = `Error during replacement block ${i} (search: "${rep.search}")`;
-            logger.error(errorMessage, error instanceof Error ? error : undefined, repContext);
-            // Fail fast: Stop processing further replacements if one block fails.
-            throw new McpError(BaseErrorCode.INTERNAL_ERROR, `${errorMessage}: ${error instanceof Error ? error.message : "Unknown error"}`, repContext);
-        }
-    } // End of replacements loop
-    logger.debug(`Finished all replacement operations. Total replacements made: ${totalReplacementsMade}`, replaceContext);
-    // --- Step 3: Write Modified Content Back to Obsidian ---
-    let finalState = null;
-    const POST_UPDATE_DELAY_MS = 500; // Delay before trying to read the file back
-    // Only write back if the content actually changed to avoid unnecessary file operations.
-    if (modifiedContent !== originalContent) {
-        const writeContext = { ...context, operation: "writeFileContent" };
-        try {
-            logger.debug(`Content changed. Writing modified content back to ${targetDescription}`, writeContext);
-            // Use the effectiveFilePath determined during the read phase for filePath targets
-            if (targetType === "filePath") {
-                await obsidianService.updateFileContent(effectiveFilePath, modifiedContent, writeContext);
-                if (vaultCacheService) {
-                    await vaultCacheService.updateCacheForFile(effectiveFilePath, writeContext);
-                }
-            }
-            else if (targetType === "activeFile") {
-                await obsidianService.updateActiveFile(modifiedContent, writeContext);
-            }
-            else {
-                // periodicNote
-                await obsidianService.updatePeriodicNote(targetPeriod, modifiedContent, writeContext);
-            }
-            logger.info(`Successfully updated ${targetDescription} with ${totalReplacementsMade} replacement(s).`, writeContext);
-            // Attempt to get the final state *after* successfully writing.
-            logger.debug(`Waiting ${POST_UPDATE_DELAY_MS}ms before retrieving final state after write...`, { ...writeContext, subOperation: "postWriteDelay" });
-            await new Promise((resolve) => setTimeout(resolve, POST_UPDATE_DELAY_MS));
-            try {
-                finalState = await retryWithDelay(async () => getFinalState(targetType, effectiveFilePath, targetPeriod, obsidianService, context), {
-                    operationName: "getFinalStateAfterSearchReplaceWrite",
-                    context: {
-                        ...context,
-                        operation: "getFinalStateAfterSearchReplaceWriteAttempt",
-                    },
-                    maxRetries: 3,
-                    delayMs: 300,
-                    shouldRetry: (err) => err instanceof McpError &&
-                        (err.code === BaseErrorCode.NOT_FOUND ||
-                            err.code === BaseErrorCode.SERVICE_UNAVAILABLE ||
-                            err.code === BaseErrorCode.TIMEOUT),
-                    onRetry: (attempt, err) => logger.warning(`getFinalStateAfterSearchReplaceWrite (attempt ${attempt}) failed. Error: ${err.message}. Retrying...`, writeContext),
-                });
-            }
-            catch (retryError) {
-                finalState = null;
-                logger.error(`Failed to retrieve final state for ${targetDescription} after write, even after retries. Error: ${retryError.message}`, retryError instanceof Error ? retryError : undefined, writeContext);
-            }
-        }
-        catch (error) {
-            // Handle errors during the write phase
-            if (error instanceof McpError)
-                throw error; // Re-throw known McpErrors
-            const errorMessage = `Unexpected error writing modified content to ${targetDescription}.`;
-            logger.error(errorMessage, error instanceof Error ? error : undefined, writeContext);
-            throw new McpError(BaseErrorCode.INTERNAL_ERROR, `${errorMessage}: ${error instanceof Error ? error.message : String(error)}`, writeContext);
-        }
-    }
-    else {
-        // Content did not change, no need to write.
-        logger.info(`No changes detected in ${targetDescription} after search/replace operations. Skipping write.`, context);
-        // Still attempt to get the state, as the user might want stats even if content is unchanged.
-        logger.debug(`Waiting ${POST_UPDATE_DELAY_MS}ms before retrieving final state (no change)...`, { ...context, subOperation: "postNoChangeDelay" });
-        await new Promise((resolve) => setTimeout(resolve, POST_UPDATE_DELAY_MS));
-        try {
-            finalState = await retryWithDelay(async () => getFinalState(targetType, effectiveFilePath, targetPeriod, obsidianService, context), {
-                operationName: "getFinalStateAfterSearchReplaceNoChange",
-                context: {
-                    ...context,
-                    operation: "getFinalStateAfterSearchReplaceNoChangeAttempt",
-                },
-                maxRetries: 3,
-                delayMs: 300,
-                shouldRetry: (err) => err instanceof McpError &&
-                    (err.code === BaseErrorCode.NOT_FOUND ||
-                        err.code === BaseErrorCode.SERVICE_UNAVAILABLE ||
-                        err.code === BaseErrorCode.TIMEOUT),
-                onRetry: (attempt, err) => logger.warning(`getFinalStateAfterSearchReplaceNoChange (attempt ${attempt}) failed. Error: ${err.message}. Retrying...`, context),
-            });
-        }
-        catch (retryError) {
-            finalState = null;
-            logger.error(`Failed to retrieve final state for ${targetDescription} (no change), even after retries. Error: ${retryError.message}`, retryError instanceof Error ? retryError : undefined, context);
-        }
-    }
-    // --- Step 4: Construct and Return the Response ---
-    const responseContext = { ...context, operation: "buildResponse" };
-    let message;
-    if (totalReplacementsMade > 0) {
-        message = `Search/replace completed on ${targetDescription}. Successfully made ${totalReplacementsMade} replacement(s).`;
-    }
-    else if (modifiedContent !== originalContent) {
-        // This case should ideally not happen if totalReplacementsMade is 0, but as a safeguard:
-        message = `Search/replace completed on ${targetDescription}. Content was modified, but replacement count is zero. Please review.`;
-    }
-    else {
-        message = `Search/replace completed on ${targetDescription}. No matching text was found, so no replacements were made.`;
-    }
-    // Append a warning if the final state couldn't be retrieved
-    if (finalState === null) {
-        const warningMsg = " (Warning: Could not retrieve final file stats/content after update.)";
-        message += warningMsg;
-        logger.warning(`Appending warning to response message: ${warningMsg}`, responseContext);
-    }
-    // Format the file statistics using the shared utility.
-    // Use final state content if available, otherwise use the (potentially modified) content in memory for token count.
-    const finalContentForStat = finalState?.content ?? modifiedContent;
-    const formattedStatResult = finalState?.stat
-        ? await createFormattedStatWithTokenCount(finalState.stat, finalContentForStat, responseContext) // Await the async utility
-        : undefined;
-    // Ensure stat is undefined if the utility returned null (e.g., token counting failed)
-    const formattedStat = formattedStatResult === null ? undefined : formattedStatResult;
-    // Build the final response object
-    const response = {
-        success: true,
-        message: message,
-        totalReplacementsMade,
-        stats: formattedStat,
-    };
-    // Include final content if requested and available.
-    if (returnContent) {
-        // Prefer content from final state read, fallback to in-memory modified content.
-        response.finalContent = finalState?.content ?? modifiedContent;
-        logger.debug(`Including final content in response as requested.`, responseContext);
-    }
-    logger.debug(`Search/replace process completed successfully.`, responseContext);
-    return response;
-};

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

@@ -1,22 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { ObsidianRestApiService, VaultCacheService } from "../../../services/obsidianRestAPI/index.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 declare const registerObsidianSearchReplaceTool: (server: McpServer, obsidianService: ObsidianRestApiService, vaultCacheService: VaultCacheService | undefined) => Promise<void>;