@cyanheads/git-mcp-server 2.1.7 → 2.2.0

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

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

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

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

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