@cyanheads/git-mcp-server 2.1.7 → 2.2.0

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

@@ -1,78 +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 { GitBranchBaseSchema, gitBranchLogic, } from "./logic.js";
-let _getWorkingDirectory;
-let _getSessionId;
 /**
- * Initializes the state accessors needed by the git_branch 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_branch tool.
+ * @module src/mcp-server/tools/gitBranch/registration
  */
-export function initializeGitBranchStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_branch tool registration.");
-}
+import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { GitBranchBaseSchema, gitBranchLogic, GitBranchOutputSchema } from "./logic.js";
 const TOOL_NAME = "git_branch";
 const TOOL_DESCRIPTION = "Manages Git branches. Supports listing (local, remote, all), creating, deleting (with force), renaming (with force), and showing the current branch. Returns results as a JSON object.";
 /**
- * Registers the git_branch 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_branch 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 registerGitBranchTool = async (server) => {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_branch must be initialized before registration.");
-    }
+export const registerGitBranchTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitBranchTool";
     const context = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(async () => {
-        // Register using the BASE schema shape
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitBranchBaseSchema.shape, 
-        // SDK validates against the full GitBranchInputSchema 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 Branch",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitBranchBaseSchema.shape,
+        outputSchema: GitBranchOutputSchema.shape,
+        annotations: {
+            readOnlyHint: false, // Can be destructive (delete/rename)
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
+        });
+        try {
+            const sessionId = getSessionId(handlerContext);
+            const result = await gitBranchLogic(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 branchResult = await gitBranchLogic(toolInput, logicContext);
-                const resultContent = {
-                    type: "text",
-                    text: JSON.stringify(branchResult, null, 2), // Pretty-print JSON
-                    contentType: "application/json",
-                };
-                if (branchResult.success) {
-                    logger.info(`Tool ${TOOL_NAME} (mode: ${toolInput.mode}) executed successfully, returning JSON`, logicContext);
-                }
-                else {
-                    logger.warning(`Tool ${TOOL_NAME} (mode: ${toolInput.mode}) failed: ${branchResult.message}`, { ...logicContext, errorDetails: branchResult.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/gitCheckout/index.js

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

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

@@ -1,158 +1,83 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_checkout tool.
+ * @module src/mcp-server/tools/gitCheckout/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 input schema for the git_checkout tool using Zod
+// 1. DEFINE the Zod input schema.
 export const GitCheckoutInputSchema = 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."),
-    branchOrPath: z
-        .string()
-        .min(1)
-        .describe("The branch name (e.g., 'main'), commit hash, tag, or file path(s) (e.g., './src/file.ts') to checkout."),
-    newBranch: z
-        .string()
-        .optional()
-        .describe("Create a new branch named <new_branch> (e.g., 'feat/new-feature') and start it at <branchOrPath>."),
-    force: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("Force checkout even if there are uncommitted changes (use with caution, discards local changes)."),
-    // Add other relevant git checkout options as needed (e.g., --track, -b for new branch shorthand)
+    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."),
+    branchOrPath: z.string().min(1).describe("The branch, commit, tag, or file path to checkout."),
+    newBranch: z.string().optional().describe("Create a new branch with this name before checking out."),
+    force: z.boolean().default(false).describe("Force checkout, discarding local changes."),
+});
+// 2. DEFINE the Zod response schema.
+export const GitCheckoutOutputSchema = z.object({
+    success: z.boolean().describe("Indicates if the command was successful."),
+    message: z.string().describe("A summary message of the result."),
+    currentBranch: z.string().optional().describe("The name of the current branch after the operation."),
+    newBranchCreated: z.boolean().optional().describe("Indicates if a new branch was created."),
 });
 /**
- * Executes the 'git checkout' command and returns structured JSON output.
- * Handles switching branches, creating new branches, and restoring files.
- *
- * @param {GitCheckoutInput} input - The validated input object.
- * @param {RequestContext} context - The request context for logging and error handling.
- * @returns {Promise<GitCheckoutResult>} A promise that resolves with the structured checkout 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 checkoutGit(input, context) {
+export async function checkoutGit(params, context) {
     const operation = "checkoutGit";
-    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,
-        });
-    }
-    catch (error) {
-        logger.error("Path resolution or sanitization failed", {
-            ...context,
-            operation,
-            error,
-        });
-        if (error instanceof McpError)
-            throw error;
-        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path: ${error instanceof Error ? error.message : String(error)}`, { context, operation, originalError: error });
+    logger.debug(`Executing ${operation}`, { ...context, params });
+    const workingDir = context.getWorkingDirectory();
+    if (params.path === "." && !workingDir) {
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, "No session working directory set. Please specify a 'path' or use 'git_set_working_dir' first.");
     }
+    const targetPath = sanitization.sanitizePath(params.path === "." ? workingDir : params.path, { allowAbsolute: true }).sanitizedPath;
+    const args = ["-C", targetPath, "checkout"];
+    if (params.force)
+        args.push("--force");
+    if (params.newBranch)
+        args.push("-b", params.newBranch);
+    args.push(params.branchOrPath);
     try {
-        // Construct the git checkout command
-        const args = ["-C", targetPath, "checkout"];
-        if (input.force) {
-            args.push("--force");
-        }
-        if (input.newBranch) {
-            args.push("-b", input.newBranch);
-        }
-        args.push(input.branchOrPath); // Add the target branch/path
-        logger.debug(`Executing command: git ${args.join(" ")}`, {
-            ...context,
-            operation,
-        });
-        // Execute command. Checkout often uses stderr for status messages.
+        logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
         const { stdout, stderr } = await execFileAsync("git", args);
         const message = stderr.trim() || stdout.trim();
-        logger.debug(`Git checkout stdout: ${stdout}`, { ...context, operation });
-        if (stderr) {
-            logger.debug(`Git checkout stderr: ${stderr}`, { ...context, operation });
-        }
-        // Get the current branch name after the checkout operation
+        logger.info("git checkout executed successfully", { ...context, operation, message });
         let currentBranch;
         try {
-            const { stdout: branchStdout } = await execFileAsync("git", [
-                "-C",
-                targetPath,
-                "branch",
-                "--show-current",
-            ]);
+            const { stdout: branchStdout } = await execFileAsync("git", ["-C", targetPath, "branch", "--show-current"]);
             currentBranch = branchStdout.trim();
         }
-        catch (e) {
-            // This can fail in detached HEAD state, which is not an error for checkout
+        catch {
             currentBranch = "Detached HEAD";
         }
-        const result = {
+        return {
             success: true,
             message,
             currentBranch,
-            newBranchCreated: !!input.newBranch,
+            newBranchCreated: !!params.newBranch,
         };
-        logger.info("git checkout executed successfully", {
-            ...context,
-            operation,
-            path: targetPath,
-            result,
-        });
-        return result;
     }
     catch (error) {
-        logger.error(`Failed to execute git checkout command`, {
-            ...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
+        logger.error(`Failed to execute git checkout command`, { ...context, operation, errorMessage });
         if (errorMessage.toLowerCase().includes("not a git repository")) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`, { context, operation, originalError: error });
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`);
         }
-        if (errorMessage.match(/pathspec '.*?' did not match any file\(s\) known to git/)) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Branch or pathspec not found: ${input.branchOrPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+        if (errorMessage.match(/pathspec '.*?' did not match/)) {
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Branch or pathspec not found: ${params.branchOrPath}.`);
         }
         if (errorMessage.includes("already exists")) {
-            // e.g., trying -b with existing branch name
-            throw new McpError(BaseErrorCode.CONFLICT, `Cannot create new branch '${input.newBranch}': it already exists. Error: ${errorMessage}`, { context, operation, originalError: error });
+            throw new McpError(BaseErrorCode.CONFLICT, `Cannot create new branch '${params.newBranch}': it already exists.`);
         }
-        if (errorMessage.includes("Your local changes to the following files would be overwritten by checkout")) {
-            throw new McpError(BaseErrorCode.CONFLICT, `Checkout failed due to uncommitted local changes that would be overwritten. Please commit or stash them first, or use --force. Error: ${errorMessage}`, { context, operation, originalError: error });
+        if (errorMessage.includes("overwritten by checkout")) {
+            throw new McpError(BaseErrorCode.CONFLICT, "Checkout failed due to uncommitted local changes. Stash or commit them, or use --force.");
         }
         if (errorMessage.includes("invalid reference")) {
-            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid branch name or reference: ${input.branchOrPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid branch name or reference: ${params.branchOrPath}.`);
         }
-        // Generic internal error for other failures
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to checkout for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git checkout failed: ${errorMessage}`);
     }
 }

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

@@ -1,83 +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 { checkoutGit, GitCheckoutInputSchema, } 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_checkout tool.
+ * @module src/mcp-server/tools/gitCheckout/registration
  */
-export function initializeGitCheckoutStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_checkout tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
+import { checkoutGit, GitCheckoutInputSchema, GitCheckoutOutputSchema, } from "./logic.js";
 const TOOL_NAME = "git_checkout";
 const TOOL_DESCRIPTION = "Switches branches or restores working tree files. Can checkout branches, commits, tags, or specific file paths. Supports creating new branches and forcing checkout.";
 /**
- * Registers the git_checkout tool with the MCP server.
- *
- * @param {McpServer} server - The MCP server instance.
- * @throws {Error} If state accessors are not initialized.
+ * Registers the git_checkout 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 registerGitCheckoutTool(server) {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_checkout must be initialized before registration.");
-    }
+export const registerGitCheckoutTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitCheckoutTool";
     const context = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(async () => {
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitCheckoutInputSchema.shape, // Provide the Zod schema shape
-        async (validatedArgs, callContext) => {
-            const toolOperation = "tool:git_checkout";
-            const requestContext = requestContextService.createRequestContext({
-                operation: toolOperation,
-                parentContext: callContext,
+    server.registerTool(TOOL_NAME, {
+        title: "Git Checkout",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitCheckoutInputSchema.shape,
+        outputSchema: GitCheckoutOutputSchema.shape,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true, // Can discard local changes with --force
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
+        });
+        try {
+            const sessionId = getSessionId(handlerContext);
+            const result = await checkoutGit(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 checkoutResult = await checkoutGit(validatedArgs, logicContext);
-                // Format the result as a JSON string within TextContent
-                const resultContent = {
-                    type: "text",
-                    text: JSON.stringify(checkoutResult, null, 2), // Pretty-print JSON
-                    contentType: "application/json",
-                };
-                // Log based on the success flag in the result
-                if (checkoutResult.success) {
-                    logger.info(`Tool ${TOOL_NAME} executed successfully: ${checkoutResult.message}`, logicContext);
-                }
-                else {
-                    // Log non-fatal conditions like conflicts differently if needed
-                    logger.info(`Tool ${TOOL_NAME} completed with status: ${checkoutResult.message}`, logicContext);
-                }
-                // Even if success is false (e.g., due to conflicts reported by logic),
-                // it's not a tool execution error unless the logic threw an McpError.
-                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 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/gitCherryPick/index.js

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