@cyanheads/git-mcp-server 2.1.8 → 2.2.1

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

@@ -1,25 +1,9 @@
-// Import utils from barrel (ErrorHandler from ../utils/internal/errorHandler.js)
-import { ErrorHandler } from "../../../utils/index.js";
-// Import utils from barrel (logger from ../utils/internal/logger.js)
-import { logger } from "../../../utils/index.js";
-// Import utils from barrel (requestContextService from ../utils/internal/requestContext.js)
-import { requestContextService } from "../../../utils/index.js";
-// Import the result type along with the function and input schema
-import { BaseErrorCode } from "../../../types-global/errors.js"; // Keep direct import for types-global
-import { commitGitChanges, GitCommitInputSchema, } from "./logic.js";
-let _getWorkingDirectory;
-let _getSessionId;
 /**
- * Initializes the state accessors needed by the tool registration.
- * This should be called once during server setup.
- * @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_commit tool.
+ * @module src/mcp-server/tools/gitCommit/registration
  */
-export function initializeGitCommitStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_commit tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { commitGitChanges, GitCommitInputSchema, GitCommitOutputSchema, } from "./logic.js";
 const TOOL_NAME = "git_commit";
 const TOOL_DESCRIPTION = `Commits staged changes to the Git repository index with a descriptive message. Supports author override, amending, and empty commits. Returns a JSON result.
 
@@ -45,63 +29,58 @@ Closes #123 (if applicable).
 - Commit related changes logically. Use the optional \`filesToStage\` parameter to auto-stage specific files before committing.
 - The \`path\` defaults to the session's working directory unless overridden. If \`GIT_SIGN_COMMITS=true\` is set, commits are signed (\`-S\`), with an optional \`forceUnsignedOnFailure\` fallback.`;
 /**
- * Registers the git_commit tool with the MCP server.
- * Uses the high-level server.tool() method for registration, schema validation, and routing.
- *
- * @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_commit 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 registerGitCommitTool = async (server) => {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_commit must be initialized before registration.");
-    }
+export const registerGitCommitTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitCommitTool";
     const context = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(async () => {
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitCommitInputSchema.shape, // Provide the Zod schema shape
-        async (validatedArgs, callContext) => {
-            const toolOperation = "tool:git_commit";
-            const requestContext = requestContextService.createRequestContext({
-                operation: toolOperation,
-                parentContext: callContext,
+    server.registerTool(TOOL_NAME, {
+        title: "Git Commit",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitCommitInputSchema.shape,
+        outputSchema: GitCommitOutputSchema.shape,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false, // Committing is not idempotent
+            openWorldHint: false,
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
+        });
+        try {
+            const sessionId = getSessionId(handlerContext);
+            const result = await commitGitChanges(params, {
+                ...handlerContext,
+                getWorkingDirectory: () => getWorkingDirectory(sessionId),
             });
-            const sessionId = _getSessionId(requestContext);
-            const getWorkingDirectoryForSession = () => {
-                return _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}`, logicContext);
-            return await ErrorHandler.tryCatch(async () => {
-                // Call the core logic function which now returns a GitCommitResult object
-                const commitResult = await commitGitChanges(validatedArgs, logicContext);
-                // Format the result as a JSON string within TextContent
-                const resultContent = {
-                    type: "text",
-                    // Stringify the JSON object for the response content
-                    text: JSON.stringify(commitResult, null, 2), // Pretty-print JSON
-                    contentType: "application/json",
-                };
-                // Log based on the success flag in the result
-                if (commitResult.success) {
-                    logger.info(`Tool ${TOOL_NAME} executed successfully, returning JSON`, logicContext);
-                }
-                else {
-                    logger.info(`Tool ${TOOL_NAME} completed with non-fatal condition (e.g., nothing to commit), returning JSON`, logicContext);
-                }
-                // Even if success is false (e.g., nothing to commit), it's not a tool execution 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 mcpError = ErrorHandler.handleError(error, {
+                operation: `tool:${TOOL_NAME}`,
+                context: handlerContext,
+                input: params,
             });
-        });
-        logger.info(`Tool registered: ${TOOL_NAME}`, context);
-    }, { operation, context, critical: true });
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error: ${mcpError.message}` }],
+                structuredContent: {
+                    code: mcpError.code,
+                    message: mcpError.message,
+                    details: mcpError.details,
+                },
+            };
+        }
+    });
+    logger.info(`Tool '${TOOL_NAME}' registered successfully.`, context);
 };

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

@@ -1,6 +1,5 @@
 /**
  * @fileoverview Barrel file for the gitDiff tool.
+ * @module src/mcp-server/tools/gitDiff/index
  */
-export { registerGitDiffTool, initializeGitDiffStateAccessors, } from "./registration.js";
-// Export types if needed elsewhere, e.g.:
-// export type { GitDiffInput, GitDiffResult } from './logic.js';
+export { registerGitDiffTool } from "./registration.js";

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

@@ -1,279 +1,87 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_diff tool.
+ * @module src/mcp-server/tools/gitDiff/logic
+ */
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { z } from "zod";
-// Import utils from barrel (logger from ../utils/internal/logger.js)
-import { logger } from "../../../utils/index.js";
-// Import utils from barrel (RequestContext from ../utils/internal/requestContext.js)
-import { BaseErrorCode, McpError } from "../../../types-global/errors.js"; // Keep direct import for types-global
-// Import utils from barrel (sanitization from ../utils/security/sanitization.js)
-import { sanitization } from "../../../utils/index.js";
+import { logger, sanitization } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
 const execFileAsync = promisify(execFile);
-// Define the base input schema without refinement
-const GitDiffInputBaseSchema = z.object({
-    path: z
-        .string()
-        .min(1)
-        .optional()
-        .default(".")
-        .describe("Path to the Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
-    commit1: z
-        .string()
-        .optional()
-        .describe("First commit, branch, or ref for comparison. If omitted, compares against the working tree or index (depending on 'staged')."),
-    commit2: z
-        .string()
-        .optional()
-        .describe("Second commit, branch, or ref for comparison. If omitted, compares commit1 against the working tree or index."),
-    staged: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("Show diff of changes staged for the next commit (compares index against HEAD). Overrides commit1/commit2 if true."),
-    file: z
-        .string()
-        .optional()
-        .describe("Limit the diff output to a specific file path."),
-    includeUntracked: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("Include untracked files in the diff output (shows their full content as new files). This is a non-standard extension."),
-    // Add options like --name-only, --stat, context lines (-U<n>) if needed
+// 1. DEFINE the Zod input schema.
+export const GitDiffBaseSchema = z.object({
+    path: z.string().default(".").describe("Path to the Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
+    commit1: z.string().optional().describe("First commit, branch, or ref for comparison."),
+    commit2: z.string().optional().describe("Second commit, branch, or ref for comparison."),
+    staged: z.boolean().default(false).describe("Show diff of changes staged for the next commit."),
+    file: z.string().optional().describe("Limit the diff output to a specific file path."),
+    includeUntracked: z.boolean().default(false).describe("Include untracked files in the diff output."),
+});
+export const GitDiffInputSchema = GitDiffBaseSchema.refine(data => !(data.staged && (data.commit1 || data.commit2)), {
+    message: "Cannot use 'staged' option with specific commit references.",
+    path: ["staged"],
 });
-// Export the shape for registration
-export const GitDiffInputShape = GitDiffInputBaseSchema.shape;
-// Define the final schema with refinement for validation during execution
-export const GitDiffInputSchema = GitDiffInputBaseSchema.refine((data) => !(data.staged && (data.commit1 || data.commit2)), {
-    message: "Cannot use 'staged' option with specific commit references (commit1 or commit2).",
-    path: ["staged", "commit1", "commit2"], // Indicate related fields
+// 2. DEFINE the Zod response schema.
+export const GitDiffOutputSchema = z.object({
+    success: z.boolean().describe("Indicates if the command was successful."),
+    diff: z.string().describe("The diff output. Will be 'No changes found.' if there are no differences."),
+    message: z.string().describe("A summary message of the result."),
 });
+async function getUntrackedFilesDiff(targetPath, context) {
+    const { stdout } = await execFileAsync("git", ["-C", targetPath, "ls-files", "--others", "--exclude-standard"]);
+    const untrackedFiles = stdout.trim().split("\n").filter(Boolean);
+    if (untrackedFiles.length === 0)
+        return "";
+    let diffs = "";
+    for (const file of untrackedFiles) {
+        const { stdout: diffOut } = await execFileAsync("git", ["-C", targetPath, "diff", "--no-index", "/dev/null", file]).catch(err => {
+            if (err.stdout)
+                return { stdout: err.stdout };
+            logger.warning(`Failed to diff untracked file: ${file}`, { ...context, error: err.message });
+            return { stdout: "" };
+        });
+        diffs += diffOut;
+    }
+    return diffs;
+}
 /**
- * Executes the 'git diff' command and returns the diff output.
- *
- * @param {GitDiffInput} input - The validated input object.
- * @param {RequestContext} context - The request context for logging and error handling.
- * @returns {Promise<GitDiffResult>} A promise that resolves with the structured diff result.
- * @throws {McpError} Throws an McpError if path resolution, validation, or the git command fails unexpectedly.
+ * 4. IMPLEMENT the core logic function.
+ * @throws {McpError} If the logic encounters an unrecoverable issue.
  */
-export async function diffGitChanges(input, context) {
+export async function diffGitChanges(params, context) {
     const operation = "diffGitChanges";
-    logger.debug(`Executing ${operation}`, { ...context, input });
-    let targetPath;
-    try {
-        // Resolve and sanitize the target path
-        if (input.path && input.path !== ".") {
-            targetPath = input.path;
-        }
-        else {
-            const workingDir = context.getWorkingDirectory();
-            if (!workingDir) {
-                throw new McpError(BaseErrorCode.VALIDATION_ERROR, "No path provided and no working directory set for the session.", { context, operation });
-            }
-            targetPath = workingDir;
-        }
-        targetPath = sanitization.sanitizePath(targetPath, {
-            allowAbsolute: true,
-        }).sanitizedPath;
-        logger.debug("Sanitized path", {
-            ...context,
-            operation,
-            sanitizedPath: targetPath,
-        });
+    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.");
     }
-    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 });
+    const targetPath = sanitization.sanitizePath(params.path === "." ? workingDir : params.path, { allowAbsolute: true }).sanitizedPath;
+    const args = ["-C", targetPath, "diff"];
+    if (params.staged) {
+        args.push("--staged");
     }
-    // Basic sanitization for refs and file path
-    const safeCommit1 = input.commit1?.replace(/[`$&;*()|<>]/g, "");
-    const safeCommit2 = input.commit2?.replace(/[`$&;*()|<>]/g, "");
-    const safeFile = input.file?.replace(/[`$&;*()|<>]/g, "");
-    let untrackedFilesDiff = "";
-    let untrackedFilesCount = 0;
-    try {
-        // Construct the standard git diff command
-        const standardDiffArgs = ["-C", targetPath, "diff"];
-        if (input.staged) {
-            standardDiffArgs.push("--staged"); // Or --cached
-        }
-        else {
-            // Add commit references if not doing staged diff
-            if (safeCommit1) {
-                standardDiffArgs.push(safeCommit1);
-            }
-            if (safeCommit2) {
-                standardDiffArgs.push(safeCommit2);
-            }
-        }
-        // Add file path limiter if provided for standard diff
-        // Note: `input.file` will not apply to the untracked files part unless we explicitly filter them.
-        // For simplicity, `includeUntracked` will show all untracked files if `input.file` is also set.
-        if (safeFile) {
-            standardDiffArgs.push("--", safeFile); // Use '--' to separate paths from revisions
-        }
-        logger.debug(`Executing standard diff command: git ${standardDiffArgs.join(" ")}`, {
-            ...context,
-            operation,
-        });
-        const { stdout: standardStdout, stderr: standardStderr } = await execFileAsync("git", standardDiffArgs, {
-            maxBuffer: 1024 * 1024 * 20,
-        });
-        if (standardStderr) {
-            logger.warning(`Git diff (standard) stderr: ${standardStderr}`, {
-                ...context,
-                operation,
-            });
-        }
-        let combinedDiffOutput = standardStdout;
-        // Handle untracked files if requested
-        if (input.includeUntracked) {
-            logger.debug("Including untracked files.", { ...context, operation });
-            const listUntrackedArgs = [
-                "-C",
-                targetPath,
-                "ls-files",
-                "--others",
-                "--exclude-standard",
-            ];
-            try {
-                const { stdout: untrackedFilesStdOut } = await execFileAsync("git", listUntrackedArgs);
-                const untrackedFiles = untrackedFilesStdOut
-                    .trim()
-                    .split("\n")
-                    .filter((f) => f); // Filter out empty lines
-                if (untrackedFiles.length > 0) {
-                    logger.info(`Found ${untrackedFiles.length} untracked files.`, {
-                        ...context,
-                        operation,
-                        untrackedFiles,
-                    });
-                    let individualUntrackedDiffs = "";
-                    for (const untrackedFile of untrackedFiles) {
-                        // Sanitize each untracked file path before using in command
-                        const safeUntrackedFile = untrackedFile.replace(/[`$&;*()|<>]/g, "");
-                        // Skip if file path becomes empty after sanitization (unlikely but safe)
-                        if (!safeUntrackedFile)
-                            continue;
-                        const untrackedDiffArgs = [
-                            "-C",
-                            targetPath,
-                            "diff",
-                            "--no-index",
-                            "/dev/null",
-                            safeUntrackedFile,
-                        ];
-                        logger.debug(`Executing diff for untracked file: git ${untrackedDiffArgs.join(" ")}`, { ...context, operation, file: safeUntrackedFile });
-                        try {
-                            const { stdout: untrackedFileDiffOut } = await execFileAsync("git", untrackedDiffArgs);
-                            individualUntrackedDiffs += untrackedFileDiffOut;
-                            untrackedFilesCount++;
-                        }
-                        catch (untrackedError) {
-                            // For `git diff --no-index`, a non-zero exit code (usually 1) means differences were found.
-                            // The actual diff output will be in untrackedError.stdout.
-                            if (untrackedError.stdout) {
-                                individualUntrackedDiffs += untrackedError.stdout;
-                                untrackedFilesCount++;
-                                // Log stderr if it exists, as it might contain actual error messages despite stdout having the diff
-                                if (untrackedError.stderr) {
-                                    logger.warning(`Stderr while diffing untracked file ${safeUntrackedFile} (diff captured from stdout): ${untrackedError.stderr}`, { ...context, operation, file: safeUntrackedFile });
-                                }
-                            }
-                            else {
-                                // If stdout is empty, then it's a more genuine failure.
-                                logger.warning(`Failed to diff untracked file: ${safeUntrackedFile}. Error: ${untrackedError.message}`, {
-                                    ...context,
-                                    operation,
-                                    file: safeUntrackedFile,
-                                    errorDetails: {
-                                        stderr: untrackedError.stderr,
-                                        stdout: untrackedError.stdout,
-                                        code: untrackedError.code,
-                                    },
-                                });
-                                individualUntrackedDiffs += `\n--- Diff for untracked file ${safeUntrackedFile} failed: ${untrackedError.message}\n`;
-                            }
-                        }
-                    }
-                    if (individualUntrackedDiffs) {
-                        // Add a separator if standard diff also had output
-                        if (combinedDiffOutput.trim()) {
-                            combinedDiffOutput += "\n";
-                        }
-                        combinedDiffOutput += individualUntrackedDiffs;
-                    }
-                }
-                else {
-                    logger.info("No untracked files found.", { ...context, operation });
-                }
-            }
-            catch (lsFilesError) {
-                logger.warning(`Failed to list untracked files. Error: ${lsFilesError.message}`, {
-                    ...context,
-                    operation,
-                    error: lsFilesError.stderr || lsFilesError.stdout,
-                });
-                // Proceed without untracked files if listing fails
-            }
-        }
-        const isNoChanges = combinedDiffOutput.trim() === "";
-        const finalDiffOutput = isNoChanges
-            ? "No changes found."
-            : combinedDiffOutput;
-        let message = isNoChanges
-            ? "No changes found."
-            : "Diff generated successfully.";
-        if (untrackedFilesCount > 0) {
-            message += ` Included ${untrackedFilesCount} untracked file(s).`;
-        }
-        logger.info(message, {
-            ...context,
-            operation,
-            path: targetPath,
-            untrackedFilesProcessed: untrackedFilesCount,
-        });
-        return {
-            success: true,
-            diff: finalDiffOutput,
-            message,
-            untrackedFilesProcessed: untrackedFilesCount,
-        };
+    else {
+        if (params.commit1)
+            args.push(params.commit1);
+        if (params.commit2)
+            args.push(params.commit2);
     }
-    catch (error) {
-        // This catch block now primarily handles errors from the *standard* diff command
-        // or catastrophic failures before/after untracked file processing.
-        logger.error(`Failed to execute git diff operation`, {
-            ...context,
-            operation,
-            path: targetPath,
-            error: error.message,
-            stderr: error.stderr,
-            stdout: error.stdout,
-        });
-        const errorMessage = error.stderr || error.stdout || error.message || "";
-        // Handle specific error cases
-        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 });
-        }
-        if (errorMessage.includes("fatal: bad object") ||
-            errorMessage.includes("unknown revision or path not in the working tree")) {
-            const invalidRef = input.commit1 || input.commit2 || input.file;
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Invalid commit reference or file path specified: '${invalidRef}'. Error: ${errorMessage}`, { context, operation, originalError: error });
-        }
-        if (errorMessage.includes("ambiguous argument")) {
-            const ambiguousArg = input.commit1 || input.commit2 || input.file;
-            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Ambiguous argument provided: '${ambiguousArg}'. Error: ${errorMessage}`, { context, operation, originalError: error });
+    if (params.file)
+        args.push("--", params.file);
+    logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+    const { stdout } = await execFileAsync("git", args, { maxBuffer: 1024 * 1024 * 20 });
+    let combinedDiff = stdout;
+    if (params.includeUntracked) {
+        const untrackedDiff = await getUntrackedFilesDiff(targetPath, context);
+        if (untrackedDiff) {
+            combinedDiff += (combinedDiff ? "\n" : "") + untrackedDiff;
         }
-        // If the command exits with an error but stdout has content, it might still be useful (e.g., diff with conflicts)
-        // However, standard 'git diff' usually exits 0 even with differences. Errors typically mean invalid input/repo state.
-        // We'll treat most exec errors as failures.
-        // Generic internal error for other failures
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to get git diff for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
     }
+    const noChanges = combinedDiff.trim() === "";
+    const message = noChanges ? "No changes found." : `Diff generated successfully.${params.includeUntracked ? " Untracked files included." : ""}`;
+    return {
+        success: true,
+        diff: noChanges ? "No changes found." : combinedDiff,
+        message,
+    };
 }

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

@@ -1,79 +1,64 @@
-// Import utils from barrel (ErrorHandler from ../utils/internal/errorHandler.js)
-import { ErrorHandler } from "../../../utils/index.js";
-// Import utils from barrel (logger from ../utils/internal/logger.js)
-import { logger } from "../../../utils/index.js";
-// Import utils from barrel (requestContextService, RequestContext from ../utils/internal/requestContext.js)
-import { requestContextService } from "../../../utils/index.js";
-// Import the shape and the final schema/types
-import { BaseErrorCode } from "../../../types-global/errors.js"; // Keep direct import for types-global
-import { diffGitChanges, GitDiffInputShape, } from "./logic.js";
-let _getWorkingDirectory;
-let _getSessionId;
 /**
- * Initializes the state accessors needed by the tool registration.
- * This should be called once during server setup.
- * @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_diff tool.
+ * @module src/mcp-server/tools/gitDiff/registration
  */
-export function initializeGitDiffStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_diff tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { diffGitChanges, GitDiffOutputSchema, GitDiffBaseSchema, } from "./logic.js";
 const TOOL_NAME = "git_diff";
 const TOOL_DESCRIPTION = "Shows changes between commits, commit and working tree, etc. Can show staged changes or diff specific files. An optional 'includeUntracked' parameter (boolean) can be used to also show the content of untracked files. Returns the diff output as plain text.";
 /**
- * Registers the git_diff tool with the MCP server.
- *
- * @param {McpServer} server - The MCP server instance.
- * @throws {Error} If state accessors are not initialized.
+ * Registers the git_diff 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 async function registerGitDiffTool(server) {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_diff must be initialized before registration.");
-    }
+export const registerGitDiffTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitDiffTool";
     const context = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(async () => {
-        // Use the exported shape for registration
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitDiffInputShape, // Provide the Zod base schema shape
-        async (validatedArgs, callContext) => {
-            const toolOperation = "tool:git_diff";
-            const requestContext = requestContextService.createRequestContext({
-                operation: toolOperation,
-                parentContext: callContext,
+    server.registerTool(TOOL_NAME, {
+        title: "Git Diff",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitDiffBaseSchema.shape,
+        outputSchema: GitDiffOutputSchema.shape,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
+        });
+        try {
+            const sessionId = getSessionId(handlerContext);
+            const result = await diffGitChanges(params, {
+                ...handlerContext,
+                getWorkingDirectory: () => getWorkingDirectory(sessionId),
             });
-            const sessionId = _getSessionId(requestContext);
-            const getWorkingDirectoryForSession = () => {
-                return _getWorkingDirectory(sessionId);
-            };
-            const logicContext = {
-                ...requestContext,
-                sessionId: sessionId,
-                getWorkingDirectory: getWorkingDirectoryForSession,
+            return {
+                structuredContent: result,
+                content: [{ type: "text", text: result.diff, contentType: "text/plain; charset=utf-8" }],
             };
-            logger.info(`Executing tool: ${TOOL_NAME}`, logicContext);
-            return await ErrorHandler.tryCatch(async () => {
-                // Call the core logic function
-                const diffResult = await diffGitChanges(validatedArgs, logicContext);
-                // Format the result (the diff string) as plain text within TextContent
-                const resultContent = {
-                    type: "text",
-                    // Return the raw diff output directly
-                    text: diffResult.diff,
-                    // Indicate the content type is plain text diff
-                    contentType: "text/plain; charset=utf-8", // Or 'text/x-diff'
-                };
-                logger.info(`Tool ${TOOL_NAME} executed successfully: ${diffResult.message}`, logicContext);
-                // Success is determined by the logic function
-                return { content: [resultContent] };
-            }, {
-                operation: toolOperation,
-                context: logicContext,
-                input: validatedArgs,
-                errorCode: BaseErrorCode.INTERNAL_ERROR, // Default if unexpected error in logic
+        }
+        catch (error) {
+            logger.error(`Error in ${TOOL_NAME} handler`, { error, ...handlerContext });
+            const mcpError = ErrorHandler.handleError(error, {
+                operation: `tool:${TOOL_NAME}`,
+                context: handlerContext,
+                input: params,
             });
-        });
-        logger.info(`Tool registered: ${TOOL_NAME}`, context);
-    }, { operation, context, critical: true });
-}
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error: ${mcpError.message}` }],
+                structuredContent: {
+                    code: mcpError.code,
+                    message: mcpError.message,
+                    details: mcpError.details,
+                },
+            };
+        }
+    });
+    logger.info(`Tool '${TOOL_NAME}' registered successfully.`, context);
+};