@cyanheads/git-mcp-server 2.1.8 → 2.2.0

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

@@ -1,72 +1,31 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_worktree tool.
+ * @module src/mcp-server/tools/gitWorktree/logic
+ */
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { z } from "zod";
 import { logger, sanitization } from "../../../utils/index.js";
-import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
 const execFileAsync = promisify(execFile);
-// Define the BASE input schema for the git_worktree tool using Zod
+// 1. DEFINE the Zod input schema.
 export const GitWorktreeBaseSchema = z.object({
-    path: z
-        .string()
-        .min(1)
-        .optional()
-        .default(".")
-        .describe("Path to the local Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
-    mode: z
-        .enum(["list", "add", "remove", "move", "prune"])
-        .describe("The worktree operation to perform: 'list', 'add', 'remove', 'move', 'prune'."),
-    // Common optional path for operations
-    worktreePath: z
-        .string()
-        .min(1)
-        .optional()
-        .describe("Path of the worktree. Required for 'add', 'remove', 'move' modes."),
-    // 'add' mode specific
-    commitish: z
-        .string()
-        .min(1)
-        .optional()
-        .describe("Branch or commit to checkout in the new worktree. Used only in 'add' mode. Defaults to HEAD."),
-    newBranch: z
-        .string()
-        .min(1)
-        .optional()
-        .describe("Create a new branch in the worktree. Used only in 'add' mode."),
-    force: z
-        .boolean()
-        .default(false)
-        .describe("Force the operation (e.g., for 'add' if branch exists, or 'remove' if uncommitted changes)."),
-    detach: z
-        .boolean()
-        .default(false)
-        .describe("Detach HEAD in the new worktree. Used only in 'add' mode."),
-    // 'move' mode specific
-    newPath: z
-        .string()
-        .min(1)
-        .optional()
-        .describe("The new path for the worktree. Required for 'move' mode."),
-    // 'prune' mode specific
-    verbose: z
-        .boolean()
-        .default(false)
-        .describe("Provide more detailed output. Used in 'list' and 'prune' modes."),
-    dryRun: z
-        .boolean()
-        .default(false)
-        .describe("Show what would be done without actually doing it. Used in 'prune' mode."),
-    expire: z
-        .string()
-        .min(1)
-        .optional()
-        .describe("Prune entries older than this time (e.g., '1.month.ago'). Used in 'prune' mode."),
+    path: z.string().default(".").describe("Path to the local Git repository."),
+    mode: z.enum(["list", "add", "remove", "move", "prune"]).describe("The worktree operation to perform."),
+    worktreePath: z.string().min(1).optional().describe("Path of the worktree."),
+    commitish: z.string().min(1).optional().describe("Branch or commit to checkout in the new worktree."),
+    newBranch: z.string().min(1).optional().describe("Create a new branch in the worktree."),
+    force: z.boolean().default(false).describe("Force the operation."),
+    detach: z.boolean().default(false).describe("Detach HEAD in the new worktree."),
+    newPath: z.string().min(1).optional().describe("The new path for the worktree."),
+    verbose: z.boolean().default(false).describe("Provide more detailed output."),
+    dryRun: z.boolean().default(false).describe("Show what would be done without actually doing it."),
+    expire: z.string().min(1).optional().describe("Prune entries older than this time (e.g., '1.month.ago')."),
 });
-// Apply refinements and export the FINAL schema
 export const GitWorktreeInputSchema = GitWorktreeBaseSchema.refine((data) => !(data.mode === "add" && !data.worktreePath), {
     message: "A 'worktreePath' is required for 'add' mode.",
     path: ["worktreePath"],
-})
-    .refine((data) => !(data.mode === "remove" && !data.worktreePath), {
+}).refine((data) => !(data.mode === "remove" && !data.worktreePath), {
     message: "A 'worktreePath' is required for 'remove' mode.",
     path: ["worktreePath"],
 })
@@ -74,291 +33,122 @@ export const GitWorktreeInputSchema = GitWorktreeBaseSchema.refine((data) => !(d
     message: "Both 'worktreePath' (old path) and 'newPath' are required for 'move' mode.",
     path: ["worktreePath", "newPath"],
 });
-/**
- * Parses the output of `git worktree list --porcelain`.
- */
+// 2. DEFINE the Zod response schema.
+const WorktreeInfoSchema = z.object({
+    path: z.string(),
+    head: z.string(),
+    branch: z.string().optional(),
+    isBare: z.boolean(),
+    isLocked: z.boolean(),
+    isPrunable: z.boolean(),
+    prunableReason: z.string().optional(),
+});
+export const GitWorktreeOutputSchema = z.object({
+    success: z.boolean().describe("Indicates if the command was successful."),
+    mode: z.string().describe("The mode of operation that was performed."),
+    message: z.string().optional().describe("A summary message of the result."),
+    worktrees: z.array(WorktreeInfoSchema).optional().describe("A list of worktrees for the 'list' mode."),
+});
 function parsePorcelainWorktreeList(stdout) {
-    const worktrees = [];
-    const entries = stdout.trim().split("\n\n"); // Entries are separated by double newlines
-    for (const entry of entries) {
+    return stdout.trim().split("\n\n").map(entry => {
         const lines = entry.trim().split("\n");
-        let path = "";
-        let head = "";
-        let branch;
-        let isBare = false;
-        let isLocked = false;
-        let isPrunable = false;
-        let prunableReason;
-        for (const line of lines) {
-            if (line.startsWith("worktree ")) {
-                path = line.substring("worktree ".length);
-            }
-            else if (line.startsWith("HEAD ")) {
-                head = line.substring("HEAD ".length);
-            }
-            else if (line.startsWith("branch ")) {
-                branch = line.substring("branch ".length);
-            }
-            else if (line.startsWith("bare")) {
-                isBare = true;
-            }
-            else if (line.startsWith("locked")) {
-                isLocked = true;
-                const reasonMatch = line.match(/locked(?: (.+))?/);
-                if (reasonMatch && reasonMatch[1]) {
-                    prunableReason = reasonMatch[1]; // Using prunableReason for lock reason too
-                }
-            }
-            else if (line.startsWith("prunable")) {
-                isPrunable = true;
-                const reasonMatch = line.match(/prunable(?: (.+))?/);
-                if (reasonMatch && reasonMatch[1]) {
-                    prunableReason = reasonMatch[1];
-                }
-            }
-        }
-        if (path) {
-            // Only add if a path was found
-            worktrees.push({
-                path,
-                head,
-                branch,
-                isBare,
-                isLocked,
-                isPrunable,
-                prunableReason,
-            });
-        }
-    }
-    return worktrees;
+        const info = {
+            isBare: false,
+            isLocked: false,
+            isPrunable: false,
+        };
+        lines.forEach(line => {
+            if (line.startsWith("worktree "))
+                info.path = line.substring(9);
+            else if (line.startsWith("HEAD "))
+                info.head = line.substring(5);
+            else if (line.startsWith("branch "))
+                info.branch = line.substring(7);
+            else if (line.startsWith("bare"))
+                info.isBare = true;
+            else if (line.startsWith("locked"))
+                info.isLocked = true;
+            else if (line.startsWith("prunable"))
+                info.isPrunable = true;
+        });
+        return info;
+    }).filter(wt => wt.path);
 }
 /**
- * Executes git worktree commands.
+ * 4. IMPLEMENT the core logic function.
+ * @throws {McpError} If the logic encounters an unrecoverable issue.
  */
-export async function gitWorktreeLogic(input, context) {
-    const operation = `gitWorktreeLogic:${input.mode}`;
-    logger.debug(`Executing ${operation}`, { ...context, input });
-    let targetPath;
-    try {
-        const workingDir = context.getWorkingDirectory();
-        targetPath =
-            input.path && input.path !== "." ? input.path : (workingDir ?? ".");
-        if (targetPath === "." && !workingDir) {
-            logger.warning("Executing git worktree in server's CWD as no path provided and no session WD set.", { ...context, operation });
-            targetPath = process.cwd();
-        }
-        else if (targetPath === "." && workingDir) {
-            targetPath = workingDir;
-            logger.debug(`Using session working directory: ${targetPath}`, {
-                ...context,
-                operation,
-                sessionId: context.sessionId,
-            });
-        }
-        else {
-            logger.debug(`Using provided path: ${targetPath}`, {
-                ...context,
-                operation,
-            });
-        }
-        targetPath = sanitization.sanitizePath(targetPath, {
-            allowAbsolute: true,
-        }).sanitizedPath;
-    }
-    catch (error) {
-        logger.error("Path resolution or sanitization failed", {
-            ...context,
-            operation,
-            error,
-        });
-        if (error instanceof McpError)
-            throw error;
-        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path: ${error instanceof Error ? error.message : String(error)}`, { context, operation, originalError: error });
+export async function gitWorktreeLogic(params, context) {
+    const operation = `gitWorktreeLogic:${params.mode}`;
+    logger.debug(`Executing ${operation}`, { ...context, params });
+    const workingDir = context.getWorkingDirectory();
+    if (params.path === "." && !workingDir) {
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, "No session working directory set. Please specify a 'path' or use 'git_set_working_dir' first.");
     }
-    try {
-        let args;
-        let result;
-        switch (input.mode) {
+    const targetPath = sanitization.sanitizePath(params.path === "." ? workingDir : params.path, { allowAbsolute: true }).sanitizedPath;
+    const buildArgs = () => {
+        const baseArgs = ["-C", targetPath, "worktree", params.mode];
+        switch (params.mode) {
             case "list":
-                args = ["-C", targetPath, "worktree", "list"];
-                if (input.verbose) {
-                    args.push("--porcelain");
-                } // Use porcelain for structured output
-                logger.debug(`Executing command: git ${args.join(" ")}`, {
-                    ...context,
-                    operation,
-                });
-                const { stdout: listStdout } = await execFileAsync("git", args);
-                if (input.verbose) {
-                    const worktrees = parsePorcelainWorktreeList(listStdout);
-                    result = { success: true, mode: "list", worktrees };
-                }
-                else {
-                    // Simple list output parsing (less structured)
-                    const worktrees = listStdout
-                        .trim()
-                        .split("\n")
-                        .map((line) => {
-                        const parts = line.split(/\s+/);
-                        return {
-                            path: parts[0],
-                            head: parts[1],
-                            branch: parts[2]?.replace(/[\[\]]/g, ""), // Remove brackets from branch name
-                            isBare: false, // Cannot determine from simple list
-                            isLocked: false, // Cannot determine
-                            isPrunable: false, // Cannot determine
-                        };
-                    });
-                    result = { success: true, mode: "list", worktrees };
-                }
+                if (params.verbose)
+                    baseArgs.push("--verbose");
                 break;
             case "add":
-                // worktreePath is guaranteed by refine
-                const sanitizedWorktreePathAdd = sanitization.sanitizePath(input.worktreePath, { allowAbsolute: true, rootDir: targetPath }).sanitizedPath;
-                args = ["-C", targetPath, "worktree", "add"];
-                if (input.force) {
-                    args.push("--force");
-                }
-                if (input.detach) {
-                    args.push("--detach");
-                }
-                if (input.newBranch) {
-                    args.push("-b", input.newBranch);
-                }
-                args.push(sanitizedWorktreePathAdd);
-                if (input.commitish) {
-                    args.push(input.commitish);
-                }
-                logger.debug(`Executing command: git ${args.join(" ")}`, {
-                    ...context,
-                    operation,
-                });
-                await execFileAsync("git", args);
-                // To get the HEAD of the new worktree, we might need another command or parse output if available
-                // For simplicity, we'll report success. A more robust solution might `git -C new_worktree_path rev-parse HEAD`
-                result = {
-                    success: true,
-                    mode: "add",
-                    worktreePath: sanitizedWorktreePathAdd,
-                    branch: input.newBranch,
-                    head: "HEAD", // Placeholder, actual SHA would require another call
-                    message: `Worktree '${sanitizedWorktreePathAdd}' added successfully.`,
-                };
+                if (params.force)
+                    baseArgs.push("--force");
+                if (params.detach)
+                    baseArgs.push("--detach");
+                if (params.newBranch)
+                    baseArgs.push("-b", params.newBranch);
+                if (params.worktreePath)
+                    baseArgs.push(params.worktreePath);
+                if (params.commitish)
+                    baseArgs.push(params.commitish);
                 break;
             case "remove":
-                // worktreePath is guaranteed by refine
-                const sanitizedWorktreePathRemove = sanitization.sanitizePath(input.worktreePath, { allowAbsolute: true, rootDir: targetPath }).sanitizedPath;
-                args = ["-C", targetPath, "worktree", "remove"];
-                if (input.force) {
-                    args.push("--force");
-                }
-                args.push(sanitizedWorktreePathRemove);
-                logger.debug(`Executing command: git ${args.join(" ")}`, {
-                    ...context,
-                    operation,
-                });
-                const { stdout: removeStdout } = await execFileAsync("git", args);
-                result = {
-                    success: true,
-                    mode: "remove",
-                    worktreePath: sanitizedWorktreePathRemove,
-                    message: removeStdout.trim() ||
-                        `Worktree '${sanitizedWorktreePathRemove}' removed successfully.`,
-                };
+                if (params.force)
+                    baseArgs.push("--force");
+                if (params.worktreePath)
+                    baseArgs.push(params.worktreePath);
                 break;
             case "move":
-                // worktreePath and newPath are guaranteed by refine
-                const sanitizedOldPathMove = sanitization.sanitizePath(input.worktreePath, { allowAbsolute: true, rootDir: targetPath }).sanitizedPath;
-                const sanitizedNewPathMove = sanitization.sanitizePath(input.newPath, {
-                    allowAbsolute: true,
-                    rootDir: targetPath,
-                }).sanitizedPath;
-                args = [
-                    "-C",
-                    targetPath,
-                    "worktree",
-                    "move",
-                    sanitizedOldPathMove,
-                    sanitizedNewPathMove,
-                ];
-                logger.debug(`Executing command: git ${args.join(" ")}`, {
-                    ...context,
-                    operation,
-                });
-                await execFileAsync("git", args);
-                result = {
-                    success: true,
-                    mode: "move",
-                    oldPath: sanitizedOldPathMove,
-                    newPath: sanitizedNewPathMove,
-                    message: `Worktree moved from '${sanitizedOldPathMove}' to '${sanitizedNewPathMove}' successfully.`,
-                };
+                if (params.worktreePath)
+                    baseArgs.push(params.worktreePath);
+                if (params.newPath)
+                    baseArgs.push(params.newPath);
                 break;
             case "prune":
-                args = ["-C", targetPath, "worktree", "prune"];
-                if (input.dryRun) {
-                    args.push("--dry-run");
-                }
-                if (input.verbose) {
-                    args.push("--verbose");
-                }
-                if (input.expire) {
-                    args.push(`--expire=${input.expire}`);
-                }
-                logger.debug(`Executing command: git ${args.join(" ")}`, {
-                    ...context,
-                    operation,
-                });
-                const { stdout: pruneStdout, stderr: pruneStderr } = await execFileAsync("git", args);
-                // Prune often outputs to stderr even on success for verbose/dry-run
-                const pruneMessage = pruneStdout.trim() ||
-                    pruneStderr.trim() ||
-                    "Worktree prune operation completed.";
-                result = { success: true, mode: "prune", message: pruneMessage };
-                if (input.verbose && pruneStdout.trim()) {
-                    // Attempt to parse verbose output if needed, for now just return raw message
-                    // result.prunedItems = ...
-                }
+                if (params.verbose)
+                    baseArgs.push("--verbose");
+                if (params.dryRun)
+                    baseArgs.push("--dry-run");
+                if (params.expire)
+                    baseArgs.push(`--expire=${params.expire}`);
                 break;
-            default:
-                throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid mode: ${input.mode}`, { context, operation });
         }
-        logger.info(`git worktree ${input.mode} executed successfully`, {
-            ...context,
-            operation,
-            path: targetPath,
-            result,
-        });
-        return result;
+        return baseArgs;
+    };
+    const args = buildArgs();
+    try {
+        logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+        const { stdout } = await execFileAsync("git", args);
+        if (params.mode === 'list' && params.verbose) {
+            return { success: true, mode: params.mode, worktrees: parsePorcelainWorktreeList(stdout) };
+        }
+        return { success: true, mode: params.mode, message: stdout.trim() || `Worktree ${params.mode} operation successful.` };
     }
     catch (error) {
-        const errorMessage = error.stderr || error.stdout || error.message || "";
-        logger.error(`Failed to execute git worktree command`, {
-            ...context,
-            path: targetPath,
-            error: errorMessage,
-            stderr: error.stderr,
-            stdout: error.stdout,
-        });
+        const errorMessage = error.stderr || error.message || "";
+        logger.error(`Failed to execute git worktree command`, { ...context, operation, errorMessage });
         if (errorMessage.toLowerCase().includes("not a git repository")) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`, { context, operation, originalError: error });
-        }
-        // Add more specific error handling based on `git worktree` messages
-        if (input.mode === "add" && errorMessage.includes("already exists")) {
-            throw new McpError(BaseErrorCode.CONFLICT, `Failed to add worktree: Path '${input.worktreePath}' already exists or is a worktree. Error: ${errorMessage}`, { context, operation, originalError: error });
-        }
-        if (input.mode === "add" && errorMessage.includes("is a submodule")) {
-            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Failed to add worktree: Path '${input.worktreePath}' is a submodule. Error: ${errorMessage}`, { context, operation, originalError: error });
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`);
         }
-        if (input.mode === "remove" &&
-            errorMessage.includes("cannot remove the current worktree")) {
-            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Failed to remove worktree: Cannot remove the current worktree. Error: ${errorMessage}`, { context, operation, originalError: error });
+        if (params.mode === "add" && errorMessage.includes("already exists")) {
+            throw new McpError(BaseErrorCode.CONFLICT, `Path '${params.worktreePath}' already exists or is a worktree.`);
         }
-        if (input.mode === "remove" &&
-            errorMessage.includes("has unclean changes")) {
-            throw new McpError(BaseErrorCode.CONFLICT, `Failed to remove worktree: '${input.worktreePath}' has uncommitted changes. Use force=true to remove. Error: ${errorMessage}`, { context, operation, originalError: error });
+        if (params.mode === "remove" && errorMessage.includes("has unclean changes")) {
+            throw new McpError(BaseErrorCode.CONFLICT, `Worktree '${params.worktreePath}' has uncommitted changes. Use force=true to remove.`);
         }
-        // Throw a generic McpError for other failures
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git worktree ${input.mode} failed for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git worktree ${params.mode} failed: ${errorMessage}`);
     }
 }

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

@@ -1,70 +1,66 @@
-import { logger, ErrorHandler, requestContextService, } from "../../../utils/index.js";
-import { BaseErrorCode } from "../../../types-global/errors.js";
-import { GitWorktreeBaseSchema, gitWorktreeLogic, } from "./logic.js";
-let _getWorkingDirectory;
-let _getSessionId;
 /**
- * Initializes the state accessors needed by the git_worktree tool registration.
- * @param getWdFn - Function to get the working directory for a session.
- * @param getSidFn - Function to get the session ID from context.
+ * @fileoverview Handles registration and error handling for the git_worktree tool.
+ * @module src/mcp-server/tools/gitWorktree/registration
  */
-export function initializeGitWorktreeStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_worktree tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
+import { gitWorktreeLogic, GitWorktreeInputSchema, GitWorktreeOutputSchema, GitWorktreeBaseSchema, } from "./logic.js";
 const TOOL_NAME = "git_worktree";
 const TOOL_DESCRIPTION = "Manages Git worktrees. Supports listing, adding, removing, moving, and pruning worktrees. Returns results as a JSON object.";
 /**
- * Registers the git_worktree tool with the MCP server.
- *
- * @param {McpServer} server - The McpServer instance to register the tool with.
- * @returns {Promise<void>}
- * @throws {Error} If registration fails or state accessors are not initialized.
+ * Registers the git_worktree tool with the MCP server instance.
+ * @param server The MCP server instance.
+ * @param getWorkingDirectory Function to get the session's working directory.
+ * @param getSessionId Function to get the session ID from context.
  */
-export const registerGitWorktreeTool = async (server) => {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_worktree must be initialized before registration.");
-    }
+export const registerGitWorktreeTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitWorktreeTool";
     const context = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(async () => {
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitWorktreeBaseSchema.shape, async (validatedArgs, callContext) => {
-            const toolInput = validatedArgs; // Cast for use
-            const toolOperation = `tool:${TOOL_NAME}:${toolInput.mode}`;
-            const requestContext = requestContextService.createRequestContext({
-                operation: toolOperation,
-                parentContext: callContext,
+    server.registerTool(TOOL_NAME, {
+        title: "Git Worktree",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitWorktreeBaseSchema.shape,
+        outputSchema: GitWorktreeOutputSchema.shape,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true, // Can add/remove/move worktrees
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
+        });
+        try {
+            // Explicitly parse with the refined schema to enforce validation rules
+            const validatedParams = GitWorktreeInputSchema.parse(params);
+            const sessionId = getSessionId(handlerContext);
+            const result = await gitWorktreeLogic(validatedParams, {
+                ...handlerContext,
+                getWorkingDirectory: () => getWorkingDirectory(sessionId),
             });
-            const sessionId = _getSessionId(requestContext);
-            const getWorkingDirectoryForSession = () => _getWorkingDirectory(sessionId);
-            const logicContext = {
-                ...requestContext,
-                sessionId: sessionId,
-                getWorkingDirectory: getWorkingDirectoryForSession,
+            return {
+                structuredContent: result,
+                content: [{ type: "text", text: `Success: ${JSON.stringify(result, null, 2)}` }],
             };
-            logger.info(`Executing tool: ${TOOL_NAME} (mode: ${toolInput.mode})`, logicContext);
-            return await ErrorHandler.tryCatch(async () => {
-                const worktreeResult = await gitWorktreeLogic(toolInput, logicContext);
-                const resultContent = {
-                    type: "text",
-                    text: JSON.stringify(worktreeResult, null, 2), // Pretty-print JSON
-                    contentType: "application/json",
-                };
-                if (worktreeResult.success) {
-                    logger.info(`Tool ${TOOL_NAME} (mode: ${toolInput.mode}) executed successfully, returning JSON`, logicContext);
-                }
-                else {
-                    logger.warning(`Tool ${TOOL_NAME} (mode: ${toolInput.mode}) failed: ${worktreeResult.message}`, { ...logicContext, errorDetails: worktreeResult.error });
-                }
-                return { content: [resultContent] };
-            }, {
-                operation: toolOperation,
-                context: logicContext,
-                input: validatedArgs,
-                errorCode: BaseErrorCode.INTERNAL_ERROR,
+        }
+        catch (error) {
+            logger.error(`Error in ${TOOL_NAME} handler`, { error, ...handlerContext });
+            const handledError = ErrorHandler.handleError(error, {
+                operation: `tool:${TOOL_NAME}`,
+                context: handlerContext,
+                input: params,
             });
-        });
-        logger.info(`Tool registered: ${TOOL_NAME}`, context);
-    }, { operation, context, critical: true });
+            const mcpError = handledError instanceof McpError
+                ? handledError
+                : new McpError(BaseErrorCode.INTERNAL_ERROR, "An unexpected error occurred.", { originalError: handledError });
+            return {
+                isError: true,
+                content: [{ type: "text", text: mcpError.message }],
+                structuredContent: mcpError.details,
+            };
+        }
+    });
+    logger.info(`Tool '${TOOL_NAME}' registered successfully.`, context);
 };

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

@@ -1,3 +1,5 @@
-export { registerGitWrapupInstructionsTool, initializeGitWrapupInstructionsStateAccessors, } from "./registration.js";
-// This tool now requires session-specific state accessors (getWorkingDirectory, getSessionId)
-// to fetch git status, so initializeGitWrapupInstructionsStateAccessors is exported for server setup.
+/**
+ * @fileoverview Barrel file for the gitWrapupInstructions tool.
+ * @module src/mcp-server/tools/gitWrapupInstructions/index
+ */
+export { registerGitWrapupInstructionsTool } from "./registration.js";