obsidian-mcp-server 1.5.8 → 2.0.2

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

@@ -0,0 +1,179 @@
+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 { logger, retryWithDelay, } from "../../../utils/index.js";
+// ====================================================================================
+// Schema Definitions for Input Validation
+// ====================================================================================
+/**
+ * Zod schema for validating the input parameters of the 'obsidian_list_files' tool.
+ */
+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
+        .string()
+        .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"]
+     */
+    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.'),
+    /**
+     * 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
+        .describe("Optional regex pattern (JavaScript syntax) to filter results by name."),
+})
+    .describe("Input parameters for listing files and subdirectories within a specified Obsidian vault directory, with optional filtering.");
+// ====================================================================================
+// 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.
+ *
+ * @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.
+ */
+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
+    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
+    });
+    return treeString;
+}
+// ====================================================================================
+// 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.
+ *
+ * @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.
+ */
+export const processObsidianListFiles = async (params, context, obsidianService) => {
+    const { dirPath, fileExtensionFilter, nameRegexFilter } = params;
+    // Normalize dirPath for logging and response (use "/" for root)
+    const dirPathForLog = dirPath === "" || dirPath === "/" ? "/" : dirPath;
+    logger.debug(`Processing obsidian_list_files request for path: ${dirPathForLog}`, { ...context, fileExtensionFilter, nameRegexFilter });
+    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);
+        const shouldRetryNotFound = (err) => err instanceof McpError && err.code === BaseErrorCode.NOT_FOUND;
+        let fileNames = await retryWithDelay(() => obsidianService.listFiles(effectiveDirPath, listContext), {
+            operationName: "listFilesWithRetry",
+            context: listContext,
+            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 ---
+        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
+        const response = {
+            directoryPath: dirPathForLog, // Return the normalized path
+            tree: treeString,
+            totalEntries: totalEntries,
+        };
+        logger.debug(`Successfully processed list request for ${dirPathForLog}.`, 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
+            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);
+            }
+            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);
+        }
+    }
+};

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

@@ -0,0 +1,19 @@
+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.
+ *
+ * @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 registerObsidianListFilesTool: (server: McpServer, obsidianService: ObsidianRestApiService) => Promise<void>;

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

@@ -0,0 +1,96 @@
+import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
+import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js";
+import { ObsidianListFilesInputSchema, processObsidianListFiles, } from "./logic.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.
+ *
+ * @param {McpServer} server - The MCP server instance to register the tool with.
+ * @param {ObsidianRestApiService} obsidianService - An instance of the Obsidian REST API service
+ *   used to interact with the user's Obsidian vault.
+ * @returns {Promise<void>} A promise that resolves when the tool registration is complete or rejects on error.
+ * @throws {McpError} Throws an McpError if registration fails critically.
+ */
+export const 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.";
+    // Create a context specifically for the registration process.
+    const registrationContext = requestContextService.createRequestContext({
+        operation: "RegisterObsidianListFilesTool",
+        toolName: toolName,
+        module: "ObsidianListFilesRegistration", // Identify the module
+    });
+    logger.info(`Attempting to register tool: ${toolName}`, registrationContext);
+    // Wrap the registration logic in a tryCatch block for robust error handling during server setup.
+    await ErrorHandler.tryCatch(async () => {
+        // Use the high-level SDK method `server.tool` for registration.
+        server.tool(toolName, toolDescription, ObsidianListFilesInputSchema.shape, // Provide the Zod schema shape for input definition.
+        /**
+         * The handler function executed when the 'obsidian_list_files' tool is called by the client.
+         *
+         * @param {ObsidianListFilesInput} params - The input parameters received from the client,
+         *   validated against the ObsidianListFilesInputSchema shape.
+         * @returns {Promise<CallToolResult>} A promise resolving to the structured result for the MCP client,
+         *   containing either the successful response data (serialized JSON) or an error indication.
+         */
+        async (params) => {
+            // Type matches the inferred input schema
+            // Create a specific context for this handler invocation.
+            const handlerContext = requestContextService.createRequestContext({
+                parentContext: registrationContext, // Link to registration context
+                operation: "HandleObsidianListFilesRequest",
+                toolName: toolName,
+                params: {
+                    // Log all relevant parameters for debugging
+                    dirPath: params.dirPath,
+                    fileExtensionFilter: params.fileExtensionFilter,
+                    nameRegexFilter: params.nameRegexFilter,
+                },
+            });
+            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: [
+                        {
+                            type: "text", // Standard content type for structured JSON data
+                            text: JSON.stringify(response, null, 2), // Pretty-print JSON
+                        },
+                    ],
+                    isError: false, // Indicate successful execution
+                };
+            }, {
+                // Configuration for the inner error handler (processing logic).
+                operation: `processing ${toolName} handler`,
+                context: handlerContext,
+                input: params, // Log the full input parameters if an error occurs.
+                // Custom error mapping for consistent error reporting.
+                errorMapper: (error) => new McpError(error instanceof McpError
+                    ? error.code
+                    : BaseErrorCode.INTERNAL_ERROR, `Error processing ${toolName} tool: ${error instanceof Error ? error.message : "Unknown error"}`, { ...handlerContext }),
+            }); // End of inner ErrorHandler.tryCatch
+        }); // End of server.tool call
+        logger.info(`Tool registered successfully: ${toolName}`, registrationContext);
+    }, {
+        // Configuration for the outer error handler (registration process).
+        operation: `registering tool ${toolName}`,
+        context: registrationContext,
+        errorCode: BaseErrorCode.INTERNAL_ERROR, // Default error code for registration failure.
+        // Custom error mapping for registration failures.
+        errorMapper: (error) => new McpError(error instanceof McpError ? error.code : BaseErrorCode.INTERNAL_ERROR, `Failed to register tool '${toolName}': ${error instanceof Error ? error.message : "Unknown error"}`, { ...registrationContext }),
+        critical: true, // Treat registration failure as critical.
+    }); // End of outer ErrorHandler.tryCatch
+};

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

@@ -0,0 +1,3 @@
+export { ObsidianManageFrontmatterInputSchemaShape, processObsidianManageFrontmatter, } from "./logic.js";
+export type { ObsidianManageFrontmatterInput, ObsidianManageFrontmatterResponse, } from "./logic.js";
+export { registerObsidianManageFrontmatterTool } from "./registration.js";

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

@@ -0,0 +1,2 @@
+export { ObsidianManageFrontmatterInputSchemaShape, processObsidianManageFrontmatter, } from "./logic.js";
+export { registerObsidianManageFrontmatterTool } from "./registration.js";

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

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { ObsidianRestApiService, VaultCacheService } from "../../../services/obsidianRestAPI/index.js";
+import { RequestContext } from "../../../utils/index.js";
+export declare const ObsidianManageFrontmatterInputSchemaShape: {
+    filePath: z.ZodString;
+    operation: z.ZodEnum<["get", "set", "delete"]>;
+    key: z.ZodString;
+    value: z.ZodOptional<z.ZodAny>;
+};
+export declare const ManageFrontmatterInputSchema: z.ZodEffects<z.ZodObject<{
+    filePath: z.ZodString;
+    operation: z.ZodEnum<["get", "set", "delete"]>;
+    key: z.ZodString;
+    value: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    operation: "get" | "delete" | "set";
+    key: string;
+    filePath: string;
+    value?: any;
+}, {
+    operation: "get" | "delete" | "set";
+    key: string;
+    filePath: string;
+    value?: any;
+}>, {
+    operation: "get" | "delete" | "set";
+    key: string;
+    filePath: string;
+    value?: any;
+}, {
+    operation: "get" | "delete" | "set";
+    key: string;
+    filePath: string;
+    value?: any;
+}>;
+export type ObsidianManageFrontmatterInput = z.infer<typeof ManageFrontmatterInputSchema>;
+export interface ObsidianManageFrontmatterResponse {
+    success: boolean;
+    message: string;
+    value?: any;
+}
+export declare const processObsidianManageFrontmatter: (params: ObsidianManageFrontmatterInput, context: RequestContext, obsidianService: ObsidianRestApiService, vaultCacheService: VaultCacheService | undefined) => Promise<ObsidianManageFrontmatterResponse>;

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

@@ -0,0 +1,152 @@
+import { z } from "zod";
+import { dump } from "js-yaml";
+import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
+import { logger, retryWithDelay, } from "../../../utils/index.js";
+// ====================================================================================
+// Schema Definitions
+// ====================================================================================
+const ManageFrontmatterInputSchemaBase = z.object({
+    filePath: z
+        .string()
+        .min(1)
+        .describe("The vault-relative path to the target note (e.g., 'Projects/Active/My Note.md')."),
+    operation: z
+        .enum(["get", "set", "delete"])
+        .describe("The operation to perform on the frontmatter: 'get' to read a key, 'set' to create or update a key, or 'delete' to remove a key."),
+    key: z
+        .string()
+        .min(1)
+        .describe("The name of the frontmatter key to target, such as 'status', 'tags', or 'aliases'."),
+    value: z
+        .any()
+        .optional()
+        .describe("The value to assign when using the 'set' operation. Can be a string, number, boolean, array, or a JSON object."),
+});
+export const ObsidianManageFrontmatterInputSchemaShape = ManageFrontmatterInputSchemaBase.shape;
+export const ManageFrontmatterInputSchema = ManageFrontmatterInputSchemaBase.refine((data) => {
+    if (data.operation === "set" && data.value === undefined) {
+        return false;
+    }
+    return true;
+}, {
+    message: "A 'value' is required when the 'operation' is 'set'.",
+    path: ["value"],
+});
+// ====================================================================================
+// Core Logic Function
+// ====================================================================================
+export const processObsidianManageFrontmatter = async (params, context, obsidianService, vaultCacheService) => {
+    logger.debug(`Processing obsidian_manage_frontmatter request`, {
+        ...context,
+        operation: params.operation,
+        filePath: params.filePath,
+        key: params.key,
+    });
+    const { filePath, operation, key, value } = params;
+    const shouldRetryNotFound = (err) => err instanceof McpError && err.code === BaseErrorCode.NOT_FOUND;
+    const getFileWithRetry = async (opContext, format = "json") => {
+        return await retryWithDelay(() => obsidianService.getFileContent(filePath, format, opContext), {
+            operationName: `getFileContentForFrontmatter`,
+            context: opContext,
+            maxRetries: 3,
+            delayMs: 300,
+            shouldRetry: shouldRetryNotFound,
+        });
+    };
+    switch (operation) {
+        case "get": {
+            const note = (await getFileWithRetry(context));
+            const frontmatter = note.frontmatter ?? {};
+            const retrievedValue = frontmatter[key];
+            return {
+                success: true,
+                message: `Successfully retrieved key '${key}' from frontmatter.`,
+                value: retrievedValue,
+            };
+        }
+        case "set": {
+            const patchOptions = {
+                operation: "replace",
+                targetType: "frontmatter",
+                target: key,
+                createTargetIfMissing: true,
+                contentType: typeof value === "object" ? "application/json" : "text/markdown",
+            };
+            const content = typeof value === "object" ? JSON.stringify(value) : String(value);
+            await retryWithDelay(() => obsidianService.patchFile(filePath, content, patchOptions, context), {
+                operationName: `patchFileForFrontmatterSet`,
+                context,
+                maxRetries: 3,
+                delayMs: 300,
+                shouldRetry: shouldRetryNotFound,
+            });
+            if (vaultCacheService) {
+                await vaultCacheService.updateCacheForFile(filePath, context);
+            }
+            return {
+                success: true,
+                message: `Successfully set key '${key}' in frontmatter.`,
+                value: { [key]: value },
+            };
+        }
+        case "delete": {
+            // Note on deletion strategy: The Obsidian REST API's PATCH endpoint for frontmatter
+            // supports adding/updating keys but does not have a dedicated "delete key" operation.
+            // Therefore, deletion is handled by reading the note content, parsing the frontmatter,
+            // removing the key from the JavaScript object, and then overwriting the entire note
+            // with the updated frontmatter block. This regex-based replacement is a workaround
+            // for the current API limitations.
+            const noteJson = (await getFileWithRetry(context, "json"));
+            const frontmatter = noteJson.frontmatter;
+            if (!frontmatter || frontmatter[key] === undefined) {
+                return {
+                    success: true,
+                    message: `Key '${key}' not found in frontmatter. No action taken.`,
+                    value: {},
+                };
+            }
+            delete frontmatter[key];
+            const noteContent = (await getFileWithRetry(context, "markdown"));
+            const frontmatterRegex = /^---\n([\s\S]*?)\n---\n/;
+            const match = noteContent.match(frontmatterRegex);
+            let newContent;
+            const newFrontmatterString = Object.keys(frontmatter).length > 0 ? dump(frontmatter) : "";
+            if (match) {
+                // Frontmatter exists, replace it
+                if (newFrontmatterString) {
+                    newContent = noteContent.replace(frontmatterRegex, `---\n${newFrontmatterString}---\n`);
+                }
+                else {
+                    // If frontmatter is now empty, remove the block entirely
+                    newContent = noteContent.replace(frontmatterRegex, "");
+                }
+            }
+            else {
+                // This case should be rare given the initial check, but handle it defensively
+                logger.warning("Frontmatter key existed in JSON but block not found in markdown. No action taken.", context);
+                return {
+                    success: false,
+                    message: `Could not find frontmatter block to update, though key '${key}' was detected.`,
+                    value: {},
+                };
+            }
+            await retryWithDelay(() => obsidianService.updateFileContent(filePath, newContent, context), {
+                operationName: `updateFileForFrontmatterDelete`,
+                context,
+                maxRetries: 3,
+                delayMs: 300,
+                shouldRetry: shouldRetryNotFound,
+            });
+            if (vaultCacheService) {
+                await vaultCacheService.updateCacheForFile(filePath, context);
+            }
+            return {
+                success: true,
+                message: `Successfully deleted key '${key}' from frontmatter.`,
+                value: {},
+            };
+        }
+        default:
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid operation: ${operation}`, context);
+    }
+};

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

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

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

@@ -0,0 +1,52 @@
+import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
+import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js";
+import { ManageFrontmatterInputSchema, ObsidianManageFrontmatterInputSchemaShape, processObsidianManageFrontmatter, } from "./logic.js";
+export const registerObsidianManageFrontmatterTool = async (server, obsidianService, vaultCacheService) => {
+    const toolName = "obsidian_manage_frontmatter";
+    const toolDescription = "Atomically manages a note's YAML frontmatter. Supports getting, setting (creating/updating), and deleting specific keys without rewriting the entire file. Ideal for efficient metadata operations on primitive or structured Obsidian frontmatter data.";
+    const registrationContext = requestContextService.createRequestContext({
+        operation: "RegisterObsidianManageFrontmatterTool",
+        toolName: toolName,
+        module: "ObsidianManageFrontmatterRegistration",
+    });
+    logger.info(`Attempting to register tool: ${toolName}`, registrationContext);
+    await ErrorHandler.tryCatch(async () => {
+        server.tool(toolName, toolDescription, ObsidianManageFrontmatterInputSchemaShape, async (params) => {
+            const handlerContext = requestContextService.createRequestContext({
+                parentContext: registrationContext,
+                operation: "HandleObsidianManageFrontmatterRequest",
+                toolName: toolName,
+                params: params,
+            });
+            logger.debug(`Handling '${toolName}' request`, handlerContext);
+            return await ErrorHandler.tryCatch(async () => {
+                const validatedParams = ManageFrontmatterInputSchema.parse(params);
+                const response = await processObsidianManageFrontmatter(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/obsidianManageTagsTool/index.d.ts

@@ -0,0 +1,3 @@
+export { ObsidianManageTagsInputSchemaShape, processObsidianManageTags, } from "./logic.js";
+export type { ObsidianManageTagsInput, ObsidianManageTagsResponse, } from "./logic.js";
+export { registerObsidianManageTagsTool } from "./registration.js";

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

@@ -0,0 +1,2 @@
+export { ObsidianManageTagsInputSchemaShape, processObsidianManageTags, } from "./logic.js";
+export { registerObsidianManageTagsTool } from "./registration.js";

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

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { ObsidianRestApiService, VaultCacheService } from "../../../services/obsidianRestAPI/index.js";
+import { RequestContext } from "../../../utils/index.js";
+export declare const ObsidianManageTagsInputSchemaShape: {
+    filePath: z.ZodString;
+    operation: z.ZodEnum<["add", "remove", "list"]>;
+    tags: z.ZodArray<z.ZodString, "many">;
+};
+export declare const ManageTagsInputSchema: z.ZodObject<{
+    filePath: z.ZodString;
+    operation: z.ZodEnum<["add", "remove", "list"]>;
+    tags: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    operation: "add" | "remove" | "list";
+    filePath: string;
+    tags: string[];
+}, {
+    operation: "add" | "remove" | "list";
+    filePath: string;
+    tags: string[];
+}>;
+export type ObsidianManageTagsInput = z.infer<typeof ManageTagsInputSchema>;
+export interface ObsidianManageTagsResponse {
+    success: boolean;
+    message: string;
+    currentTags: string[];
+}
+export declare const processObsidianManageTags: (params: ObsidianManageTagsInput, context: RequestContext, obsidianService: ObsidianRestApiService, vaultCacheService: VaultCacheService | undefined) => Promise<ObsidianManageTagsResponse>;