@cyanheads/git-mcp-server 2.1.8 → 2.2.1

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

@@ -1,86 +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 { BaseErrorCode } from "../../../types-global/errors.js"; // Keep direct import for types-global
-import { requestContextService } from "../../../utils/index.js";
-import { GitPushInputSchema, pushGitChanges, } 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_push tool.
+ * @module src/mcp-server/tools/gitPush/registration
  */
-export function initializeGitPushStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_push tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { pushGitChanges, GitPushOutputSchema, GitPushBaseSchema, } from "./logic.js";
 const TOOL_NAME = "git_push";
 const TOOL_DESCRIPTION = "Updates remote refs using local refs, sending objects necessary to complete the given refs. Supports pushing specific branches, tags, forcing, setting upstream, and deleting remote branches. Returns the push result as a JSON object.";
 /**
- * Registers the git_push tool with the MCP server.
- *
- * @param {McpServer} server - The MCP server instance.
- * @throws {Error} If state accessors are not initialized.
+ * Registers the git_push 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 registerGitPushTool(server) {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_push must be initialized before registration.");
-    }
+export const registerGitPushTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitPushTool";
     const context = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(async () => {
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitPushInputSchema.shape, // Provide the Zod schema shape
-        async (validatedArgs, callContext) => {
-            const toolOperation = "tool:git_push";
-            const requestContext = requestContextService.createRequestContext({
-                operation: toolOperation,
-                parentContext: callContext,
+    server.registerTool(TOOL_NAME, {
+        title: "Git Push",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitPushBaseSchema.shape,
+        outputSchema: GitPushOutputSchema.shape,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true, // Can alter remote history
+            idempotentHint: false,
+            openWorldHint: true, // Interacts with remote repositories
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
+        });
+        try {
+            const sessionId = getSessionId(handlerContext);
+            const result = await pushGitChanges(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
-                const pushResult = await pushGitChanges(validatedArgs, logicContext);
-                // Format the result as a JSON string within TextContent
-                const resultContent = {
-                    type: "text",
-                    text: JSON.stringify(pushResult, null, 2), // Pretty-print JSON
-                    contentType: "application/json",
-                };
-                // Log based on the success flag in the result
-                if (pushResult.success) {
-                    logger.info(`Tool ${TOOL_NAME} executed successfully, returning JSON`, logicContext);
-                }
-                else {
-                    // Log non-fatal conditions like rejections differently
-                    const logMessage = pushResult.rejected
-                        ? `Tool ${TOOL_NAME} completed but push was rejected, returning JSON`
-                        : `Tool ${TOOL_NAME} completed with status: ${pushResult.message}, returning JSON`;
-                    logger.info(logMessage, logicContext);
-                }
-                // Even if success is false (e.g., rejected), it's not necessarily a tool execution *error*
-                // unless the logic threw an McpError. The success flag in the JSON indicates the Git outcome.
-                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);
+};

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

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

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

@@ -1,222 +1,74 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_rebase tool.
+ * @module src/mcp-server/tools/gitRebase/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 for the git_rebase tool using Zod
+// 1. DEFINE the Zod input schema.
 export const GitRebaseBaseSchema = 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(["start", "continue", "abort", "skip"])
-        .default("start")
-        .describe("Rebase operation mode: 'start' (initiate rebase), 'continue', 'abort', 'skip' (manage ongoing rebase)."),
-    upstream: z
-        .string()
-        .min(1)
-        .optional()
-        .describe("The upstream branch or commit to rebase onto. Required for 'start' mode unless 'interactive' is true with default base."),
-    branch: z
-        .string()
-        .min(1)
-        .optional()
-        .describe("The branch to rebase. Defaults to the current branch if omitted."),
-    interactive: z
-        .boolean()
-        .default(false)
-        .describe("Perform an interactive rebase (`-i`). 'upstream' can be omitted to rebase current branch's tracked upstream or use fork-point."),
-    strategy: z
-        .enum(["recursive", "resolve", "ours", "theirs", "octopus", "subtree"])
-        .optional()
-        .describe("Specifies the merge strategy to use during rebase."),
-    strategyOption: z
-        .string()
-        .optional()
-        .describe("Pass a specific option to the merge strategy (e.g., 'ours', 'theirs' for recursive). Use with -X."),
-    onto: z
-        .string()
-        .min(1)
-        .optional()
-        .describe("Rebase onto a specific commit/branch instead of the upstream's base. Requires 'upstream' to be specified."),
-    // TODO: Add options like --preserve-merges, --autosquash, --autostash?
+    path: z.string().default(".").describe("Path to the local Git repository."),
+    mode: z.enum(["start", "continue", "abort", "skip"]).default("start").describe("Rebase operation mode."),
+    upstream: z.string().min(1).optional().describe("The upstream branch or commit to rebase onto."),
+    branch: z.string().min(1).optional().describe("The branch to rebase."),
+    interactive: z.boolean().default(false).describe("Perform an interactive rebase."),
+    strategy: z.enum(["recursive", "resolve", "ours", "theirs", "octopus", "subtree"]).optional().describe("The merge strategy to use."),
+    strategyOption: z.string().optional().describe("Pass a specific option to the merge strategy."),
+    onto: z.string().min(1).optional().describe("Rebase onto a specific commit/branch instead of the upstream's base."),
 });
-// Apply refinements and export the FINAL schema for validation within the handler
 export const GitRebaseInputSchema = GitRebaseBaseSchema.refine((data) => !(data.mode === "start" && !data.interactive && !data.upstream), {
     message: "An 'upstream' branch/commit is required for 'start' mode unless 'interactive' is true.",
     path: ["upstream"],
-}).refine((data) => !(data.mode !== "start" &&
-    (data.upstream ||
-        data.branch ||
-        data.interactive ||
-        data.strategy ||
-        data.onto)), {
-    message: "Parameters like 'upstream', 'branch', 'interactive', 'strategy', 'onto' are only applicable for 'start' mode.",
-    path: ["mode"],
+});
+// 2. DEFINE the Zod response schema.
+export const GitRebaseOutputSchema = z.object({
+    success: z.boolean().describe("Indicates if the command was successful."),
+    message: z.string().describe("A summary message of the result."),
+    rebaseCompleted: z.boolean().optional().describe("True if the rebase finished successfully."),
+    needsManualAction: z.boolean().optional().describe("True if conflicts or interactive steps require user input."),
 });
 /**
- * Executes the 'git rebase' command based on the specified mode.
- *
- * @param {GitRebaseInput} input - The validated input object.
- * @param {RequestContext} context - The request context for logging and error handling.
- * @returns {Promise<GitRebaseResult>} A promise that resolves with the structured result.
- * @throws {McpError} Throws an McpError for path resolution/validation failures or unexpected errors.
+ * 4. IMPLEMENT the core logic function.
+ * @throws {McpError} If the logic encounters an unrecoverable issue.
  */
-export async function gitRebaseLogic(input, context) {
-    const operation = `gitRebaseLogic:${input.mode}`;
-    logger.debug(`Executing ${operation}`, { ...context, input });
-    let targetPath;
-    try {
-        // Resolve and sanitize the target path
-        const workingDir = context.getWorkingDirectory();
-        targetPath =
-            input.path && input.path !== "." ? input.path : (workingDir ?? ".");
-        if (targetPath === "." && !workingDir) {
-            logger.warning("Executing git rebase 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;
-        logger.debug("Sanitized path", {
-            ...context,
-            operation,
-            sanitizedPath: targetPath,
-        });
-    }
-    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 });
-    }
-    try {
-        const args = ["-C", targetPath, "rebase"];
-        switch (input.mode) {
-            case "start":
-                if (input.interactive) {
-                    args.push("-i");
-                }
-                if (input.strategy) {
-                    args.push(`--strategy=${input.strategy}`);
-                }
-                if (input.strategyOption) {
-                    args.push(`-X${input.strategyOption}`);
-                } // Note: -X for strategy options
-                if (input.onto) {
-                    args.push("--onto", input.onto);
-                }
-                // Upstream is required by refine unless interactive
-                if (input.upstream) {
-                    args.push(input.upstream);
-                }
-                if (input.branch) {
-                    args.push(input.branch);
-                }
-                break;
-            case "continue":
-                args.push("--continue");
-                break;
-            case "abort":
-                args.push("--abort");
-                break;
-            case "skip":
-                args.push("--skip");
-                break;
-            default:
-                // Should not happen due to Zod validation
-                throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid mode: ${input.mode}`, { context, operation });
-        }
-        logger.debug(`Executing command: git ${args.join(" ")}`, {
-            ...context,
-            operation,
-        });
-        try {
-            const { stdout, stderr } = await execFileAsync("git", args);
-            const output = stdout + stderr;
-            const message = `Rebase ${input.mode} executed successfully. Output: ${output.trim()}`;
-            logger.info(message, { ...context, operation, path: targetPath });
-            return {
-                success: true,
-                mode: input.mode,
-                message,
-                rebaseCompleted: /successfully rebased/.test(output),
-                needsManualAction: /conflict|stopped at|edit/i.test(output),
-            };
-        }
-        catch (rebaseError) {
-            const errorMessage = rebaseError.stderr || rebaseError.stdout || rebaseError.message || "";
-            logger.error(`Git rebase ${input.mode} command failed`, {
-                ...context,
-                operation,
-                path: targetPath,
-                error: errorMessage,
-                stderr: rebaseError.stderr,
-                stdout: rebaseError.stdout,
-            });
-            // Handle specific error cases
-            if (/conflict/i.test(errorMessage)) {
-                throw new McpError(BaseErrorCode.CONFLICT, `Rebase ${input.mode} failed due to conflicts. Resolve conflicts and use 'git rebase --continue'. Error: ${errorMessage}`, { context, operation, originalError: rebaseError });
-            }
-            if (/no rebase in progress/i.test(errorMessage)) {
-                throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Failed to ${input.mode} rebase: No rebase is currently in progress. Error: ${errorMessage}`, { context, operation, originalError: rebaseError });
-            }
-            if (/cannot rebase onto multiple branches/i.test(errorMessage)) {
-                throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Failed to start rebase: Cannot rebase onto multiple branches. Check your 'upstream' parameter. Error: ${errorMessage}`, { context, operation, originalError: rebaseError });
-            }
-            if (/does not point to a valid commit/i.test(errorMessage)) {
-                throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Failed to start rebase: Invalid upstream, branch, or onto reference provided. Error: ${errorMessage}`, { context, operation, originalError: rebaseError });
-            }
-            if (/your local changes would be overwritten/i.test(errorMessage)) {
-                throw new McpError(BaseErrorCode.CONFLICT, `Failed to ${input.mode} rebase: Your local changes to tracked files would be overwritten. Please commit or stash them. Error: ${errorMessage}`, { context, operation, originalError: rebaseError });
-            }
-            if (/interactive rebase already started/i.test(errorMessage)) {
-                throw new McpError(BaseErrorCode.CONFLICT, `Failed to start rebase: An interactive rebase is already in progress. Use 'continue', 'abort', or 'skip'. Error: ${errorMessage}`, { context, operation, originalError: rebaseError });
-            }
-            // Throw McpError for critical issues like non-existent repo
-            if (errorMessage.toLowerCase().includes("not a git repository")) {
-                throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`, { context, operation, originalError: rebaseError });
-            }
-            // Throw a generic McpError for other failures
-            throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git rebase ${input.mode} failed for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: rebaseError });
-        }
+export async function gitRebaseLogic(params, context) {
+    const operation = `gitRebaseLogic:${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.");
     }
-    catch (error) {
-        // Catch errors from path resolution or unexpected issues before command execution
-        logger.error(`Unexpected error during git rebase setup or execution`, {
-            ...context,
-            operation,
-            path: targetPath,
-            error: error.message,
-        });
-        if (error instanceof McpError)
-            throw error;
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `An unexpected error occurred during git rebase ${input.mode}: ${error.message}`, { context, operation, originalError: error });
+    const targetPath = sanitization.sanitizePath(params.path === "." ? workingDir : params.path, { allowAbsolute: true }).sanitizedPath;
+    const args = ["-C", targetPath, "rebase"];
+    switch (params.mode) {
+        case "start":
+            if (params.interactive)
+                args.push("-i");
+            if (params.strategy)
+                args.push(`--strategy=${params.strategy}`);
+            if (params.strategyOption)
+                args.push(`-X${params.strategyOption}`);
+            if (params.onto)
+                args.push("--onto", params.onto);
+            if (params.upstream)
+                args.push(params.upstream);
+            if (params.branch)
+                args.push(params.branch);
+            break;
+        default:
+            args.push(`--${params.mode}`);
+            break;
     }
+    logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+    const { stdout, stderr } = await execFileAsync("git", args);
+    const output = stdout + stderr;
+    return {
+        success: true,
+        message: `Rebase ${params.mode} executed successfully.`,
+        rebaseCompleted: /successfully rebased/i.test(output),
+        needsManualAction: /conflict|stopped at|edit/i.test(output),
+    };
 }

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

@@ -1,82 +1,64 @@
-// Import utils from barrel (logger from ../utils/internal/logger.js)
-import { logger } from "../../../utils/index.js";
-// Import utils from barrel (ErrorHandler from ../utils/internal/errorHandler.js)
-import { ErrorHandler } from "../../../utils/index.js";
-// Import utils from barrel (requestContextService from ../utils/internal/requestContext.js)
-import { BaseErrorCode } from "../../../types-global/errors.js"; // Keep direct import for types-global
-import { requestContextService } from "../../../utils/index.js";
-import { GitRebaseBaseSchema, gitRebaseLogic, } from "./logic.js";
-let _getWorkingDirectory;
-let _getSessionId;
 /**
- * Initializes the state accessors needed by the git_rebase 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_rebase tool.
+ * @module src/mcp-server/tools/gitRebase/registration
  */
-export function initializeGitRebaseStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_rebase tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { gitRebaseLogic, GitRebaseOutputSchema, GitRebaseBaseSchema, } from "./logic.js";
 const TOOL_NAME = "git_rebase";
 const TOOL_DESCRIPTION = "Reapplies commits on top of another base tip. Supports starting a rebase (standard or interactive), continuing, aborting, or skipping steps in an ongoing rebase. Returns results as a JSON object.";
 /**
- * Registers the git_rebase 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_rebase 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 registerGitRebaseTool = async (server) => {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_rebase must be initialized before registration.");
-    }
+export const registerGitRebaseTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitRebaseTool";
     const context = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(async () => {
-        // Register using the BASE schema shape
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitRebaseBaseSchema.shape, 
-        // SDK validates against the full GitRebaseInputSchema before calling this handler
-        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 Rebase",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitRebaseBaseSchema.shape,
+        outputSchema: GitRebaseOutputSchema.shape,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true, // Rebase alters commit history
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
+        });
+        try {
+            const sessionId = getSessionId(handlerContext);
+            const result = await gitRebaseLogic(params, {
+                ...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 rebaseResult = await gitRebaseLogic(toolInput, logicContext);
-                const resultContent = {
-                    type: "text",
-                    text: JSON.stringify(rebaseResult, null, 2), // Pretty-print JSON
-                    contentType: "application/json",
-                };
-                if (rebaseResult.success) {
-                    logger.info(`Tool ${TOOL_NAME} (mode: ${toolInput.mode}) executed successfully (Needs Manual Action: ${!!rebaseResult.needsManualAction}), returning JSON`, logicContext);
-                }
-                else {
-                    logger.warning(`Tool ${TOOL_NAME} (mode: ${toolInput.mode}) failed: ${rebaseResult.message}`, {
-                        ...logicContext,
-                        errorDetails: rebaseResult.error,
-                        conflicts: rebaseResult.conflicts,
-                    });
-                }
-                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/gitRemote/index.js

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