obsidian-mcp-server 2.0.7 → 3.1.0

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

@@ -1,215 +0,0 @@
-/**
- * @fileoverview Core logic for the 'obsidian_list_notes' 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/obsidianListNotesTool/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";
-// ====================================================================================
-// Schema Definitions for Input Validation
-// ====================================================================================
-/**
- * Zod schema for validating the input parameters of the 'obsidian_list_notes' tool.
- */
-export const ObsidianListNotesInputSchema = z
-    .object({
-    /**
-     * The vault-relative path to the directory whose contents should be listed.
-     * 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.
-     */
-    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.
-     */
-    nameRegexFilter: z
-        .string()
-        .nullable()
-        .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 and recursion.");
-// ====================================================================================
-// Helper Functions
-// ====================================================================================
-/**
- * Recursively builds a formatted tree string from a nested array of FileTreeNode objects.
- *
- * @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 formatTree(nodes, indent = "") {
-    let treeString = "";
-    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 {ObsidianListNotesInput} 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 treeNodes;
-}
-// ====================================================================================
-// Core Logic Function
-// ====================================================================================
-/**
- * Processes the core logic for listing files and directories recursively within the Obsidian vault.
- *
- * @param {ObsidianListNotesInput} 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<ObsidianListNotesResponse>} 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 processObsidianListNotes = async (params, context, obsidianService) => {
-    const { dirPath } = params;
-    const dirPathForLog = dirPath === "" || dirPath === "/" ? "/" : dirPath;
-    logger.debug(`Processing obsidian_list_notes request for path: ${dirPathForLog}`, { ...context, params });
-    try {
-        const effectiveDirPath = dirPath === "" ? "/" : dirPath;
-        // --- 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;
-        const fileTree = await retryWithDelay(() => buildFileTree(effectiveDirPath, 0, // Start at depth 0
-        params, buildTreeContext, obsidianService), {
-            operationName: "buildFileTreeWithRetry",
-            context: buildTreeContext,
-            maxRetries: 3,
-            delayMs: 300,
-            shouldRetry: shouldRetryNotFound,
-        });
-        // --- Step 2: Format the tree and count entries ---
-        const formatContext = { ...context, operation: "formatResponse" };
-        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,
-            tree: tree.trimEnd(), // Remove trailing newline
-            totalEntries: count,
-        };
-        logger.debug(`Successfully processed list request for ${dirPathForLog}. Found ${count} entries.`, context);
-        return response;
-    }
-    catch (error) {
-        if (error instanceof McpError) {
-            // Provide a more specific message if the directory wasn't found after retries
-            if (error.code === BaseErrorCode.NOT_FOUND) {
-                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;
-        }
-        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/obsidianListNotesTool/registration.d.ts

@@ -1,23 +0,0 @@
-/**
- * @fileoverview Registers the 'obsidian_list_notes' 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/obsidianListNotesTool/registration
- */
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { ObsidianRestApiService } from "../../../services/obsidianRestAPI/index.js";
-/**
- * Registers the 'obsidian_list_notes' 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,
- * 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
- *   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 registerObsidianListNotesTool: (server: McpServer, obsidianService: ObsidianRestApiService) => Promise<void>;

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

@@ -1,98 +0,0 @@
-/**
- * @fileoverview Registers the 'obsidian_list_notes' 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/obsidianListNotesTool/registration
- */
-import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
-import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js";
-import { ObsidianListNotesInputSchema, processObsidianListNotes, } from "./logic.js";
-/**
- * Registers the 'obsidian_list_notes' 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,
- * 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
- *   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 registerObsidianListNotesTool = async (server, obsidianService) => {
-    const toolName = "obsidian_list_notes";
-    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: "RegisterObsidianListNotesTool",
-        toolName: toolName,
-        module: "ObsidianListNotesRegistration", // 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, ObsidianListNotesInputSchema.shape, // Provide the Zod schema shape for input definition.
-        /**
-         * The handler function executed when the 'obsidian_list_notes' tool is called by the client.
-         *
-         * @param {ObsidianListNotesInput} params - The input parameters received from the client,
-         *   validated against the ObsidianListNotesInputSchema 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: "HandleObsidianListNotesRequest",
-                toolName: toolName,
-                params: {
-                    // Log all relevant parameters for debugging
-                    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.
-                const response = await processObsidianListNotes(params, handlerContext, obsidianService);
-                logger.debug(`'${toolName}' processed successfully`, handlerContext);
-                // Format the successful response object from the logic function into the required MCP CallToolResult structure.
-                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

@@ -1,3 +0,0 @@
-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

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

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

@@ -1,42 +0,0 @@
-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

@@ -1,152 +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";
-// ====================================================================================
-// 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

@@ -1,3 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

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

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

@@ -1,28 +0,0 @@
-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>;