@cyanheads/git-mcp-server 2.1.8 → 2.2.1

package/README.md

@@ -1,8 +1,8 @@
 # Git MCP Server
 
 [![TypeScript](https://img.shields.io/badge/TypeScript-^5.8.3-blue.svg)](https://www.typescriptlang.org/)
-[![Model Context Protocol](https://img.shields.io/badge/MCP%20SDK-^1.13.2-green.svg)](https://modelcontextprotocol.io/)
-[![Version](https://img.shields.io/badge/Version-2.1.8-blue.svg)](./CHANGELOG.md)
+[![Model Context Protocol](https://img.shields.io/badge/MCP%20SDK-^1.15.1-green.svg)](https://modelcontextprotocol.io/)
+[![Version](https://img.shields.io/badge/Version-2.2.0-blue.svg)](./CHANGELOG.md)
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![Status](https://img.shields.io/badge/Status-Stable-green.svg)](https://github.com/cyanheads/git-mcp-server/issues)
 [![GitHub](https://img.shields.io/github/stars/cyanheads/git-mcp-server?style=social)](https://github.com/cyanheads/git-mcp-server)
@@ -203,9 +203,9 @@ _Note: The `path` parameter for most tools defaults to the session's working dir
 
 ## Resources
 
-**MCP Resources are not implemented in this version (v2.1.4).**
+**MCP Resources are not implemented in this version (v2.2.0).**
 
-This version focuses on the refactored Git tools implementation based on the latest `mcp-ts-template` and MCP SDK v1.13.0. Resource capabilities, previously available, have been temporarily removed during this major update.
+This version focuses on the refactored Git tools implementation based on the latest `mcp-ts-template` and MCP SDK v1.15.1. Resource capabilities, previously available, have been temporarily removed during this major update.
 
 If you require MCP Resource access (e.g., for reading file content directly via the server), please use the stable **[v1.2.4 release](https://github.com/cyanheads/git-mcp-server/releases/tag/v1.2.4)**.
 

package/dist/mcp-server/server.js

@@ -6,313 +6,154 @@
  * 3. Selects and starts the appropriate communication transport (stdio or Streamable HTTP)
  *    based on configuration.
  * 4. Handles top-level error management during startup.
- *
- * MCP Specification References:
- * - Lifecycle: https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/lifecycle.mdx
- * - Overview (Capabilities): https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/index.mdx
- * - Transports: https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/transports.mdx
  */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-// Import validated configuration and environment details.
 import { config, environment } from "../config/index.js";
-// Import core utilities: ErrorHandler, logger, requestContextService.
-import { ErrorHandler, logger, requestContextService, } from "../utils/index.js"; // Added RequestContext
-// Import registration AND state initialization functions for ALL Git tools (alphabetized)
-import { initializeGitAddStateAccessors, registerGitAddTool, } from "./tools/gitAdd/index.js";
-import { initializeGitBranchStateAccessors, registerGitBranchTool, } from "./tools/gitBranch/index.js";
-import { initializeGitCheckoutStateAccessors, registerGitCheckoutTool, } from "./tools/gitCheckout/index.js";
-import { initializeGitCherryPickStateAccessors, registerGitCherryPickTool, } from "./tools/gitCherryPick/index.js";
-import { initializeGitCleanStateAccessors, registerGitCleanTool, } from "./tools/gitClean/index.js";
-import { initializeGitClearWorkingDirStateAccessors, registerGitClearWorkingDirTool, } from "./tools/gitClearWorkingDir/index.js";
-import { registerGitCloneTool } from "./tools/gitClone/index.js"; // No initializer needed/available
-import { initializeGitCommitStateAccessors, registerGitCommitTool, } from "./tools/gitCommit/index.js";
-import { initializeGitDiffStateAccessors, registerGitDiffTool, } from "./tools/gitDiff/index.js";
-import { initializeGitFetchStateAccessors, registerGitFetchTool, } from "./tools/gitFetch/index.js";
-import { initializeGitInitStateAccessors, registerGitInitTool, } from "./tools/gitInit/index.js";
-import { initializeGitLogStateAccessors, registerGitLogTool, } from "./tools/gitLog/index.js";
-import { initializeGitMergeStateAccessors, registerGitMergeTool, } from "./tools/gitMerge/index.js";
-import { initializeGitPullStateAccessors, registerGitPullTool, } from "./tools/gitPull/index.js";
-import { initializeGitPushStateAccessors, registerGitPushTool, } from "./tools/gitPush/index.js";
-import { initializeGitRebaseStateAccessors, registerGitRebaseTool, } from "./tools/gitRebase/index.js";
-import { initializeGitRemoteStateAccessors, registerGitRemoteTool, } from "./tools/gitRemote/index.js";
-import { initializeGitResetStateAccessors, registerGitResetTool, } from "./tools/gitReset/index.js";
-import { initializeGitSetWorkingDirStateAccessors, registerGitSetWorkingDirTool, } from "./tools/gitSetWorkingDir/index.js";
-import { initializeGitShowStateAccessors, registerGitShowTool, } from "./tools/gitShow/index.js";
-import { initializeGitStashStateAccessors, registerGitStashTool, } from "./tools/gitStash/index.js";
-import { initializeGitStatusStateAccessors, registerGitStatusTool, } from "./tools/gitStatus/index.js";
-import { initializeGitTagStateAccessors, registerGitTagTool, } from "./tools/gitTag/index.js";
-import { initializeGitWorktreeStateAccessors, registerGitWorktreeTool, } from "./tools/gitWorktree/index.js";
-import { initializeGitWrapupInstructionsStateAccessors, registerGitWrapupInstructionsTool, } from "./tools/gitWrapupInstructions/index.js";
+import { ErrorHandler, logger, requestContextService } from "../utils/index.js";
+// Import registration functions for ALL Git tools (alphabetized)
+import { registerGitAddTool } from "./tools/gitAdd/index.js";
+import { registerGitBranchTool } from "./tools/gitBranch/index.js";
+import { registerGitCheckoutTool } from "./tools/gitCheckout/index.js";
+import { registerGitCherryPickTool } from "./tools/gitCherryPick/index.js";
+import { registerGitCleanTool } from "./tools/gitClean/index.js";
+import { registerGitClearWorkingDirTool } from "./tools/gitClearWorkingDir/index.js";
+import { registerGitCloneTool } from "./tools/gitClone/index.js";
+import { registerGitCommitTool } from "./tools/gitCommit/index.js";
+import { registerGitDiffTool } from "./tools/gitDiff/index.js";
+import { registerGitFetchTool } from "./tools/gitFetch/index.js";
+import { registerGitInitTool } from "./tools/gitInit/index.js";
+import { registerGitLogTool } from "./tools/gitLog/index.js";
+import { registerGitMergeTool } from "./tools/gitMerge/index.js";
+import { registerGitPullTool } from "./tools/gitPull/index.js";
+import { registerGitPushTool } from "./tools/gitPush/index.js";
+import { registerGitRebaseTool } from "./tools/gitRebase/index.js";
+import { registerGitRemoteTool } from "./tools/gitRemote/index.js";
+import { registerGitResetTool } from "./tools/gitReset/index.js";
+import { registerGitSetWorkingDirTool } from "./tools/gitSetWorkingDir/index.js";
+import { registerGitShowTool } from "./tools/gitShow/index.js";
+import { registerGitStashTool } from "./tools/gitStash/index.js";
+import { registerGitStatusTool } from "./tools/gitStatus/index.js";
+import { registerGitTagTool } from "./tools/gitTag/index.js";
+import { registerGitWorktreeTool } from "./tools/gitWorktree/index.js";
+import { registerGitWrapupInstructionsTool } from "./tools/gitWrapupInstructions/index.js";
 // Import transport setup functions
 import { startHttpTransport } from "./transports/httpTransport.js";
 import { connectStdioTransport } from "./transports/stdioTransport.js";
-/**
- * Creates and configures a new instance of the McpServer.
- *
- * This function is central to defining the server's identity and functionality
- * as presented to connecting clients during the MCP initialization phase.
- *
- * MCP Spec Relevance:
- * - Server Identity (`serverInfo`): The `name` and `version` provided here are part
- *   of the `ServerInformation` object returned in the `InitializeResult` message,
- *   allowing clients to identify the server they are connected to.
- * - Capabilities Declaration: The `capabilities` object declares the features this
- *   server supports, enabling clients to tailor their interactions.
- *   - `logging: {}`: Indicates the server can receive `logging/setLevel` requests
- *     and may send `notifications/message` log messages (handled by the logger utility).
- *   - `resources: { listChanged: true }`: Signals that the server supports dynamic
- *     resource lists and will send `notifications/resources/list_changed` if the
- *     available resources change after initialization. (Currently no resources registered)
- *   - `tools: { listChanged: true }`: Signals support for dynamic tool lists and
- *     `notifications/tools/list_changed`.
- * - Resource/Tool Registration: This function calls specific registration functions
- *   (e.g., `registerGitAdd`) which use SDK methods (`server.resource`, `server.tool`)
- *   to make capabilities available for discovery (`resources/list`, `tools/list`) and
- *   invocation (`resources/read`, `tools/call`).
- *
- * Design Note: This factory function is used to create server instances. For the 'stdio'
- * transport, it's called once. For the 'http' transport, it's passed to `startHttpTransport`
- * and called *per session* to ensure session isolation.
- *
- * @returns {Promise<McpServer>} A promise resolving with the configured McpServer instance.
- * @throws {Error} If any resource or tool registration fails.
- */
-// Removed sessionId parameter, it will be retrieved from context within tool handlers
 async function createMcpServerInstance() {
     const context = requestContextService.createRequestContext({
         operation: "createMcpServerInstance",
     });
     logger.info("Initializing MCP server instance", context);
-    // Configure the request context service (used for correlating logs/errors).
     requestContextService.configure({
         appName: config.mcpServerName,
         appVersion: config.mcpServerVersion,
         environment,
     });
-    // Instantiate the core McpServer using the SDK.
-    // Provide server identity (name, version) and declare supported capabilities.
-    // Note: Resources capability declared, but none are registered currently.
-    logger.debug("Instantiating McpServer with capabilities", {
-        ...context,
-        serverInfo: {
-            name: config.mcpServerName,
-            version: config.mcpServerVersion,
-        },
+    const server = new McpServer({ name: config.mcpServerName, version: config.mcpServerVersion }, {
         capabilities: {
             logging: {},
             resources: { listChanged: true },
             tools: { listChanged: true },
         },
     });
-    const server = new McpServer({ name: config.mcpServerName, version: config.mcpServerVersion }, // ServerInformation part of InitializeResult
-    {
-        capabilities: {
-            logging: {},
-            resources: { listChanged: true },
-            tools: { listChanged: true },
-        },
-    });
-    // Each server instance is isolated per session. This variable will hold the
-    // working directory for the duration of this session.
-    let sessionWorkingDirectory = undefined;
-    // --- Define Unified State Accessor Functions ---
-    // These functions abstract away the transport type to get/set session state.
-    /** Gets the session ID from the tool's execution context. */
+    const sessionWorkingDirectories = new Map();
+    const STDIO_SESSION_ID = "stdio_session"; // Constant for single-session transports
     const getSessionIdFromContext = (toolContext) => {
-        // The RequestContext created by the tool registration wrapper should contain the sessionId.
         return toolContext?.sessionId;
     };
-    /** Gets the working directory for the current session. */
     const getWorkingDirectory = (sessionId) => {
-        // The working directory is now stored in a variable scoped to this server instance.
-        // The sessionId is kept for potential logging or more complex future state management.
-        return sessionWorkingDirectory;
+        const id = sessionId ?? STDIO_SESSION_ID;
+        return sessionWorkingDirectories.get(id);
     };
-    /** Sets the working directory for the current session. */
     const setWorkingDirectory = (sessionId, dir) => {
-        // The working directory is now stored in a variable scoped to this server instance.
-        logger.debug("Setting session working directory", {
-            ...context,
-            sessionId,
-            newDirectory: dir,
-        });
-        sessionWorkingDirectory = dir;
+        const id = sessionId ?? STDIO_SESSION_ID;
+        logger.debug("Setting session working directory", { ...context, sessionId: id, newDirectory: dir });
+        sessionWorkingDirectories.set(id, dir);
+    };
+    const clearWorkingDirectory = (sessionId) => {
+        const id = sessionId ?? STDIO_SESSION_ID;
+        logger.debug("Clearing session working directory", { ...context, sessionId: id });
+        sessionWorkingDirectories.delete(id);
     };
-    // --- Initialize Tool State Accessors BEFORE Registration ---
-    // Pass the defined unified accessor functions to the initializers.
-    logger.debug("Initializing state accessors for tools...", context);
-    try {
-        // Call initializers for all tools that likely need state access (alphabetized).
-        // If an initializer doesn't exist, the import would have failed earlier (or build will fail).
-        initializeGitAddStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        initializeGitBranchStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        initializeGitCheckoutStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        initializeGitCherryPickStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        initializeGitCleanStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        initializeGitClearWorkingDirStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        // initializeGitCloneStateAccessors - No initializer needed/available
-        initializeGitCommitStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        initializeGitDiffStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        initializeGitFetchStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        initializeGitInitStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        initializeGitLogStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        initializeGitMergeStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        initializeGitPullStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        initializeGitPushStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        initializeGitRebaseStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        initializeGitRemoteStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        initializeGitResetStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        initializeGitSetWorkingDirStateAccessors(getWorkingDirectory, setWorkingDirectory, getSessionIdFromContext); // Special case
-        initializeGitShowStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        initializeGitStashStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        initializeGitStatusStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        initializeGitTagStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        initializeGitWorktreeStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        initializeGitWrapupInstructionsStateAccessors(getWorkingDirectory, getSessionIdFromContext); // Added this line
-        logger.debug("State accessors initialized successfully.", context);
-    }
-    catch (initError) {
-        // Catch errors specifically during initialization phase
-        logger.error("Failed during state accessor initialization", {
-            ...context,
-            error: initError instanceof Error ? initError.message : String(initError),
-            stack: initError instanceof Error ? initError.stack : undefined,
-        });
-        throw initError; // Re-throw to prevent server starting incorrectly
-    }
     try {
-        // Register all defined Git tools (alphabetized). These calls populate the server's
-        // internal registry, making them available via MCP methods like 'tools/list'.
         logger.debug("Registering Git tools...", context);
-        await registerGitAddTool(server);
-        await registerGitBranchTool(server);
-        await registerGitCheckoutTool(server);
-        await registerGitCherryPickTool(server);
-        await registerGitCleanTool(server);
-        await registerGitClearWorkingDirTool(server);
-        await registerGitCloneTool(server);
-        await registerGitCommitTool(server);
-        await registerGitDiffTool(server);
-        await registerGitFetchTool(server);
-        await registerGitInitTool(server);
-        await registerGitLogTool(server);
-        await registerGitMergeTool(server);
-        await registerGitPullTool(server);
-        await registerGitPushTool(server);
-        await registerGitRebaseTool(server);
-        await registerGitRemoteTool(server);
-        await registerGitResetTool(server);
-        await registerGitSetWorkingDirTool(server);
-        await registerGitShowTool(server);
-        await registerGitStashTool(server);
-        await registerGitStatusTool(server);
-        await registerGitTagTool(server);
-        await registerGitWorktreeTool(server);
-        await registerGitWrapupInstructionsTool(server);
-        // Add calls to register other resources/tools here if needed in the future.
+        await registerGitAddTool(server, getWorkingDirectory, getSessionIdFromContext);
+        await registerGitBranchTool(server, getWorkingDirectory, getSessionIdFromContext);
+        await registerGitCheckoutTool(server, getWorkingDirectory, getSessionIdFromContext);
+        await registerGitCherryPickTool(server, getWorkingDirectory, getSessionIdFromContext);
+        await registerGitCleanTool(server, getWorkingDirectory, getSessionIdFromContext);
+        await registerGitClearWorkingDirTool(server, clearWorkingDirectory, getSessionIdFromContext);
+        await registerGitCloneTool(server, getSessionIdFromContext);
+        await registerGitCommitTool(server, getWorkingDirectory, getSessionIdFromContext);
+        await registerGitDiffTool(server, getWorkingDirectory, getSessionIdFromContext);
+        await registerGitFetchTool(server, getWorkingDirectory, getSessionIdFromContext);
+        await registerGitInitTool(server, getSessionIdFromContext);
+        await registerGitLogTool(server, getWorkingDirectory, getSessionIdFromContext);
+        await registerGitMergeTool(server, getWorkingDirectory, getSessionIdFromContext);
+        await registerGitPullTool(server, getWorkingDirectory, getSessionIdFromContext);
+        await registerGitPushTool(server, getWorkingDirectory, getSessionIdFromContext);
+        await registerGitRebaseTool(server, getWorkingDirectory, getSessionIdFromContext);
+        await registerGitRemoteTool(server, getWorkingDirectory, getSessionIdFromContext);
+        await registerGitResetTool(server, getWorkingDirectory, getSessionIdFromContext);
+        await registerGitSetWorkingDirTool(server, setWorkingDirectory, getSessionIdFromContext);
+        await registerGitShowTool(server, getWorkingDirectory, getSessionIdFromContext);
+        await registerGitStashTool(server, getWorkingDirectory, getSessionIdFromContext);
+        await registerGitStatusTool(server, getWorkingDirectory, getSessionIdFromContext);
+        await registerGitTagTool(server, getWorkingDirectory, getSessionIdFromContext);
+        await registerGitWorktreeTool(server, getWorkingDirectory, getSessionIdFromContext);
+        await registerGitWrapupInstructionsTool(server, getWorkingDirectory, getSessionIdFromContext);
         logger.info("Git tools registered successfully", context);
     }
     catch (err) {
-        // Registration is critical; log and re-throw errors.
         logger.error("Failed to register resources/tools", {
             ...context,
             error: err instanceof Error ? err.message : String(err),
-            stack: err instanceof Error ? err.stack : undefined, // Include stack for debugging
+            stack: err instanceof Error ? err.stack : undefined,
         });
-        throw err; // Propagate error to prevent server starting with incomplete capabilities.
+        throw err;
     }
     return server;
 }
-/**
- * Selects, sets up, and starts the appropriate MCP transport layer based on configuration.
- * This function acts as the bridge between the core server logic and the communication channel.
- *
- * MCP Spec Relevance:
- * - Transport Selection: Reads `config.mcpTransportType` ('stdio' or 'http') to determine
- *   which transport mechanism defined in the MCP specification to use.
- * - Transport Connection: Calls dedicated functions (`connectStdioTransport` or `startHttpTransport`)
- *   which handle the specifics of establishing communication according to the chosen
- *   transport's rules (e.g., stdin/stdout handling for 'stdio', HTTP server setup and
- *   endpoint handling for 'http').
- * - Server Instance Lifecycle:
- *   - For 'stdio', creates a single `McpServer` instance for the lifetime of the process.
- *   - For 'http', passes the `createMcpServerInstance` factory function to `startHttpTransport`,
- *     allowing the HTTP transport to create a new, isolated server instance for each client session,
- *     aligning with the stateful session management described in the Streamable HTTP spec.
- *
- * @returns {Promise<McpServer | void>} Resolves with the McpServer instance for 'stdio', or void for 'http'.
- * @throws {Error} If the configured transport type is unsupported or if transport setup fails.
- */
 async function startTransport() {
-    // Determine the transport type from the validated configuration.
     const transportType = config.mcpTransportType;
     const context = requestContextService.createRequestContext({
         operation: "startTransport",
         transport: transportType,
     });
     logger.info(`Starting transport: ${transportType}`, context);
-    // --- HTTP Transport Setup ---
+    const server = await createMcpServerInstance();
     if (transportType === "http") {
-        logger.debug("Delegating to startHttpTransport...", context);
-        // For HTTP, the transport layer manages its own lifecycle and potentially multiple sessions.
-        // We pass the factory function to allow the HTTP transport to create server instances as needed (per session).
-        await startHttpTransport(createMcpServerInstance, context);
-        // The HTTP server runs indefinitely, listening for connections, so this function returns void.
+        await startHttpTransport(server, context);
         return;
     }
-    // --- Stdio Transport Setup ---
     if (transportType === "stdio") {
-        logger.debug("Creating single McpServer instance for stdio transport...", context);
-        // For stdio, there's typically one persistent connection managed by a parent process.
-        // Create a single McpServer instance for the entire process lifetime.
-        const server = await createMcpServerInstance();
-        logger.debug("Delegating to connectStdioTransport...", context);
-        // Connect the server instance to the stdio transport handler.
         await connectStdioTransport(server, context);
-        // Return the server instance; the caller (main entry point) might hold onto it.
         return server;
     }
-    // --- Unsupported Transport ---
-    // This case should theoretically not be reached due to config validation, but acts as a safeguard.
     logger.fatal(`Unsupported transport type configured: ${transportType}`, context);
     throw new Error(`Unsupported transport type: ${transportType}. Must be 'stdio' or 'http'.`);
 }
-/**
- * Main application entry point. Initializes and starts the MCP server.
- *
- * MCP Spec Relevance:
- * - Orchestrates the server startup sequence, culminating in a server ready to accept
- *   connections and process MCP messages according to the chosen transport's rules.
- * - Implements top-level error handling for critical startup failures, ensuring the
- *   process exits appropriately if it cannot initialize correctly.
- *
- * @returns {Promise<void | McpServer>} Resolves upon successful startup (void for http, McpServer for stdio). Rejects on critical failure.
- */
 export async function initializeAndStartServer() {
     const context = requestContextService.createRequestContext({
         operation: "initializeAndStartServer",
     });
     logger.info("MCP Server initialization sequence started.", context);
     try {
-        // Initiate the transport setup based on configuration.
         const result = await startTransport();
         logger.info("MCP Server initialization sequence completed successfully.", context);
         return result;
     }
     catch (err) {
-        // Catch any errors that occurred during server instance creation or transport setup.
         logger.fatal("Critical error during MCP server initialization.", {
             ...context,
             error: err instanceof Error ? err.message : String(err),
             stack: err instanceof Error ? err.stack : undefined,
         });
-        // Use the centralized error handler for consistent critical error reporting.
         ErrorHandler.handleError(err, {
             ...context,
             operation: "initializeAndStartServer_Catch",
             critical: true,
         });
-        // Exit the process with a non-zero code to indicate failure.
         logger.info("Exiting process due to critical initialization error.", context);
         process.exit(1);
     }

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

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

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

@@ -1,14 +1,9 @@
+import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
 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";
 const execFileAsync = promisify(execFile);
-// Define the input schema for the git_add tool using Zod
 export const GitAddInputSchema = z.object({
     path: z
         .string()
@@ -21,121 +16,50 @@ export const GitAddInputSchema = z.object({
         .default(".")
         .describe("Files or patterns to stage, defaults to all changes ('.')"),
 });
-/**
- * Executes the 'git add' command and returns structured JSON output.
- *
- * @param {GitAddInput} input - The validated input object.
- * @param {RequestContext} context - The request context for logging and error handling.
- * @returns {Promise<GitAddResult>} A promise that resolves with the structured add result.
- * @throws {McpError} Throws an McpError if path resolution or validation fails, or if the git command fails unexpectedly.
- */
-export async function addGitFiles(input, context) {
+export const GitAddOutputSchema = z.object({
+    success: z.boolean().describe("Indicates whether the operation was successful."),
+    statusMessage: z.string().describe("A message describing the result of the operation."),
+    filesStaged: z.union([z.string(), z.array(z.string())]).describe("The files or patterns that were staged."),
+});
+export async function addGitFiles(params, context) {
     const operation = "addGitFiles";
-    logger.debug(`Executing ${operation}`, { ...context, input });
-    let targetPath;
-    try {
-        // Resolve the target path
-        if (input.path && input.path !== ".") {
-            targetPath = input.path;
-            logger.debug(`Using provided path: ${targetPath}`, {
-                ...context,
-                operation,
-            });
-        }
-        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;
-            logger.debug(`Using session working directory: ${targetPath}`, {
-                ...context,
-                operation,
-                sessionId: context.sessionId,
-            });
-        }
-        // Sanitize the resolved path
-        const sanitizedPathInfo = sanitization.sanitizePath(targetPath, {
-            allowAbsolute: true,
-        });
-        logger.debug("Sanitized repository path", {
-            ...context,
-            operation,
-            sanitizedPathInfo,
-        });
-        targetPath = sanitizedPathInfo.sanitizedPath; // Use the sanitized path going forward
-    }
-    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 filesToStage = Array.isArray(input.files) ? input.files : [input.files];
+    const targetPath = sanitization.sanitizePath(params.path === "." ? workingDir : params.path, { allowAbsolute: true }).sanitizedPath;
+    const filesToStage = Array.isArray(params.files) ? params.files : [params.files];
     if (filesToStage.length === 0) {
-        filesToStage.push("."); // Default to staging all if array is empty
-    }
-    try {
-        const args = ["-C", targetPath, "add", "--"];
-        filesToStage.forEach((file) => {
-            // Sanitize each file path. Although execFile is safer,
-            // this prevents arguments like "-v" from being treated as flags by git.
-            const sanitizedFile = file.startsWith("-") ? `./${file}` : file;
-            args.push(sanitizedFile);
-        });
-        logger.debug(`Executing command: git ${args.join(" ")}`, {
-            ...context,
-            operation,
-        });
-        const { stdout, stderr } = await execFileAsync("git", args);
-        if (stderr) {
-            // Log stderr as warning, as 'git add' can produce warnings but still succeed.
-            logger.warning(`Git add command produced stderr`, {
-                ...context,
-                operation,
-                stderr,
-            });
-        }
-        const filesAddedDesc = Array.isArray(filesToStage)
-            ? filesToStage.join(", ")
-            : filesToStage;
-        const successMessage = `Successfully staged: ${filesAddedDesc}`;
-        logger.info(successMessage, {
-            ...context,
-            operation,
-            path: targetPath,
-            files: filesToStage,
-        });
-        const reminder = "Remember to write clear, concise commit messages using the Conventional Commits format (e.g., 'feat(scope): subject').";
-        // Use statusMessage and add reminder
-        return {
-            success: true,
-            statusMessage: `${successMessage}. ${reminder}`,
-            filesStaged: filesToStage,
-        };
+        filesToStage.push(".");
     }
-    catch (error) {
-        logger.error(`Failed to execute git add command`, {
+    const args = ["-C", targetPath, "add", "--", ...filesToStage.map(file => file.startsWith("-") ? `./${file}` : file)];
+    logger.debug(`Executing command: git ${args.join(" ")}`, {
+        ...context,
+        operation,
+    });
+    const { stderr } = await execFileAsync("git", args);
+    if (stderr) {
+        logger.warning(`Git add command produced stderr`, {
             ...context,
             operation,
-            path: targetPath,
-            error: error.message,
-            stderr: error.stderr,
+            stderr,
         });
-        const errorMessage = error.stderr || error.message || "";
-        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.toLowerCase().includes("did not match any files")) {
-            // Still throw an error, but return structured info in the catch block of the registration
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Specified files/patterns did not match any files in ${targetPath}: ${filesToStage.join(", ")}`, { context, operation, originalError: error, filesStaged: filesToStage });
-        }
-        // Throw generic error for other cases
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to stage files for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error, filesStaged: filesToStage });
     }
+    const filesAddedDesc = Array.isArray(filesToStage)
+        ? filesToStage.join(", ")
+        : filesToStage;
+    const successMessage = `Successfully staged: ${filesAddedDesc}`;
+    logger.info(successMessage, {
+        ...context,
+        operation,
+        path: targetPath,
+        files: filesToStage,
+    });
+    const reminder = "Remember to write clear, concise commit messages using the Conventional Commits format (e.g., 'feat(scope): subject').";
+    return {
+        success: true,
+        statusMessage: `${successMessage}. ${reminder}`,
+        filesStaged: filesToStage,
+    };
 }