obsidian-mcp-server 2.0.7 → 3.1.0

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

@@ -1,161 +0,0 @@
-import { z } from "zod";
-import { dump } from "js-yaml";
-import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
-import { logger, retryWithDelay, } from "../../../utils/index.js";
-import { sanitization } from "../../../utils/security/sanitization.js";
-// ====================================================================================
-// Schema Definitions
-// ====================================================================================
-const ManageTagsInputSchemaBase = z.object({
-    filePath: z
-        .string()
-        .min(1)
-        .describe("The vault-relative path to the target note (e.g., 'Journal/2024-06-12.md')."),
-    operation: z
-        .enum(["add", "remove", "list"])
-        .describe("The tag operation to perform: 'add' to include new tags, 'remove' to delete existing tags, or 'list' to view all current tags."),
-    tags: z
-        .array(z.string())
-        .describe("An array of tag names to be processed. The '#' prefix should be omitted (e.g., use 'project/active', not '#project/active')."),
-});
-export const ObsidianManageTagsInputSchemaShape = ManageTagsInputSchemaBase.shape;
-export const ManageTagsInputSchema = ManageTagsInputSchemaBase;
-// ====================================================================================
-// Core Logic Function
-// ====================================================================================
-export const processObsidianManageTags = async (params, context, obsidianService, vaultCacheService) => {
-    logger.debug(`Processing obsidian_manage_tags request`, {
-        ...context,
-        ...params,
-    });
-    const { filePath, operation, tags: inputTags } = params;
-    const sanitizedTags = inputTags.map((t) => sanitization.sanitizeTagName(t));
-    const shouldRetryNotFound = (err) => err instanceof McpError && err.code === BaseErrorCode.NOT_FOUND;
-    const getFileWithRetry = async (opContext, format) => {
-        return await retryWithDelay(() => obsidianService.getFileContent(filePath, format, opContext), {
-            operationName: `getFileContentForTagManagement`,
-            context: opContext,
-            maxRetries: 3,
-            delayMs: 300,
-            shouldRetry: shouldRetryNotFound,
-        });
-    };
-    const initialNote = (await getFileWithRetry(context, "json"));
-    const currentTags = initialNote.tags;
-    switch (operation) {
-        case "list": {
-            return {
-                success: true,
-                message: "Successfully listed all tags.",
-                currentTags: currentTags,
-            };
-        }
-        case "add": {
-            const tagsToAdd = sanitizedTags.filter((t) => !currentTags.includes(t));
-            if (tagsToAdd.length === 0) {
-                return {
-                    success: true,
-                    message: "No new tags to add; all provided tags already exist in the note.",
-                    currentTags: currentTags,
-                };
-            }
-            const frontmatter = initialNote.frontmatter ?? {};
-            const frontmatterTags = Array.isArray(frontmatter.tags)
-                ? frontmatter.tags
-                : [];
-            const newFrontmatterTags = [
-                ...new Set([...frontmatterTags, ...tagsToAdd]),
-            ];
-            frontmatter.tags = newFrontmatterTags;
-            const noteContent = (await getFileWithRetry(context, "markdown"));
-            const frontmatterRegex = /^---\n([\s\S]*?)\n---\n/;
-            const match = noteContent.match(frontmatterRegex);
-            const newFrontmatterString = dump(frontmatter);
-            let newContent;
-            if (match) {
-                newContent = noteContent.replace(frontmatterRegex, `---\n${newFrontmatterString}---\n`);
-            }
-            else {
-                newContent = `---\n${newFrontmatterString}---\n\n${noteContent}`;
-            }
-            await retryWithDelay(() => obsidianService.updateFileContent(filePath, newContent, context), {
-                operationName: `updateFileForTagAdd`,
-                context,
-                maxRetries: 3,
-                delayMs: 300,
-                shouldRetry: shouldRetryNotFound,
-            });
-            if (vaultCacheService) {
-                await vaultCacheService.updateCacheForFile(filePath, context);
-            }
-            const finalTags = [...new Set([...currentTags, ...tagsToAdd])];
-            return {
-                success: true,
-                message: `Successfully added tags: ${tagsToAdd.join(", ")}.`,
-                currentTags: finalTags,
-            };
-        }
-        case "remove": {
-            const tagsToRemove = sanitizedTags.filter((t) => currentTags.includes(t));
-            if (tagsToRemove.length === 0) {
-                return {
-                    success: true,
-                    message: "No tags to remove; none of the provided tags exist in the note.",
-                    currentTags: currentTags,
-                };
-            }
-            let noteContent = (await getFileWithRetry(context, "markdown"));
-            const frontmatter = initialNote.frontmatter ?? {};
-            let frontmatterTags = Array.isArray(frontmatter.tags)
-                ? frontmatter.tags
-                : [];
-            const newFrontmatterTags = frontmatterTags.filter((t) => !tagsToRemove.includes(t));
-            let frontmatterModified = newFrontmatterTags.length !== frontmatterTags.length;
-            if (frontmatterModified) {
-                frontmatter.tags = newFrontmatterTags;
-                if (newFrontmatterTags.length === 0) {
-                    delete frontmatter.tags;
-                }
-            }
-            const frontmatterRegex = /^---\n([\s\S]*?)\n---\n/;
-            const match = noteContent.match(frontmatterRegex);
-            if (frontmatterModified && match) {
-                const newFrontmatterString = Object.keys(frontmatter).length > 0 ? dump(frontmatter) : "";
-                if (newFrontmatterString) {
-                    noteContent = noteContent.replace(frontmatterRegex, `---\n${newFrontmatterString}---\n`);
-                }
-                else {
-                    noteContent = noteContent.replace(frontmatterRegex, "");
-                }
-            }
-            let inlineModified = false;
-            for (const tag of tagsToRemove) {
-                const regex = new RegExp(`(^|[^\\w-#])#${tag}\\b`, "g");
-                if (regex.test(noteContent)) {
-                    noteContent = noteContent.replace(regex, "$1");
-                    inlineModified = true;
-                }
-            }
-            if (frontmatterModified || inlineModified) {
-                await retryWithDelay(() => obsidianService.updateFileContent(filePath, noteContent, context), {
-                    operationName: `updateFileContentForTagRemove`,
-                    context,
-                    maxRetries: 3,
-                    delayMs: 300,
-                    shouldRetry: shouldRetryNotFound,
-                });
-            }
-            if (vaultCacheService) {
-                await vaultCacheService.updateCacheForFile(filePath, context);
-            }
-            const finalTags = currentTags.filter((t) => !tagsToRemove.includes(t));
-            return {
-                success: true,
-                message: `Successfully removed tags: ${tagsToRemove.join(", ")}.`,
-                currentTags: finalTags,
-            };
-        }
-        default:
-            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid operation: ${operation}`, context);
-    }
-};

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

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

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

@@ -1,52 +0,0 @@
-import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
-import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js";
-import { ManageTagsInputSchema, ObsidianManageTagsInputSchemaShape, processObsidianManageTags, } from "./logic.js";
-export const registerObsidianManageTagsTool = async (server, obsidianService, vaultCacheService) => {
-    const toolName = "obsidian_manage_tags";
-    const toolDescription = "Manages tags for a specified note, handling them in both the YAML frontmatter and inline content. Supports adding, removing, and listing tags to provide a comprehensive tag management solution.";
-    const registrationContext = requestContextService.createRequestContext({
-        operation: "RegisterObsidianManageTagsTool",
-        toolName: toolName,
-        module: "ObsidianManageTagsRegistration",
-    });
-    logger.info(`Attempting to register tool: ${toolName}`, registrationContext);
-    await ErrorHandler.tryCatch(async () => {
-        server.tool(toolName, toolDescription, ObsidianManageTagsInputSchemaShape, async (params) => {
-            const handlerContext = requestContextService.createRequestContext({
-                parentContext: registrationContext,
-                operation: "HandleObsidianManageTagsRequest",
-                toolName: toolName,
-                params: params,
-            });
-            logger.debug(`Handling '${toolName}' request`, handlerContext);
-            return await ErrorHandler.tryCatch(async () => {
-                const validatedParams = ManageTagsInputSchema.parse(params);
-                const response = await processObsidianManageTags(validatedParams, handlerContext, obsidianService, vaultCacheService);
-                logger.debug(`'${toolName}' processed successfully`, handlerContext);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(response, null, 2),
-                        },
-                    ],
-                    isError: false,
-                };
-            }, {
-                operation: `processing ${toolName} handler`,
-                context: handlerContext,
-                input: params,
-                errorMapper: (error) => new McpError(error instanceof McpError
-                    ? error.code
-                    : BaseErrorCode.INTERNAL_ERROR, `Error processing ${toolName} tool: ${error instanceof Error ? error.message : "Unknown error"}`, { ...handlerContext }),
-            });
-        });
-        logger.info(`Tool registered successfully: ${toolName}`, registrationContext);
-    }, {
-        operation: `registering tool ${toolName}`,
-        context: registrationContext,
-        errorCode: BaseErrorCode.INTERNAL_ERROR,
-        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,
-    });
-};

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

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

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

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

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

@@ -1,87 +0,0 @@
-import { z } from "zod";
-import { NoteJson, ObsidianRestApiService } from "../../../services/obsidianRestAPI/index.js";
-import { RequestContext } from "../../../utils/index.js";
-/**
- * Zod schema for validating the input parameters of the 'obsidian_read_note' tool.
- */
-export declare const ObsidianReadNoteInputSchema: z.ZodObject<{
-    /**
-     * The vault-relative path to the target file (e.g., "Folder/My Note.md").
-     * Must include the file extension. The tool first attempts a case-sensitive match.
-     * If not found, it attempts a case-insensitive fallback search within the same directory.
-     */
-    filePath: z.ZodString;
-    /**
-     * Specifies the desired format for the returned content.
-     * 'markdown' returns the raw file content as a string.
-     * 'json' returns a structured NoteJson object containing content, parsed frontmatter, tags, and file metadata (stat).
-     * Defaults to 'markdown'.
-     */
-    format: z.ZodOptional<z.ZodDefault<z.ZodEnum<["markdown", "json"]>>>;
-    /**
-     * If true and the requested format is 'markdown', includes formatted file statistics
-     * (creation time, modification time, token count estimate) in the response's 'stat' field.
-     * Defaults to false. This flag is ignored if the format is 'json', as stats are always included within the NoteJson object itself (and also added to the top-level 'stat' field in the response).
-     */
-    includeStat: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    filePath: string;
-    includeStat: boolean;
-    format?: "markdown" | "json" | undefined;
-}, {
-    filePath: string;
-    format?: "markdown" | "json" | undefined;
-    includeStat?: boolean | undefined;
-}>;
-/**
- * TypeScript type inferred from the input schema (`ObsidianReadNoteInputSchema`).
- * Represents the validated input parameters used within the core processing logic.
- */
-export type ObsidianReadNoteInput = z.infer<typeof ObsidianReadNoteInputSchema>;
-/**
- * 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 (e.g., "05:29:00 PM | 05-03-2025"). */
-    createdTime: string;
-    /** Last modified time formatted as a standard date-time string (e.g., "05:29:00 PM | 05-03-2025"). */
-    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 `processObsidianReadNote` function.
- * This object is typically serialized to JSON and sent back to the client.
- */
-export interface ObsidianReadNoteResponse {
-    /**
-     * The content of the file in the requested format.
-     * If format='markdown', this is a string.
-     * If format='json', this is a NoteJson object (which also contains the content string and stats).
-     */
-    content: string | NoteJson;
-    /**
-     * Optional formatted file statistics.
-     * Included if format='json', or if format='markdown' and includeStat=true.
-     */
-    stats?: FormattedStat;
-}
-/**
- * Processes the core logic for reading a file from the Obsidian vault.
- *
- * It attempts to read the file using the provided path (case-sensitive first,
- * then case-insensitive fallback). It always fetches the full NoteJson object
- * internally to access file statistics. Finally, it formats the response
- * according to the requested format ('markdown' or 'json') and the 'includeStat' flag.
- *
- * @param {ObsidianReadNoteInput} 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<ObsidianReadNoteResponse>} A promise resolving to the structured success response
- *   containing the file content and optionally formatted statistics.
- * @throws {McpError} Throws an McpError if the file cannot be found (even with fallback),
- *   if there's an ambiguous fallback match, or if any other API interaction fails.
- */
-export declare const processObsidianReadNote: (params: ObsidianReadNoteInput, context: RequestContext, obsidianService: ObsidianRestApiService) => Promise<ObsidianReadNoteResponse>;
-export {};

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

@@ -1,216 +0,0 @@
-import path from "node:path"; // Using POSIX path functions for vault path manipulation
-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 allowed formats for the returned file content.
- * - 'markdown': Returns the raw Markdown content as a string.
- * - 'json': Returns a structured NoteJson object including content, frontmatter, tags, and stats.
- */
-const ReadNoteFormatSchema = z
-    .enum(["markdown", "json"])
-    .default("markdown")
-    .describe("Specifies the format for the returned content ('markdown' or 'json'). Defaults to 'markdown'.");
-/**
- * Zod schema for validating the input parameters of the 'obsidian_read_note' tool.
- */
-export const ObsidianReadNoteInputSchema = z
-    .object({
-    /**
-     * The vault-relative path to the target file (e.g., "Folder/My Note.md").
-     * Must include the file extension. The tool first attempts a case-sensitive match.
-     * If not found, it attempts a case-insensitive fallback search within the same directory.
-     */
-    filePath: z
-        .string()
-        .min(1, "filePath cannot be empty")
-        .describe('The vault-relative path to the target file (e.g., "developer/github/tips.md"). Tries case-sensitive first, then case-insensitive fallback.'),
-    /**
-     * Specifies the desired format for the returned content.
-     * 'markdown' returns the raw file content as a string.
-     * 'json' returns a structured NoteJson object containing content, parsed frontmatter, tags, and file metadata (stat).
-     * Defaults to 'markdown'.
-     */
-    format: ReadNoteFormatSchema.optional() // Optional, defaults to 'markdown' via ReadNoteFormatSchema
-        .describe("Format for the returned content ('markdown' or 'json'). Defaults to 'markdown'."),
-    /**
-     * If true and the requested format is 'markdown', includes formatted file statistics
-     * (creation time, modification time, token count estimate) in the response's 'stat' field.
-     * Defaults to false. This flag is ignored if the format is 'json', as stats are always included within the NoteJson object itself (and also added to the top-level 'stat' field in the response).
-     */
-    includeStat: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("If true and format is 'markdown', includes file stats in the response. Defaults to false. Ignored if format is 'json'."),
-})
-    .describe("Retrieves the content and optionally metadata of a specific file within the connected Obsidian vault. Supports case-insensitive path fallback.");
-// ====================================================================================
-// Core Logic Function
-// ====================================================================================
-/**
- * Processes the core logic for reading a file from the Obsidian vault.
- *
- * It attempts to read the file using the provided path (case-sensitive first,
- * then case-insensitive fallback). It always fetches the full NoteJson object
- * internally to access file statistics. Finally, it formats the response
- * according to the requested format ('markdown' or 'json') and the 'includeStat' flag.
- *
- * @param {ObsidianReadNoteInput} 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<ObsidianReadNoteResponse>} A promise resolving to the structured success response
- *   containing the file content and optionally formatted statistics.
- * @throws {McpError} Throws an McpError if the file cannot be found (even with fallback),
- *   if there's an ambiguous fallback match, or if any other API interaction fails.
- */
-export const processObsidianReadNote = async (params, context, obsidianService) => {
-    const { filePath: originalFilePath, format: requestedFormat, includeStat, } = params;
-    let effectiveFilePath = originalFilePath; // Track the actual path used (might change during fallback)
-    logger.debug(`Processing obsidian_read_note request for path: ${originalFilePath}`, { ...context, format: requestedFormat, includeStat });
-    const shouldRetryNotFound = (err) => err instanceof McpError && err.code === BaseErrorCode.NOT_FOUND;
-    try {
-        let noteJson;
-        // --- Step 1: Read File Content (always fetch JSON internally) ---
-        const readContext = { ...context, operation: "readFileAsJson" };
-        try {
-            // Attempt 1: Read using the provided path (case-sensitive)
-            logger.debug(`Attempting to read file as JSON (case-sensitive): ${originalFilePath}`, readContext);
-            noteJson = await retryWithDelay(() => obsidianService.getFileContent(originalFilePath, "json", readContext), {
-                operationName: "readFileWithRetry",
-                context: readContext,
-                maxRetries: 3,
-                delayMs: 300,
-                shouldRetry: shouldRetryNotFound,
-            });
-            effectiveFilePath = originalFilePath; // Confirm exact path worked
-            logger.debug(`Successfully read file as JSON using exact path: ${originalFilePath}`, readContext);
-        }
-        catch (error) {
-            // Attempt 2: Case-insensitive fallback if initial read failed with NOT_FOUND
-            if (error instanceof McpError && error.code === BaseErrorCode.NOT_FOUND) {
-                logger.info(`File not found with exact path: ${originalFilePath}. Attempting case-insensitive fallback.`, readContext);
-                const fallbackContext = {
-                    ...readContext,
-                    subOperation: "caseInsensitiveFallback",
-                };
-                try {
-                    // Use POSIX path functions as vault paths are typically /-separated
-                    const dirname = path.posix.dirname(originalFilePath);
-                    const filenameLower = path.posix
-                        .basename(originalFilePath)
-                        .toLowerCase();
-                    // Handle case where the file is in the vault root (dirname is '.')
-                    const dirToList = dirname === "." ? "/" : dirname;
-                    logger.debug(`Listing directory for fallback: ${dirToList}`, fallbackContext);
-                    const filesInDir = await retryWithDelay(() => obsidianService.listFiles(dirToList, fallbackContext), {
-                        operationName: "listFilesForReadFallback",
-                        context: fallbackContext,
-                        maxRetries: 3,
-                        delayMs: 300,
-                        shouldRetry: shouldRetryNotFound,
-                    });
-                    // Filter directory listing for files matching the lowercase filename
-                    const matches = filesInDir.filter((f) => !f.endsWith("/") && // Ensure it's a file, not a directory entry ending in /
-                        path.posix.basename(f).toLowerCase() === filenameLower);
-                    if (matches.length === 1) {
-                        // Found exactly one case-insensitive match
-                        const correctFilename = path.posix.basename(matches[0]);
-                        effectiveFilePath = path.posix.join(dirname, correctFilename); // Construct the correct path
-                        logger.info(`Found case-insensitive match: ${effectiveFilePath}. Retrying read as JSON.`, fallbackContext);
-                        // Retry reading the file content using the corrected path
-                        noteJson = await retryWithDelay(() => obsidianService.getFileContent(effectiveFilePath, "json", fallbackContext), {
-                            operationName: "readFileWithFallbackRetry",
-                            context: fallbackContext,
-                            maxRetries: 3,
-                            delayMs: 300,
-                            shouldRetry: shouldRetryNotFound,
-                        });
-                        logger.debug(`Successfully read file as JSON using fallback path: ${effectiveFilePath}`, fallbackContext);
-                    }
-                    else if (matches.length > 1) {
-                        // Ambiguous match: Multiple files match case-insensitively
-                        logger.error(`Case-insensitive fallback failed: Multiple matches found for ${filenameLower} in ${dirToList}.`, { ...fallbackContext, matches });
-                        throw new McpError(BaseErrorCode.CONFLICT, // Use CONFLICT for ambiguity
-                        `File read failed: Ambiguous case-insensitive matches for '${originalFilePath}'. Found: [${matches.join(", ")}]`, fallbackContext);
-                    }
-                    else {
-                        // No match found even with fallback
-                        logger.error(`Case-insensitive fallback failed: No match found for ${filenameLower} in ${dirToList}.`, fallbackContext);
-                        throw new McpError(BaseErrorCode.NOT_FOUND, `File not found: '${originalFilePath}' (case-insensitive fallback also failed).`, fallbackContext);
-                    }
-                }
-                catch (fallbackError) {
-                    // Catch errors specifically from the fallback logic
-                    if (fallbackError instanceof McpError)
-                        throw fallbackError; // Re-throw known errors
-                    // Wrap unexpected fallback errors
-                    const errorMessage = `Unexpected error during case-insensitive fallback for ${originalFilePath}`;
-                    logger.error(errorMessage, fallbackError instanceof Error ? fallbackError : undefined, fallbackContext);
-                    throw new McpError(BaseErrorCode.INTERNAL_ERROR, `${errorMessage}: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`, fallbackContext);
-                }
-            }
-            else {
-                // Re-throw errors from the initial read attempt that were not NOT_FOUND
-                throw error;
-            }
-        }
-        // --- Step 2: Format the Response ---
-        const formatContext = {
-            ...context,
-            operation: "formatResponse",
-            effectiveFilePath,
-        };
-        logger.debug(`Formatting response. Requested format: ${requestedFormat}, Include stat: ${includeStat}`, formatContext);
-        // Generate formatted statistics using the utility function.
-        // Provide the content string for token counting. Handle cases where stat might be missing.
-        const formattedStatResult = noteJson.stat
-            ? await createFormattedStatWithTokenCount(noteJson.stat, noteJson.content ?? "", formatContext) // 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;
-        // Initialize the response object
-        const response = {
-            content: "", // Placeholder, will be set based on format
-            // stat is added conditionally below
-        };
-        // Populate response based on requested format
-        if (requestedFormat === "json") {
-            // Return the full NoteJson object. Its internal 'stat' will remain numeric.
-            // The formatted stats are provided in the top-level 'response.stats'.
-            response.content = noteJson;
-            response.stats = formattedStat; // Always include formatted stat at top level for JSON format
-            logger.debug(`Response format set to JSON, including full NoteJson (with original numeric stat) and top-level formatted stat.`, formatContext);
-        }
-        else {
-            // 'markdown' format
-            response.content = noteJson.content ?? ""; // Extract the markdown content string
-            if (includeStat && formattedStat) {
-                response.stats = formattedStat; // Include formatted stats only if requested for markdown
-                logger.debug(`Response format set to markdown, including formatted stat as requested.`, formatContext);
-            }
-            else {
-                logger.debug(`Response format set to markdown, excluding stat (includeStat=${includeStat}).`, formatContext);
-            }
-        }
-        logger.debug(`Successfully processed read request for ${effectiveFilePath}.`, context);
-        return response;
-    }
-    catch (error) {
-        // Catch any errors that propagated up (e.g., from initial read, fallback, or unexpected issues)
-        if (error instanceof McpError) {
-            // Log known McpErrors that reached this top level
-            logger.error(`McpError during file read process for ${originalFilePath}: ${error.message}`, error, context);
-            throw error; // Re-throw McpError
-        }
-        else {
-            // Wrap unexpected errors in a generic McpError
-            const errorMessage = `Unexpected error processing read request for ${originalFilePath}`;
-            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/obsidianReadNoteTool/registration.d.ts

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