@cyanheads/git-mcp-server 2.1.8 → 2.2.0

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

@@ -1,89 +1,64 @@
-import { BaseErrorCode } from "../../../types-global/errors.js"; // Direct import for types-global
-import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js"; // logger (./utils/internal/logger.js), ErrorHandler (./utils/internal/errorHandler.js), requestContextService (./utils/internal/requestContext.js)
-// Import the final schema and types for handler logic
-// Import the BASE schema separately for registration shape
-import { GitStashBaseSchema, gitStashLogic, } from "./logic.js";
-let _getWorkingDirectory;
-let _getSessionId;
 /**
- * Initializes the state accessors needed by the git_stash 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_stash tool.
+ * @module src/mcp-server/tools/gitStash/registration
  */
-export function initializeGitStashStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_stash tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
+import { gitStashLogic, GitStashOutputSchema, GitStashBaseSchema, } from "./logic.js";
 const TOOL_NAME = "git_stash";
 const TOOL_DESCRIPTION = "Manages stashed changes in the working directory. Supports listing stashes, applying/popping specific stashes (with conflict detection), dropping stashes, and saving current changes to a new stash with an optional message. Returns results as a JSON object.";
 /**
- * Registers the git_stash 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_stash 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 registerGitStashTool = async (server) => {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_stash must be initialized before registration.");
-    }
+export const registerGitStashTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitStashTool";
     const context = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(async () => {
-        // Register the tool using the *base* schema's shape for definition
-        server.tool(// Use BASE schema shape here
-        TOOL_NAME, TOOL_DESCRIPTION, GitStashBaseSchema.shape, // Use the shape from the BASE schema
-        // Let TypeScript infer handler argument types.
-        // The SDK validates against the full GitStashInputSchema before calling this.
-        async (validatedArgs, callContext) => {
-            // Cast validatedArgs to the specific input type for use within the handler
-            const toolInput = validatedArgs;
-            const toolOperation = `tool:${TOOL_NAME}:${toolInput.mode}`; // Include mode in operation
-            const requestContext = requestContextService.createRequestContext({
-                operation: toolOperation,
-                parentContext: callContext,
+    server.registerTool(TOOL_NAME, {
+        title: "Git Stash",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitStashBaseSchema.shape,
+        outputSchema: GitStashOutputSchema.shape,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true, // Can drop stashes or cause conflicts
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
+        });
+        try {
+            const sessionId = getSessionId(handlerContext);
+            const result = await gitStashLogic(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} (mode: ${toolInput.mode})`, logicContext);
-            return await ErrorHandler.tryCatch(async () => {
-                // Call the core logic function which returns a GitStashResult object
-                const stashResult = await gitStashLogic(toolInput, logicContext);
-                // Format the result as a JSON string within TextContent
-                const resultContent = {
-                    type: "text",
-                    text: JSON.stringify(stashResult, null, 2), // Pretty-print JSON
-                    contentType: "application/json",
-                };
-                // Log based on the success flag in the result
-                if (stashResult.success) {
-                    logger.info(`Tool ${TOOL_NAME} (mode: ${toolInput.mode}) executed successfully, returning JSON`, logicContext);
-                }
-                else {
-                    // Log specific failure message from the result
-                    logger.warning(`Tool ${TOOL_NAME} (mode: ${toolInput.mode}) failed: ${stashResult.message}`, {
-                        ...logicContext,
-                        errorDetails: stashResult.error,
-                        conflicts: stashResult.conflicts,
-                    });
-                }
-                // Return the result, whether success or structured failure
-                return { content: [resultContent] };
-            }, {
-                operation: toolOperation,
-                context: logicContext,
-                input: validatedArgs, // Log the raw validated args
-                errorCode: BaseErrorCode.INTERNAL_ERROR, // Default if unexpected error occurs in logic/wrapper
+        }
+        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 }); // Mark registration as critical
+            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/gitStatus/index.js

@@ -1,7 +1,5 @@
 /**
  * @fileoverview Barrel file for the gitStatus tool.
- * Exports the registration function and state accessor initialization function.
+ * @module src/mcp-server/tools/gitStatus/index
  */
-export { registerGitStatusTool, initializeGitStatusStateAccessors, } from "./registration.js";
-// Export types if needed elsewhere, e.g.:
-// export type { GitStatusInput, GitStatusResult } from './logic.js';
+export { registerGitStatusTool } from "./registration.js";

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

@@ -1,267 +1,120 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_status tool.
+ * @module src/mcp-server/tools/gitStatus/logic
+ */
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { z } from "zod";
-import { BaseErrorCode, McpError } from "../../../types-global/errors.js"; // Direct import for types-global
-import { logger, sanitization } from "../../../utils/index.js"; // logger (./utils/internal/logger.js), RequestContext (./utils/internal/requestContext.js), sanitization (./utils/security/sanitization.js)
+import { logger, sanitization } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
 const execFileAsync = promisify(execFile);
-// Define the input schema for the git_status tool using Zod
+// 1. DEFINE the Zod input schema.
 export const GitStatusInputSchema = 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."),
+    path: z.string().default(".").describe("Path to the Git repository."),
 });
-/**
- * Parses the output of 'git status --porcelain=v1 -b'.
- * See: https://git-scm.com/docs/git-status#_porcelain_format_version_1
- *
- * @param {string} porcelainOutput - The raw output from the git command.
- * @returns {GitStatusResult} - Structured status information.
- */
-function parseGitStatusPorcelainV1(porcelainOutput) {
-    const lines = porcelainOutput.trim().split("\n");
+// 2. DEFINE the Zod response schema.
+const ChangesSchema = z.object({
+    Added: z.array(z.string()).optional(),
+    Modified: z.array(z.string()).optional(),
+    Deleted: z.array(z.string()).optional(),
+    Renamed: z.array(z.string()).optional(),
+    Copied: z.array(z.string()).optional(),
+    TypeChanged: z.array(z.string()).optional(),
+});
+export const GitStatusOutputSchema = z.object({
+    current_branch: z.string().nullable().describe("The current branch, or null for detached HEAD."),
+    staged_changes: ChangesSchema.describe("Changes staged for the next commit."),
+    unstaged_changes: ChangesSchema.describe("Changes not staged for commit."),
+    untracked_files: z.array(z.string()).describe("Files not tracked by Git."),
+    conflicted_files: z.array(z.string()).describe("Files with merge conflicts."),
+    is_clean: z.boolean().describe("True if there are no pending changes."),
+});
+function parseGitStatus(porcelainOutput) {
+    const lines = porcelainOutput.trim().split("\n").filter(Boolean);
     const result = {
         current_branch: null,
         staged_changes: {},
         unstaged_changes: {},
         untracked_files: [],
         conflicted_files: [],
-        is_clean: true, // Assume clean initially
+        is_clean: true,
     };
-    if (lines.length === 0 || (lines.length === 1 && lines[0] === "")) {
-        return result;
-    }
-    if (lines[0].startsWith("## ")) {
+    if (lines.length > 0 && lines[0].startsWith("## ")) {
         const branchLine = lines.shift();
-        const standardBranchMatch = branchLine.match(/^## ([^ ]+?)(?:\.\.\.| \[.*\]|$)/);
-        const noCommitsMatch = branchLine.match(/^## No commits yet on (.+)/);
-        const detachedMatch = branchLine.match(/^## HEAD \(no branch\)/);
-        if (standardBranchMatch) {
-            result.current_branch = standardBranchMatch[1];
-        }
-        else if (noCommitsMatch) {
-            result.current_branch = `${noCommitsMatch[1]} (no commits yet)`;
-        }
-        else if (detachedMatch) {
-            result.current_branch = "HEAD (detached)";
-        }
-        else {
-            logger.warning("Could not parse branch information from line:", {
-                branchLine,
-            });
-            result.current_branch = "(unknown)";
-        }
+        const branchMatch = branchLine.match(/^## (.*?)(?:\.\.\..*)?$/);
+        result.current_branch = branchMatch ? branchMatch[1] : "HEAD (detached)";
     }
-    for (const line of lines) {
-        if (!line)
-            continue;
-        result.is_clean = false; // Any line indicates non-clean state
+    lines.forEach(line => {
+        result.is_clean = false;
         const xy = line.substring(0, 2);
         const file = line.substring(3);
-        const stagedStatusChar = xy[0];
-        const unstagedStatusChar = xy[1];
-        // Handle untracked files
-        if (xy === "??") {
+        const staged = xy[0];
+        const unstaged = xy[1];
+        if (xy === '??') {
             result.untracked_files.push(file);
-            continue;
         }
-        // Handle conflicted files (unmerged paths)
-        // DD = both deleted, AU = added by us, UD = deleted by them, UA = added by them, DU = deleted by us
-        // AA = both added, UU = both modified
-        if (stagedStatusChar === "U" ||
-            unstagedStatusChar === "U" ||
-            (stagedStatusChar === "D" && unstagedStatusChar === "D") ||
-            (stagedStatusChar === "A" && unstagedStatusChar === "A")) {
+        else if (staged === 'U' || unstaged === 'U' || (staged === 'A' && unstaged === 'A') || (staged === 'D' && unstaged === 'D')) {
             result.conflicted_files.push(file);
-            continue; // Conflicted files are handled separately and not in staged/unstaged
         }
-        // Handle staged changes (index status)
-        if (stagedStatusChar !== " " && stagedStatusChar !== "?") {
-            let statusDesc = undefined;
-            switch (stagedStatusChar) {
-                case "M":
-                    statusDesc = "Modified";
-                    break;
-                case "A":
-                    statusDesc = "Added";
-                    break;
-                case "D":
-                    statusDesc = "Deleted";
-                    break;
-                case "R":
-                    statusDesc = "Renamed";
-                    break;
-                case "C":
-                    statusDesc = "Copied";
-                    break;
-                case "T":
-                    statusDesc = "TypeChanged";
-                    break;
-            }
-            if (statusDesc) {
-                if (!result.staged_changes[statusDesc]) {
-                    result.staged_changes[statusDesc] = [];
+        else {
+            const mapStatus = (char, changeSet) => {
+                let statusKey;
+                switch (char) {
+                    case 'M':
+                        statusKey = 'Modified';
+                        break;
+                    case 'A':
+                        statusKey = 'Added';
+                        break;
+                    case 'D':
+                        statusKey = 'Deleted';
+                        break;
+                    case 'R':
+                        statusKey = 'Renamed';
+                        break;
+                    case 'C':
+                        statusKey = 'Copied';
+                        break;
+                    case 'T':
+                        statusKey = 'TypeChanged';
+                        break;
+                    default: return;
                 }
-                result.staged_changes[statusDesc].push(file);
-            }
-        }
-        // Handle unstaged changes (worktree status)
-        if (unstagedStatusChar !== " " && unstagedStatusChar !== "?") {
-            let statusDesc = undefined;
-            switch (unstagedStatusChar) {
-                case "M":
-                    statusDesc = "Modified";
-                    break;
-                case "D":
-                    statusDesc = "Deleted";
-                    break;
-                case "T":
-                    statusDesc = "TypeChanged";
-                    break;
-                // 'A' (Added but not committed) is handled by '??' (untracked)
-                // 'R' and 'C' in worktree without being staged are complex, often appear as deleted + untracked
-            }
-            if (statusDesc) {
-                if (!result.unstaged_changes[statusDesc]) {
-                    result.unstaged_changes[statusDesc] = [];
+                if (!changeSet[statusKey]) {
+                    changeSet[statusKey] = [];
                 }
-                result.unstaged_changes[statusDesc].push(file);
-            }
+                changeSet[statusKey].push(file);
+            };
+            mapStatus(staged, result.staged_changes);
+            mapStatus(unstaged, result.unstaged_changes);
         }
-    }
-    result.is_clean =
-        Object.keys(result.staged_changes).length === 0 &&
-            Object.keys(result.unstaged_changes).length === 0 &&
-            result.untracked_files.length === 0 &&
-            result.conflicted_files.length === 0;
+    });
     return result;
 }
 /**
- * Executes the 'git status --porcelain=v1 -b' command and returns structured JSON output.
- *
- * @param {GitStatusInput} input - The validated input object containing the repository path.
- * @param {RequestContext} context - The request context for logging and error handling.
- * @returns {Promise<GitStatusResult>} A promise that resolves with the structured git status.
- * @throws {McpError} Throws an McpError if path resolution or validation fails, or if the git command fails.
+ * 4. IMPLEMENT the core logic function.
+ * @throws {McpError} If the logic encounters an unrecoverable issue.
  */
-export async function getGitStatus(input, context) {
+export async function getGitStatus(params, context) {
     const operation = "getGitStatus";
-    logger.debug(`Executing ${operation}`, { ...context, input });
-    let targetPath;
-    try {
-        // Resolve the target path
-        if (input.path && input.path !== ".") {
-            // Use the provided path directly
-            targetPath = input.path;
-            logger.debug(`Using provided path: ${targetPath}`, {
-                ...context,
-                operation,
-            });
-        }
-        else {
-            // Path is '.' or undefined, try to get the session's working directory
-            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;
-            logger.debug(`Using session working directory: ${targetPath}`, {
-                ...context,
-                operation,
-                sessionId: context.sessionId,
-            });
-        }
-        // Sanitize the resolved path
-        const sanitizedPathInfo = sanitization.sanitizePath(targetPath, {
-            allowAbsolute: true,
-        });
-        logger.debug("Sanitized path", {
-            ...context,
-            operation,
-            sanitizedPathInfo,
-        });
-        targetPath = sanitizedPathInfo.sanitizedPath; // Use the sanitized path going forward
-    }
-    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 });
+    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.");
     }
+    const targetPath = sanitization.sanitizePath(params.path === "." ? workingDir : params.path, { allowAbsolute: true }).sanitizedPath;
+    const args = ["-C", targetPath, "status", "--porcelain=v1", "-b"];
     try {
-        // Using --porcelain=v1 for stable, scriptable output and -b for branch info
-        const args = ["-C", targetPath, "status", "--porcelain=v1", "-b"];
-        logger.debug(`Executing command: git ${args.join(" ")}`, {
-            ...context,
-            operation,
-        });
-        const { stdout, stderr } = await execFileAsync("git", args);
-        if (stderr) {
-            // Log stderr as warning but proceed to parse stdout
-            logger.warning(`Git status command produced stderr (may be informational)`, { ...context, operation, stderr });
-        }
-        logger.debug(`${operation} command executed, parsing output...`, {
-            ...context,
-            operation,
-            path: targetPath,
-        });
-        // Parse the porcelain output
-        const structuredResult = parseGitStatusPorcelainV1(stdout);
-        // If parsing resulted in clean state but no branch, re-check branch explicitly
-        // This handles the case of an empty repo after init but before first commit
-        if (structuredResult.is_clean && !structuredResult.current_branch) {
-            try {
-                const branchArgs = [
-                    "-C",
-                    targetPath,
-                    "rev-parse",
-                    "--abbrev-ref",
-                    "HEAD",
-                ];
-                const { stdout: branchStdout } = await execFileAsync("git", branchArgs);
-                const currentBranchName = branchStdout.trim(); // Renamed variable for clarity
-                if (currentBranchName && currentBranchName !== "HEAD") {
-                    structuredResult.current_branch = currentBranchName;
-                }
-                else if (currentBranchName === "HEAD" &&
-                    !structuredResult.current_branch) {
-                    // If rev-parse returns HEAD and we still don't have a branch (e.g. detached from no-commits branch)
-                    structuredResult.current_branch = "HEAD (detached)";
-                }
-            }
-            catch (branchError) {
-                // Ignore error if rev-parse fails (e.g., still no commits)
-                logger.debug("Could not determine branch via rev-parse, likely no commits yet.", { ...context, operation, branchError });
-            }
-        }
-        logger.info("git status parsed successfully", {
-            ...context,
-            operation,
-            path: targetPath,
-            isClean: structuredResult.is_clean,
-            currentBranch: structuredResult.current_branch,
-        });
-        return structuredResult; // Return the structured JSON object
+        logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+        const { stdout } = await execFileAsync("git", args);
+        return parseGitStatus(stdout);
     }
     catch (error) {
-        logger.error(`Failed to execute or parse git status command`, {
-            ...context,
-            operation,
-            path: targetPath,
-            error: error.message,
-            stderr: error.stderr,
-        });
         const errorMessage = error.stderr || error.message || "";
+        logger.error(`Failed to execute git status 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 });
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`);
         }
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to get git status for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git status failed: ${errorMessage}`);
     }
 }

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

@@ -1,78 +1,64 @@
-import { BaseErrorCode } from "../../../types-global/errors.js"; // Direct import for types-global
-import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js"; // logger (./utils/internal/logger.js), ErrorHandler (./utils/internal/errorHandler.js), requestContextService (./utils/internal/requestContext.js)
-// Import the result type along with the function and input schema
-import { getGitStatus, GitStatusInputSchema, } 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_status tool.
+ * @module src/mcp-server/tools/gitStatus/registration
  */
-export function initializeGitStatusStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_status tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
+import { getGitStatus, GitStatusInputSchema, GitStatusOutputSchema, } from "./logic.js";
 const TOOL_NAME = "git_status";
 const TOOL_DESCRIPTION = "Retrieves the status of a Git repository. Returns a JSON object detailing the current branch, cleanliness, and changes. Staged and unstaged changes are grouped by status (e.g., Added, Modified), alongside lists of untracked and conflicted files.";
 /**
- * Registers the git_status 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_status 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 registerGitStatusTool = async (server) => {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_status must be initialized before registration.");
-    }
+export const registerGitStatusTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitStatusTool";
     const context = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(async () => {
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitStatusInputSchema.shape, // Provide the Zod schema shape
-        async (validatedArgs, callContext) => {
-            const toolOperation = "tool:git_status";
-            // Create context, potentially inheriting from callContext
-            const requestContext = requestContextService.createRequestContext({
-                operation: toolOperation,
-                parentContext: callContext,
+    server.registerTool(TOOL_NAME, {
+        title: "Git Status",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitStatusInputSchema.shape,
+        outputSchema: GitStatusOutputSchema.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 getGitStatus(params, {
+                ...handlerContext,
+                getWorkingDirectory: () => getWorkingDirectory(sessionId),
             });
-            // Get session ID
-            const sessionId = _getSessionId(requestContext);
-            // Define the session-specific getter function
-            const getWorkingDirectoryForSession = () => {
-                return _getWorkingDirectory(sessionId);
-            };
-            // Enhance context for the logic function
-            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);
-            // Use ErrorHandler.tryCatch to wrap the logic execution
-            return await ErrorHandler.tryCatch(async () => {
-                // Call the core logic function with validated args and enhanced context
-                const statusResult = await getGitStatus(validatedArgs, logicContext);
-                // Format the successful result as a JSON string within TextContent
-                const resultContent = {
-                    type: "text",
-                    // Stringify the JSON object for the response content
-                    text: JSON.stringify(statusResult, null, 2), // Pretty-print JSON
-                    contentType: "application/json", // Specify content type
-                };
-                logger.info(`Tool ${TOOL_NAME} executed successfully, returning JSON`, logicContext);
-                return { content: [resultContent] }; // isError defaults to false
-            }, {
-                operation: toolOperation,
-                context: logicContext,
-                input: validatedArgs, // Log sanitized input
-                errorCode: BaseErrorCode.INTERNAL_ERROR, // Default error code if logic fails unexpectedly
+        }
+        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 }); // Treat registration failure as critical
+            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);
 };