@cyanheads/git-mcp-server 2.1.7 → 2.2.0

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

@@ -1,78 +1,57 @@
-// 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 { requestContextService } from "../../../utils/index.js";
-// Import the result type along with the function and input schema
-import { BaseErrorCode } from "../../../types-global/errors.js"; // Import BaseErrorCode
-import { addGitFiles, GitAddInputSchema, } 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.
- */
-export function initializeGitAddStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_add tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
+import { addGitFiles, GitAddInputSchema, GitAddOutputSchema, } from "./logic.js";
 const TOOL_NAME = "git_add";
 const TOOL_DESCRIPTION = "Stages changes in the Git repository for the next commit by adding file contents to the index (staging area). Can stage specific files/patterns or all changes (default: '.'). Returns the result as a JSON object.";
-/**
- * Registers the git_add 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.
- */
-export const registerGitAddTool = async (server) => {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_add must be initialized before registration.");
-    }
+export const registerGitAddTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitAddTool";
     const context = requestContextService.createRequestContext({ operation });
     await ErrorHandler.tryCatch(async () => {
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitAddInputSchema.shape, // Provide the Zod schema shape
-        async (validatedArgs, callContext) => {
+        server.registerTool(TOOL_NAME, {
+            title: "Git Add",
+            description: TOOL_DESCRIPTION,
+            inputSchema: GitAddInputSchema.shape,
+            outputSchema: GitAddOutputSchema.shape,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: false,
+                idempotentHint: true,
+                openWorldHint: false,
+            },
+        }, async (validatedArgs, callContext) => {
             const toolOperation = "tool:git_add";
             const requestContext = requestContextService.createRequestContext({
                 operation: toolOperation,
                 parentContext: callContext,
             });
-            const sessionId = _getSessionId(requestContext);
-            const getWorkingDirectoryForSession = () => {
-                return _getWorkingDirectory(sessionId);
-            };
+            const sessionId = getSessionId(requestContext);
             const logicContext = {
                 ...requestContext,
                 sessionId: sessionId,
-                getWorkingDirectory: getWorkingDirectoryForSession,
+                getWorkingDirectory: () => getWorkingDirectory(sessionId),
             };
             logger.info(`Executing tool: ${TOOL_NAME}`, logicContext);
-            return await ErrorHandler.tryCatch(async () => {
-                // Call the core logic function which now returns a GitAddResult object
-                const addResult = await addGitFiles(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(addResult, null, 2), // Pretty-print JSON
-                    contentType: "application/json",
+            try {
+                const result = await addGitFiles(validatedArgs, logicContext);
+                return {
+                    structuredContent: result,
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
                 };
-                logger.info(`Tool ${TOOL_NAME} executed successfully, returning JSON`, logicContext);
-                return { content: [resultContent] };
-            }, {
-                operation: toolOperation,
-                context: logicContext,
-                input: validatedArgs,
-                errorCode: BaseErrorCode.INTERNAL_ERROR, // Default error code
-                // Let the logic function throw specific errors like NOT_FOUND
-            });
+            }
+            catch (error) {
+                const handledError = ErrorHandler.handleError(error, {
+                    operation: "gitAddToolHandler",
+                    context: logicContext,
+                    input: validatedArgs,
+                });
+                const mcpError = handledError instanceof McpError
+                    ? handledError
+                    : new McpError(BaseErrorCode.INTERNAL_ERROR, "An unexpected error occurred while staging files.", { originalErrorName: handledError.name });
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Error: ${mcpError.message}` }],
+                };
+            }
         });
         logger.info(`Tool registered: ${TOOL_NAME}`, context);
     }, { operation, context, critical: true });

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

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

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

@@ -1,324 +1,146 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_branch tool.
+ * @module src/mcp-server/tools/gitBranch/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 { BaseErrorCode, McpError } from "../../../types-global/errors.js";
+import { logger, sanitization } from "../../../utils/index.js";
 const execFileAsync = promisify(execFile);
-// Define the BASE input schema for the git_branch tool using Zod
+// 1. DEFINE the Zod input schema.
 export const GitBranchBaseSchema = z.object({
-    path: z
-        .string()
-        .min(1)
-        .optional()
-        .default(".")
-        .describe("Path to the local Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
-    mode: z
-        .enum(["list", "create", "delete", "rename", "show-current"])
-        .describe("The branch operation to perform: 'list', 'create', 'delete', 'rename', 'show-current'."),
-    branchName: z
-        .string()
-        .min(1)
-        .optional()
-        .describe("The name of the branch (e.g., 'feat/new-login', 'main'). Required for 'create', 'delete', 'rename' modes."),
-    newBranchName: z
-        .string()
-        .min(1)
-        .optional()
-        .describe("The new name for the branch (e.g., 'fix/typo-in-readme'). Required for 'rename' mode."),
-    startPoint: z
-        .string()
-        .min(1)
-        .optional()
-        .describe("Optional commit hash, tag, or existing branch name (e.g., 'main', 'v1.0.0', 'commit-hash') to start the new branch from. Used only in 'create' mode. Defaults to HEAD."),
-    force: z
-        .boolean()
-        .default(false)
-        .describe("Force the operation. Use -D for delete, -M for rename, -f for create (if branch exists). Use with caution, as forcing operations can lead to data loss."),
-    all: z
-        .boolean()
-        .default(false)
-        .describe("List both local and remote-tracking branches. Used only in 'list' mode."),
-    remote: z
-        .boolean()
-        .default(false)
-        .describe("Act on remote-tracking branches. Used with 'list' (-r) or 'delete' (-r)."),
+    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."),
+    mode: z.enum(["list", "create", "delete", "rename", "show-current"]).describe("The branch operation to perform."),
+    branchName: z.string().optional().describe("The name of the branch for create, delete, or rename operations."),
+    newBranchName: z.string().optional().describe("The new name for the branch when renaming."),
+    startPoint: z.string().optional().describe("The starting point (commit, tag, or branch) for a new branch."),
+    force: z.boolean().default(false).describe("Force the operation (e.g., overwrite existing branch)."),
+    all: z.boolean().default(false).describe("List all branches (local and remote)."),
+    remote: z.boolean().default(false).describe("Act on remote-tracking branches."),
 });
-// Apply refinements and export the FINAL schema for validation within the handler
-export const GitBranchInputSchema = GitBranchBaseSchema.refine((data) => !(data.mode === "create" && !data.branchName), {
+export const GitBranchInputSchema = GitBranchBaseSchema.refine(data => !(data.mode === "create" && !data.branchName), {
     message: "A 'branchName' is required for 'create' mode.",
     path: ["branchName"],
-})
-    .refine((data) => !(data.mode === "delete" && !data.branchName), {
+}).refine(data => !(data.mode === "delete" && !data.branchName), {
     message: "A 'branchName' is required for 'delete' mode.",
     path: ["branchName"],
-})
-    .refine((data) => !(data.mode === "rename" && (!data.branchName || !data.newBranchName)), {
-    message: "Both 'branchName' (old name) and 'newBranchName' are required for 'rename' mode.",
-    path: ["branchName", "newBranchName"],
+}).refine(data => !(data.mode === "rename" && (!data.branchName || !data.newBranchName)), {
+    message: "Both 'branchName' and 'newBranchName' are required for 'rename' mode.",
+    path: ["newBranchName"],
+});
+// 2. DEFINE the Zod response schema.
+const BranchInfoSchema = z.object({
+    name: z.string(),
+    isCurrent: z.boolean(),
+    isRemote: z.boolean(),
+    commitHash: z.string().optional(),
+    commitSubject: z.string().optional(),
+});
+export const GitBranchOutputSchema = z.object({
+    success: z.boolean().describe("Indicates if the command was successful."),
+    mode: z.string().describe("The mode of operation that was performed."),
+    message: z.string().describe("A summary message of the result."),
+    branches: z.array(BranchInfoSchema).optional().describe("A list of branches for the 'list' mode."),
+    currentBranch: z.string().nullable().optional().describe("The current branch name."),
 });
 /**
- * Executes git branch commands based on the specified mode.
- *
- * @param {GitBranchInput} input - The validated input object.
- * @param {RequestContext} context - The request context for logging and error handling.
- * @returns {Promise<GitBranchResult>} 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 gitBranchLogic(input, context) {
-    const operation = `gitBranchLogic:${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 branch 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 gitBranchLogic(params, context) {
+    const operation = `gitBranchLogic:${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];
+    switch (params.mode) {
+        case "list":
+            args.push("branch", "--list", "--no-color", "--verbose");
+            if (params.all)
+                args.push("-a");
+            else if (params.remote)
+                args.push("-r");
+            break;
+        case "create":
+            args.push("branch");
+            if (params.force)
+                args.push("-f");
+            args.push(params.branchName, params.startPoint || "");
+            break;
+        case "delete":
+            args.push("branch", params.force ? "-D" : "-d");
+            if (params.remote)
+                args.push("-r");
+            args.push(params.branchName);
+            break;
+        case "rename":
+            args.push("branch", params.force ? "-M" : "-m", params.branchName, params.newBranchName);
+            break;
+        case "show-current":
+            args.push("branch", "--show-current");
+            break;
     }
     try {
-        let args;
-        let result;
-        switch (input.mode) {
-            case "list":
-                args = ["-C", targetPath, "branch", "--list", "--no-color"]; // Start with basic list
-                if (input.all) {
-                    args.push("-a"); // Add -a if requested
-                }
-                else if (input.remote) {
-                    args.push("-r"); // Add -r if requested (exclusive with -a)
-                }
-                args.push("--verbose"); // Add verbose for commit info
-                logger.debug(`Executing command: git ${args.join(" ")}`, {
-                    ...context,
-                    operation,
-                });
-                const { stdout: listStdout } = await execFileAsync("git", args);
-                const branches = listStdout
-                    .trim()
-                    .split("\n")
-                    .filter((line) => line && !line.match(/^\s*->\s*/)) // Filter out HEAD pointer lines if any
-                    .map((line) => {
-                    const isCurrent = line.startsWith("* ");
-                    const trimmedLine = line.replace(/^\*?\s+/, ""); // Remove leading '*' and spaces
-                    // Determine isRemote based on the raw trimmed line BEFORE splitting
-                    const isRemote = trimmedLine.startsWith("remotes/");
-                    const parts = trimmedLine.split(/\s+/);
-                    const name = parts[0]; // This might be 'remotes/origin/main' or just 'main'
-                    const commitHash = parts[1] || undefined; // Verbose gives hash
-                    const commitSubject = parts.slice(2).join(" ") || undefined; // Verbose gives subject
-                    // Return the correct name (without 'remotes/' prefix if it was remote) and the isRemote flag
-                    return {
-                        name: isRemote ? name.split("/").slice(2).join("/") : name, // e.g., 'origin/main' or 'main'
-                        isCurrent,
-                        isRemote, // Use the flag determined before splitting
-                        commitHash,
-                        commitSubject,
-                    };
-                });
-                const currentBranch = branches.find((b) => b.isCurrent)?.name;
-                result = { success: true, mode: "list", branches, currentBranch };
-                break;
-            case "create":
-                // branchName is validated by Zod refine
-                args = ["-C", targetPath, "branch"];
-                if (input.force) {
-                    args.push("-f");
-                }
-                args.push(input.branchName); // branchName is guaranteed by refine
-                if (input.startPoint) {
-                    args.push(input.startPoint);
-                }
-                logger.debug(`Executing command: git ${args.join(" ")}`, {
-                    ...context,
-                    operation,
-                });
-                await execFileAsync("git", args);
-                result = {
-                    success: true,
-                    mode: "create",
-                    branchName: input.branchName,
-                    message: `Branch '${input.branchName}' created successfully.`,
-                };
-                break;
-            case "delete":
-                // branchName is validated by Zod refine
-                args = ["-C", targetPath, "branch"];
-                if (input.remote) {
-                    args.push("-r");
-                }
-                args.push(input.force ? "-D" : "-d");
-                args.push(input.branchName); // branchName is guaranteed by refine
-                logger.debug(`Executing command: git ${args.join(" ")}`, {
-                    ...context,
-                    operation,
-                });
-                const { stdout: deleteStdout } = await execFileAsync("git", args);
-                result = {
-                    success: true,
-                    mode: "delete",
-                    branchName: input.branchName,
-                    wasRemote: input.remote,
-                    message: deleteStdout.trim() ||
-                        `Branch '${input.branchName}' deleted successfully.`,
-                };
-                break;
-            case "rename":
-                // branchName and newBranchName validated by Zod refine
-                args = ["-C", targetPath, "branch"];
-                args.push(input.force ? "-M" : "-m");
-                args.push(input.branchName, input.newBranchName);
-                logger.debug(`Executing command: git ${args.join(" ")}`, {
-                    ...context,
-                    operation,
-                });
-                await execFileAsync("git", args);
-                result = {
-                    success: true,
-                    mode: "rename",
-                    oldBranchName: input.branchName,
-                    newBranchName: input.newBranchName,
-                    message: `Branch '${input.branchName}' renamed to '${input.newBranchName}' successfully.`,
-                };
-                break;
-            case "show-current":
-                args = ["-C", targetPath, "branch", "--show-current"];
-                logger.debug(`Executing command: git ${args.join(" ")}`, {
-                    ...context,
-                    operation,
-                });
-                try {
-                    const { stdout: currentStdout } = await execFileAsync("git", args);
-                    const currentBranchName = currentStdout.trim();
-                    result = {
-                        success: true,
-                        mode: "show-current",
-                        currentBranch: currentBranchName || null,
-                        message: currentBranchName
-                            ? `Current branch is '${currentBranchName}'.`
-                            : "Currently in detached HEAD state.",
-                    };
-                }
-                catch (showError) {
-                    // Handle detached HEAD state specifically if command fails
-                    if (showError.stderr?.includes("HEAD detached")) {
-                        result = {
-                            success: true,
-                            mode: "show-current",
-                            currentBranch: null,
-                            message: "Currently in detached HEAD state.",
-                        };
-                    }
-                    else {
-                        throw showError; // Re-throw other errors
-                    }
-                }
-                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.filter(Boolean));
+        if (stderr && !stderr.includes("HEAD detached")) {
+            logger.warning(`Git branch command produced stderr`, { ...context, operation, stderr });
         }
-        logger.info(`git branch ${input.mode} executed successfully`, {
-            ...context,
-            operation,
-            path: targetPath,
-            result,
-        });
-        return result;
-    }
-    catch (error) {
-        const errorMessage = error.stderr || error.stdout || error.message || ""; // stdout might contain error messages too
-        logger.error(`Failed to execute git branch command`, {
-            ...context,
-            operation,
-            path: targetPath,
-            error: errorMessage,
-            stderr: error.stderr,
-            stdout: error.stdout,
-        });
-        // Specific error handling
-        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 (input.mode === "create" && errorMessage.includes("already exists")) {
+        if (params.mode === "list") {
+            const branches = stdout.trim().split("\n").filter(Boolean).map(line => {
+                const isCurrent = line.startsWith("* ");
+                const trimmedLine = line.replace(/^\*?\s+/, "");
+                const isRemote = trimmedLine.startsWith("remotes/");
+                const parts = trimmedLine.split(/\s+/);
+                const name = parts[0];
+                return {
+                    name: isRemote ? name.split("/").slice(2).join("/") : name,
+                    isCurrent,
+                    isRemote,
+                    commitHash: parts[1],
+                    commitSubject: parts.slice(2).join(" "),
+                };
+            });
             return {
-                success: false,
-                mode: "create",
-                message: `Failed to create branch: Branch '${input.branchName}' already exists. Use force=true to overwrite.`,
-                error: errorMessage,
+                success: true,
+                mode: params.mode,
+                message: `Found ${branches.length} branches.`,
+                branches,
+                currentBranch: branches.find(b => b.isCurrent)?.name || null,
             };
         }
-        if (input.mode === "delete" && errorMessage.includes("not found")) {
+        if (params.mode === "show-current") {
+            const currentBranchName = stdout.trim() || null;
             return {
-                success: false,
-                mode: "delete",
-                message: `Failed to delete branch: Branch '${input.branchName}' not found.`,
-                error: errorMessage,
+                success: true,
+                mode: params.mode,
+                message: currentBranchName ? `Current branch is '${currentBranchName}'.` : "Currently in detached HEAD state.",
+                currentBranch: currentBranchName,
             };
         }
-        if (input.mode === "delete" && errorMessage.includes("not fully merged")) {
-            return {
-                success: false,
-                mode: "delete",
-                message: `Failed to delete branch: Branch '${input.branchName}' is not fully merged. Use force=true to delete.`,
-                error: errorMessage,
-            };
+        return {
+            success: true,
+            mode: params.mode,
+            message: `Operation '${params.mode}' on branch '${params.branchName || params.newBranchName}' completed successfully.`,
+        };
+    }
+    catch (error) {
+        const errorMessage = error.stderr || error.stdout || error.message || "";
+        logger.error(`Failed to execute git branch 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}`);
         }
-        if (input.mode === "rename" && errorMessage.includes("already exists")) {
-            return {
-                success: false,
-                mode: "rename",
-                message: `Failed to rename branch: Branch '${input.newBranchName}' already exists. Use force=true to overwrite.`,
-                error: errorMessage,
-            };
+        // For specific, non-critical failures, we can throw a specific error code that the handler can interpret.
+        if (params.mode === "create" && errorMessage.includes("already exists")) {
+            throw new McpError(BaseErrorCode.CONFLICT, `Branch '${params.branchName}' already exists. Use force=true to overwrite.`);
         }
-        if (input.mode === "rename" && errorMessage.includes("not found")) {
-            return {
-                success: false,
-                mode: "rename",
-                message: `Failed to rename branch: Branch '${input.branchName}' not found.`,
-                error: errorMessage,
-            };
+        if (params.mode === "delete" && errorMessage.includes("not found")) {
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Branch '${params.branchName}' not found.`);
         }
-        // Throw a generic McpError for other failures
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git branch ${input.mode} failed for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git branch ${params.mode} failed: ${errorMessage}`);
     }
 }