obsidian-mcp-server 2.0.3 → 2.0.5

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

@@ -1,4 +1,10 @@
-import path from "node:path"; // Using POSIX path functions for vault path manipulation
+/**
+ * @fileoverview Core logic for the 'obsidian_list_files' tool.
+ * This module defines the input schema, response types, and processing logic for
+ * recursively listing files and directories in an Obsidian vault with filtering.
+ * @module src/mcp-server/tools/obsidianListFilesTool/logic
+ */
+import path from "node:path";
 import { z } from "zod";
 import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
 import { logger, retryWithDelay, } from "../../../utils/index.js";
@@ -12,7 +18,6 @@ export const ObsidianListFilesInputSchema = z
     .object({
     /**
      * The vault-relative path to the directory whose contents should be listed.
-     * Examples: "Attachments/Images", "Projects", "" (for vault root), "/" (for vault root).
      * The path is treated as case-sensitive by the underlying Obsidian API.
      */
     dirPath: z
@@ -20,160 +25,191 @@ export const ObsidianListFilesInputSchema = z
         .describe('The vault-relative path to the directory to list (e.g., "developer/atlas-mcp-server", "/" for root). Case-sensitive.'),
     /**
      * Optional array of file extensions (including the leading dot) to filter the results.
-     * Only files matching one of these extensions will be included. Directories are always included regardless of this filter.
-     * Example: [".md", ".png"]
+     * Only files matching one of these extensions will be included. Directories are always included.
      */
     fileExtensionFilter: z
         .array(z.string().startsWith(".", "Extension must start with a dot '.'"))
         .optional()
-        .describe('Optional array of file extensions (e.g., [".md") to filter files. Directories are always included.'),
+        .describe('Optional array of file extensions (e.g., [".md"]) to filter files. Directories are always included.'),
     /**
      * Optional JavaScript-compatible regular expression pattern string to filter results by name.
      * Only files and directories whose names match the regex will be included.
-     * Example: "^\\d{4}-\\d{2}-\\d{2}" (matches names starting with YYYY-MM-DD)
      */
     nameRegexFilter: z
         .string()
         .nullable()
-        .optional() // Allow null in addition to string/undefined
+        .optional()
         .describe("Optional regex pattern (JavaScript syntax) to filter results by name."),
+    /**
+     * The maximum depth of subdirectories to list recursively.
+     * - A value of `0` lists only the files and directories in the specified `dirPath`.
+     * - A value of `1` lists the contents of `dirPath` and the contents of its immediate subdirectories.
+     * - A value of `-1` (the default) indicates infinite recursion, listing all subdirectories.
+     */
+    recursionDepth: z
+        .number()
+        .int()
+        .default(-1)
+        .describe("Maximum recursion depth. 0 for no recursion, -1 for infinite (default)."),
 })
-    .describe("Input parameters for listing files and subdirectories within a specified Obsidian vault directory, with optional filtering.");
+    .describe("Input parameters for listing files and subdirectories within a specified Obsidian vault directory, with optional filtering and recursion.");
 // ====================================================================================
 // Helper Functions
 // ====================================================================================
 /**
- * Formats a list of file and directory names into a simple tree-like string representation.
- * Directories (indicated by a trailing '/') are listed first, then files, both sorted alphabetically.
+ * Recursively builds a formatted tree string from a nested array of FileTreeNode objects.
  *
- * @param {string[]} fileNames - An array of file and directory names (directories should end with '/').
- * @returns {string} A formatted string representing the directory tree, or "(empty directory)" if the input array is empty.
+ * @param {FileTreeNode[]} nodes - The array of nodes to format.
+ * @param {string} [indent=""] - The indentation prefix for the current level.
+ * @returns {{ tree: string, count: number }} An object containing the formatted tree string and the total count of entries.
  */
-function formatAsTree(fileNames) {
-    if (!fileNames || fileNames.length === 0) {
-        return "(empty directory)";
-    }
-    // Sort entries: directories first, then files, alphabetically within each group.
-    fileNames.sort((a, b) => {
-        const aIsDir = a.endsWith("/");
-        const bIsDir = b.endsWith("/");
-        // Group directories before files
-        if (aIsDir && !bIsDir)
-            return -1; // a (dir) comes before b (file)
-        if (!aIsDir && bIsDir)
-            return 1; // b (dir) comes before a (file)
-        // Within the same type (both dirs or both files), sort alphabetically.
-        // Remove trailing slash for comparison if it's a directory.
-        const nameA = aIsDir ? a.slice(0, -1) : a;
-        const nameB = bIsDir ? b.slice(0, -1) : b;
-        return nameA.localeCompare(nameB);
-    });
-    // Build the tree string with prefixes
+function formatTree(nodes, indent = "") {
     let treeString = "";
-    const lastIndex = fileNames.length - 1;
-    fileNames.forEach((name, index) => {
-        const isLast = index === lastIndex;
-        const prefix = isLast ? "└── " : "├── "; // Use different connectors for the last item
-        treeString += prefix + name + (isLast ? "" : "\n"); // Add newline except for the last item
+    let count = nodes.length;
+    nodes.forEach((node, index) => {
+        const isLast = index === nodes.length - 1;
+        const prefix = isLast ? "└── " : "├── ";
+        const childIndent = isLast ? "    " : "│   ";
+        treeString += `${indent}${prefix}${node.name}\n`;
+        if (node.children && node.children.length > 0) {
+            const result = formatTree(node.children, indent + childIndent);
+            treeString += result.tree;
+            count += result.count;
+        }
+    });
+    return { tree: treeString, count };
+}
+/**
+ * Recursively builds a file tree by fetching directory contents from the Obsidian API.
+ *
+ * @param {string} dirPath - The path of the directory to process.
+ * @param {number} currentDepth - The current recursion depth.
+ * @param {ObsidianListFilesInput} params - The original validated input parameters, including filters and max depth.
+ * @param {RequestContext} context - The request context for logging.
+ * @param {ObsidianRestApiService} obsidianService - The Obsidian API service instance.
+ * @returns {Promise<FileTreeNode[]>} A promise that resolves to an array of file tree nodes.
+ */
+async function buildFileTree(dirPath, currentDepth, params, context, obsidianService) {
+    const { recursionDepth, fileExtensionFilter, nameRegexFilter } = params;
+    // Stop recursion if max depth is reached (and it's not infinite)
+    if (recursionDepth !== -1 && currentDepth > recursionDepth) {
+        return [];
+    }
+    let fileNames;
+    try {
+        fileNames = await obsidianService.listFiles(dirPath, context);
+    }
+    catch (error) {
+        if (error instanceof McpError && error.code === BaseErrorCode.NOT_FOUND) {
+            logger.warning(`Directory not found during recursive list: ${dirPath}. Skipping.`, context);
+            return []; // Return empty array if a subdirectory is not found
+        }
+        throw error; // Re-throw other errors
+    }
+    const regex = nameRegexFilter && nameRegexFilter.trim() !== ""
+        ? new RegExp(nameRegexFilter)
+        : null;
+    const treeNodes = [];
+    for (const name of fileNames) {
+        const fullPath = path.posix.join(dirPath, name);
+        const isDirectory = name.endsWith("/");
+        const cleanName = isDirectory ? name.slice(0, -1) : name;
+        // Apply filters
+        if (regex && !regex.test(cleanName)) {
+            continue;
+        }
+        if (!isDirectory && fileExtensionFilter && fileExtensionFilter.length > 0) {
+            const extension = path.posix.extname(name);
+            if (!fileExtensionFilter.includes(extension)) {
+                continue;
+            }
+        }
+        const node = {
+            name: cleanName,
+            type: isDirectory ? "directory" : "file",
+            children: [],
+        };
+        if (isDirectory) {
+            node.name += "/"; // Add trailing slash back for display
+            node.children = await buildFileTree(fullPath, currentDepth + 1, params, context, obsidianService);
+        }
+        treeNodes.push(node);
+    }
+    // Sort entries: directories first, then files, alphabetically
+    treeNodes.sort((a, b) => {
+        if (a.type === "directory" && b.type === "file")
+            return -1;
+        if (a.type === "file" && b.type === "directory")
+            return 1;
+        return a.name.localeCompare(b.name);
     });
-    return treeString;
+    return treeNodes;
 }
 // ====================================================================================
 // Core Logic Function
 // ====================================================================================
 /**
- * Processes the core logic for listing files and directories within a specified
- * directory in the Obsidian vault. Applies optional filters and formats the output.
+ * Processes the core logic for listing files and directories recursively within the Obsidian vault.
  *
  * @param {ObsidianListFilesInput} 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<ObsidianListFilesResponse>} A promise resolving to the structured success response
- *   containing the listed directory path, a formatted tree string, and the total entry count.
- * @throws {McpError} Throws an McpError if the directory cannot be listed (e.g., not found)
- *   or if any other API interaction or validation fails.
+ * @returns {Promise<ObsidianListFilesResponse>} A promise resolving to the structured success response.
+ * @throws {McpError} Throws an McpError if the initial directory is not found or another error occurs.
  */
 export const processObsidianListFiles = async (params, context, obsidianService) => {
-    const { dirPath, fileExtensionFilter, nameRegexFilter } = params;
-    // Normalize dirPath for logging and response (use "/" for root)
+    const { dirPath } = params;
     const dirPathForLog = dirPath === "" || dirPath === "/" ? "/" : dirPath;
-    logger.debug(`Processing obsidian_list_files request for path: ${dirPathForLog}`, { ...context, fileExtensionFilter, nameRegexFilter });
+    logger.debug(`Processing obsidian_list_files request for path: ${dirPathForLog}`, { ...context, params });
     try {
-        // Normalize path for the API call as well
         const effectiveDirPath = dirPath === "" ? "/" : dirPath;
-        // --- Step 1: Fetch initial list from Obsidian API ---
-        const listContext = { ...context, operation: "listFilesApiCall" };
-        logger.debug(`Calling Obsidian API to list directory: ${effectiveDirPath}`, listContext);
+        // --- Step 1: Build the file tree recursively with retry for the initial call ---
+        const buildTreeContext = {
+            ...context,
+            operation: "buildFileTreeWithRetry",
+        };
         const shouldRetryNotFound = (err) => err instanceof McpError && err.code === BaseErrorCode.NOT_FOUND;
-        let fileNames = await retryWithDelay(() => obsidianService.listFiles(effectiveDirPath, listContext), {
-            operationName: "listFilesWithRetry",
-            context: listContext,
+        const fileTree = await retryWithDelay(() => buildFileTree(effectiveDirPath, 0, // Start at depth 0
+        params, buildTreeContext, obsidianService), {
+            operationName: "buildFileTreeWithRetry",
+            context: buildTreeContext,
             maxRetries: 3,
             delayMs: 300,
             shouldRetry: shouldRetryNotFound,
         });
-        logger.debug(`Successfully listed ${fileNames.length} initial items in: ${dirPathForLog}`, listContext);
-        // --- Step 2: Apply Filters ---
-        const filterContext = { ...context, operation: "applyFilters" };
-        // Apply extension filter if provided
-        if (fileExtensionFilter && fileExtensionFilter.length > 0) {
-            const initialCount = fileNames.length;
-            fileNames = fileNames.filter((fileName) => {
-                // Always keep directories (identified by trailing '/')
-                if (fileName.endsWith("/"))
-                    return true;
-                // Check if the file's extension is in the filter list
-                const extension = path.posix.extname(fileName); // Use path.posix.extname for consistency
-                return fileExtensionFilter.includes(extension);
-            });
-            logger.debug(`Applied extension filter (${fileExtensionFilter.join(", ")}). ${initialCount} -> ${fileNames.length} items remaining.`, filterContext);
-        }
-        // Apply regex name filter if provided and is a non-empty string
-        if (nameRegexFilter && nameRegexFilter.trim() !== "") {
-            const initialCount = fileNames.length;
-            try {
-                const regex = new RegExp(nameRegexFilter); // Compile the regex pattern
-                fileNames = fileNames.filter((fileName) => regex.test(fileName)); // Test each name against the regex
-                logger.debug(`Applied regex filter /${nameRegexFilter}/. ${initialCount} -> ${fileNames.length} items remaining.`, filterContext);
-            }
-            catch (regexError) {
-                // Handle invalid regex patterns provided by the user
-                logger.error(`Invalid regex pattern provided: ${nameRegexFilter}`, regexError instanceof Error ? regexError : undefined, filterContext);
-                throw new McpError(BaseErrorCode.VALIDATION_ERROR, // It's an input validation issue
-                `Invalid regex pattern provided for nameRegexFilter: ${nameRegexFilter}. Error: ${regexError instanceof Error ? regexError.message : "Unknown regex error"}`, filterContext);
-            }
-        }
-        // --- Step 3: Format Output and Return ---
+        // --- Step 2: Format the tree and count entries ---
         const formatContext = { ...context, operation: "formatResponse" };
-        const totalEntries = fileNames.length;
-        logger.debug(`Formatting final list of ${totalEntries} entries as tree.`, formatContext);
-        // Format the potentially filtered list into a tree string
-        const treeString = formatAsTree(fileNames);
-        // Construct the final response object
+        if (fileTree.length === 0) {
+            logger.debug("Directory is empty or all items were filtered out.", formatContext);
+            return {
+                directoryPath: dirPathForLog,
+                tree: "(empty or all items filtered)",
+                totalEntries: 0,
+            };
+        }
+        const { tree, count } = formatTree(fileTree);
+        // --- Step 3: Construct and return the response ---
         const response = {
-            directoryPath: dirPathForLog, // Return the normalized path
-            tree: treeString,
-            totalEntries: totalEntries,
+            directoryPath: dirPathForLog,
+            tree: tree.trimEnd(), // Remove trailing newline
+            totalEntries: count,
         };
-        logger.debug(`Successfully processed list request for ${dirPathForLog}.`, context);
+        logger.debug(`Successfully processed list request for ${dirPathForLog}. Found ${count} entries.`, context);
         return response;
     }
     catch (error) {
-        // Handle errors, ensuring they are McpError instances before re-throwing.
         if (error instanceof McpError) {
-            // Provide a more specific message if the directory wasn't found
+            // Provide a more specific message if the directory wasn't found after retries
             if (error.code === BaseErrorCode.NOT_FOUND) {
-                logger.error(`Directory not found for listing: ${dirPathForLog}`, error, context);
-                throw new McpError(error.code, `Directory not found for listing: ${dirPathForLog}`, context);
+                const notFoundMsg = `Directory not found after retries: ${dirPathForLog}`;
+                logger.error(notFoundMsg, error, context);
+                throw new McpError(error.code, notFoundMsg, context);
             }
             logger.error(`McpError during file listing for ${dirPathForLog}: ${error.message}`, error, context);
-            throw error; // Re-throw known McpError
-        }
-        else {
-            // Catch and wrap unexpected errors
-            const errorMessage = `Unexpected error listing Obsidian files in ${dirPathForLog}`;
-            logger.error(errorMessage, error instanceof Error ? error : undefined, context);
-            throw new McpError(BaseErrorCode.INTERNAL_ERROR, `${errorMessage}: ${error instanceof Error ? error.message : String(error)}`, context);
+            throw error;
         }
+        const errorMessage = `Unexpected error listing Obsidian files in ${dirPathForLog}`;
+        logger.error(errorMessage, error instanceof Error ? error : undefined, context);
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `${errorMessage}: ${error instanceof Error ? error.message : String(error)}`, context);
     }
 };

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

@@ -1,14 +1,18 @@
+/**
+ * @fileoverview Registers the 'obsidian_list_files' tool with the MCP server.
+ * This file defines the tool's metadata and sets up the handler that links
+ * the tool call to its core processing logic.
+ * @module src/mcp-server/tools/obsidianListFilesTool/registration
+ */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { ObsidianRestApiService } from "../../../services/obsidianRestAPI/index.js";
 /**
  * Registers the 'obsidian_list_files' tool with the MCP server.
  *
  * This tool lists the files and subdirectories within a specified directory
- * in the user's Obsidian vault. It supports optional filtering by file extension
- * or by a regular expression matching the entry name.
- *
- * The response includes the path of the listed directory, a formatted tree string
- * representing the contents, and the total count of entries listed after filtering.
+ * in the user's Obsidian vault. It supports optional filtering by file extension,
+ * by a regular expression matching the entry name, and recursive listing up to a
+ * specified depth.
  *
  * @param {McpServer} server - The MCP server instance to register the tool with.
  * @param {ObsidianRestApiService} obsidianService - An instance of the Obsidian REST API service

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

@@ -1,3 +1,9 @@
+/**
+ * @fileoverview Registers the 'obsidian_list_files' tool with the MCP server.
+ * This file defines the tool's metadata and sets up the handler that links
+ * the tool call to its core processing logic.
+ * @module src/mcp-server/tools/obsidianListFilesTool/registration
+ */
 import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
 import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js";
 import { ObsidianListFilesInputSchema, processObsidianListFiles, } from "./logic.js";
@@ -5,11 +11,9 @@ import { ObsidianListFilesInputSchema, processObsidianListFiles, } from "./logic
  * Registers the 'obsidian_list_files' tool with the MCP server.
  *
  * This tool lists the files and subdirectories within a specified directory
- * in the user's Obsidian vault. It supports optional filtering by file extension
- * or by a regular expression matching the entry name.
- *
- * The response includes the path of the listed directory, a formatted tree string
- * representing the contents, and the total count of entries listed after filtering.
+ * in the user's Obsidian vault. It supports optional filtering by file extension,
+ * by a regular expression matching the entry name, and recursive listing up to a
+ * specified depth.
  *
  * @param {McpServer} server - The MCP server instance to register the tool with.
  * @param {ObsidianRestApiService} obsidianService - An instance of the Obsidian REST API service
@@ -19,8 +23,7 @@ import { ObsidianListFilesInputSchema, processObsidianListFiles, } from "./logic
  */
 export const registerObsidianListFilesTool = async (server, obsidianService) => {
     const toolName = "obsidian_list_files";
-    // Updated description to reflect the simplified response (path, tree, count)
-    const toolDescription = "Lists files and subdirectories within a specified Obsidian vault folder. Supports optional filtering by extension or name regex. Returns an object containing the listed directory path, a formatted tree string of its contents, and the total entry count. Use an empty string or '/' for dirPath to list the vault root.";
+    const toolDescription = "Lists files and subdirectories within a specified Obsidian vault folder. Supports optional filtering by extension or name regex, and recursive listing to a specified depth (-1 for infinite). Returns an object containing the listed directory path, a formatted tree string of its contents, and the total entry count. Use an empty string or '/' for dirPath to list the vault root.";
     // Create a context specifically for the registration process.
     const registrationContext = requestContextService.createRequestContext({
         operation: "RegisterObsidianListFilesTool",
@@ -52,17 +55,16 @@ export const registerObsidianListFilesTool = async (server, obsidianService) =>
                     dirPath: params.dirPath,
                     fileExtensionFilter: params.fileExtensionFilter,
                     nameRegexFilter: params.nameRegexFilter,
+                    recursionDepth: params.recursionDepth,
                 },
             });
             logger.debug(`Handling '${toolName}' request`, handlerContext);
             // Wrap the core logic execution in a tryCatch block.
             return await ErrorHandler.tryCatch(async () => {
                 // Delegate the actual file listing and filtering logic to the processing function.
-                // Note: The input schema and shape are identical here, so no separate refinement parse is needed.
                 const response = await processObsidianListFiles(params, 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 (directoryPath, tree, totalEntries) is serialized to JSON.
                 return {
                     content: [
                         {

package/dist/mcp-server/tools/{obsidianUpdateFileTool → obsidianUpdateNoteTool}/index.d.ts

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

package/dist/mcp-server/tools/{obsidianUpdateFileTool → obsidianUpdateNoteTool}/index.js

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

package/dist/mcp-server/tools/{obsidianUpdateFileTool → obsidianUpdateNoteTool}/logic.d.ts

@@ -8,7 +8,7 @@ import { RequestContext } from "../../../utils/index.js";
  * relying on the refined schema (`ObsidianUpdateFileInputSchema`) for stricter validation
  * within the handler logic.
  */
-declare const ObsidianUpdateFileRegistrationSchema: z.ZodObject<{
+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. */
@@ -48,7 +48,7 @@ declare const ObsidianUpdateFileRegistrationSchema: z.ZodObject<{
  * The shape of the registration schema, used by `server.tool` for basic validation.
  * @see ObsidianUpdateFileRegistrationSchema
  */
-export declare const ObsidianUpdateFileInputSchemaShape: {
+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. */
@@ -71,13 +71,13 @@ export declare const ObsidianUpdateFileInputSchemaShape: {
  * received by the tool handler *before* refinement.
  * @see ObsidianUpdateFileRegistrationSchema
  */
-export type ObsidianUpdateFileRegistrationInput = z.infer<typeof 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 ObsidianUpdateFileInputSchema: z.ZodEffects<z.ZodObject<{
+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. */
@@ -140,7 +140,7 @@ export declare const ObsidianUpdateFileInputSchema: z.ZodEffects<z.ZodObject<{
  * 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 ObsidianUpdateFileInput = z.infer<typeof ObsidianUpdateFileInputSchema>;
+export type ObsidianUpdateNoteInput = z.infer<typeof ObsidianUpdateNoteInputSchema>;
 /**
  * Represents the structure of file statistics after formatting, including
  * human-readable timestamps and an estimated token count.
@@ -157,7 +157,7 @@ type FormattedStat = {
  * 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 ObsidianUpdateFileResponse {
+export interface ObsidianUpdateNoteResponse {
     /** Indicates whether the operation was successful. */
     success: boolean;
     /** A human-readable message describing the outcome of the operation. */
@@ -178,6 +178,6 @@ export interface ObsidianUpdateFileResponse {
  * @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 processObsidianUpdateFile: (params: ObsidianUpdateFileInput, // Use the refined, validated type
-context: RequestContext, obsidianService: ObsidianRestApiService, vaultCacheService: VaultCacheService | undefined) => Promise<ObsidianUpdateFileResponse>;
+export declare const processObsidianUpdateNote: (params: ObsidianUpdateNoteInput, // Use the refined, validated type
+context: RequestContext, obsidianService: ObsidianRestApiService, vaultCacheService: VaultCacheService | undefined) => Promise<ObsidianUpdateNoteResponse>;
 export {};

package/dist/mcp-server/tools/{obsidianUpdateFileTool → obsidianUpdateNoteTool}/logic.js

@@ -79,7 +79,7 @@ const WholeFileUpdateSchema = BaseUpdateSchema.extend({
  * relying on the refined schema (`ObsidianUpdateFileInputSchema`) for stricter validation
  * within the handler logic.
  */
-const ObsidianUpdateFileRegistrationSchema = z
+const ObsidianUpdateNoteRegistrationSchema = z
     .object({
     /** Specifies the target note: 'filePath' (requires targetIdentifier), 'activeFile' (currently open file), or 'periodicNote' (requires targetIdentifier with period like 'daily'). */
     targetType: TargetTypeSchema,
@@ -122,7 +122,7 @@ const ObsidianUpdateFileRegistrationSchema = z
  * The shape of the registration schema, used by `server.tool` for basic validation.
  * @see ObsidianUpdateFileRegistrationSchema
  */
-export const ObsidianUpdateFileInputSchemaShape = ObsidianUpdateFileRegistrationSchema.shape;
+export const ObsidianUpdateNoteInputSchemaShape = ObsidianUpdateNoteRegistrationSchema.shape;
 // ====================================================================================
 // Refined Schema for Internal Logic and Strict Validation
 // ====================================================================================
@@ -131,7 +131,7 @@ export const ObsidianUpdateFileInputSchemaShape = ObsidianUpdateFileRegistration
  * 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 const ObsidianUpdateFileInputSchema = WholeFileUpdateSchema.refine((data) => {
+export const ObsidianUpdateNoteInputSchema = WholeFileUpdateSchema.refine((data) => {
     // Rule 1: If targetType is 'filePath' or 'periodicNote', targetIdentifier must be provided.
     if ((data.targetType === "filePath" || data.targetType === "periodicNote") &&
         !data.targetIdentifier) {
@@ -207,9 +207,9 @@ async function getFinalState(targetType, targetIdentifier, period, obsidianServi
  * @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 const processObsidianUpdateFile = async (params, // Use the refined, validated type
+export const processObsidianUpdateNote = async (params, // Use the refined, validated type
 context, obsidianService, vaultCacheService) => {
-    logger.debug(`Processing obsidian_update_file request (wholeFile mode)`, {
+    logger.debug(`Processing obsidian_update_note request (wholeFile mode)`, {
         ...context,
         targetType: params.targetType,
         wholeFileMode: params.wholeFileMode,
@@ -251,7 +251,7 @@ context, obsidianService, vaultCacheService) => {
                 existsBefore = true;
                 logger.debug(`Target exists before operation.`, checkContext);
             }, {
-                operationName: "existenceCheckObsidianUpdateFile",
+                operationName: "existenceCheckObsidianUpdateNote",
                 context: checkContext,
                 maxRetries: 3, // Total attempts: 1 initial + 2 retries
                 delayMs: 250,
@@ -263,7 +263,7 @@ context, obsidianService, vaultCacheService) => {
                         params.createIfNeeded;
                     if (error instanceof McpError &&
                         error.code === BaseErrorCode.NOT_FOUND) {
-                        logger.debug(`existenceCheckObsidianUpdateFile: shouldRetry=${should} for NOT_FOUND (createIfNeeded: ${params.createIfNeeded})`, checkContext);
+                        logger.debug(`existenceCheckObsidianUpdateNote: shouldRetry=${should} for NOT_FOUND (createIfNeeded: ${params.createIfNeeded})`, checkContext);
                     }
                     return should;
                 },

package/dist/mcp-server/tools/{obsidianUpdateFileTool → obsidianUpdateNoteTool}/registration.d.ts

@@ -1,7 +1,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { ObsidianRestApiService, VaultCacheService } from "../../../services/obsidianRestAPI/index.js";
 /**
- * Registers the 'obsidian_update_file' tool with the MCP server.
+ * Registers the 'obsidian_update_note' tool with the MCP server.
  *
  * This tool allows modification of Obsidian notes (specified by file path,
  * the active file, or a periodic note) using whole-file operations:
@@ -18,4 +18,4 @@ import { ObsidianRestApiService, VaultCacheService } from "../../../services/obs
  * @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 registerObsidianUpdateFileTool: (server: McpServer, obsidianService: ObsidianRestApiService, vaultCacheService: VaultCacheService | undefined) => Promise<void>;
+export declare const registerObsidianUpdateNoteTool: (server: McpServer, obsidianService: ObsidianRestApiService, vaultCacheService: VaultCacheService | undefined) => Promise<void>;