@cyanheads/git-mcp-server 2.1.8 → 2.2.0

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

@@ -1,222 +1,93 @@
+/**
+ * @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,
-        });
+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) {
-        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, "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;
     }
     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 });
+        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),
+        };
+    }
+    catch (error) {
+        const errorMessage = error.stderr || error.stdout || error.message || "";
+        logger.error(`Git rebase ${params.mode} command failed`, { ...context, operation, errorMessage });
+        if (/conflict/i.test(errorMessage)) {
+            throw new McpError(BaseErrorCode.CONFLICT, `Rebase failed due to conflicts. Please resolve them and use 'git rebase --continue'.`);
         }
-        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),
-            };
+        if (/no rebase in progress/i.test(errorMessage)) {
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Failed to ${params.mode} rebase: No rebase is currently in progress.`);
         }
-        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 });
+        if (/your local changes would be overwritten/i.test(errorMessage)) {
+            throw new McpError(BaseErrorCode.CONFLICT, "Rebase failed: Your local changes would be overwritten. Please commit or stash them.");
         }
-    }
-    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 });
+        if (/not a git repository/i.test(errorMessage)) {
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`);
+        }
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git rebase ${params.mode} failed: ${errorMessage}`);
     }
 }

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 { McpError, BaseErrorCode } from "../../../types-global/errors.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 handledError = ErrorHandler.handleError(error, {
+                operation: `tool:${TOOL_NAME}`,
+                context: handlerContext,
+                input: params,
             });
-        });
-        logger.info(`Tool registered: ${TOOL_NAME}`, context);
-    }, { operation, context, critical: true });
+            const mcpError = handledError instanceof McpError
+                ? handledError
+                : new McpError(BaseErrorCode.INTERNAL_ERROR, "An unexpected error occurred.", { originalError: handledError });
+            return {
+                isError: true,
+                content: [{ type: "text", text: mcpError.message }],
+                structuredContent: mcpError.details,
+            };
+        }
+    });
+    logger.info(`Tool '${TOOL_NAME}' registered successfully.`, context);
 };

package/dist/mcp-server/tools/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";