@cyanheads/git-mcp-server 2.1.8 → 2.2.1

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

@@ -1,71 +1,64 @@
-import { BaseErrorCode } from "../../../types-global/errors.js"; // Direct import for types-global
-import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js"; // ErrorHandler (./utils/internal/errorHandler.js), logger (./utils/internal/logger.js), requestContextService & RequestContext (./utils/internal/requestContext.js)
-import { GitResetInputSchema, resetGitState, } 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_reset tool.
+ * @module src/mcp-server/tools/gitReset/registration
  */
-export function initializeGitResetStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_reset tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { resetGitState, GitResetInputSchema, GitResetOutputSchema, } from "./logic.js";
 const TOOL_NAME = "git_reset";
 const TOOL_DESCRIPTION = "Resets the current HEAD to a specified state. Supports different modes ('soft', 'mixed', 'hard', 'merge', 'keep') to control how the index and working tree are affected. Can reset to a specific commit. USE 'hard' MODE WITH EXTREME CAUTION as it discards local changes.";
 /**
- * Registers the git_reset tool with the MCP server.
- *
- * @param {McpServer} server - The MCP server instance.
- * @throws {Error} If state accessors are not initialized.
+ * Registers the git_reset 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 registerGitResetTool(server) {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_reset must be initialized before registration.");
-    }
+export const registerGitResetTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitResetTool";
     const context = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(async () => {
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitResetInputSchema.shape, // Provide the Zod schema shape
-        async (validatedArgs, callContext) => {
-            const toolOperation = "tool:git_reset";
-            const requestContext = requestContextService.createRequestContext({
-                operation: toolOperation,
-                parentContext: callContext,
+    server.registerTool(TOOL_NAME, {
+        title: "Git Reset",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitResetInputSchema.shape,
+        outputSchema: GitResetOutputSchema.shape,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true, // Can be very destructive, especially in 'hard' mode
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
+        });
+        try {
+            const sessionId = getSessionId(handlerContext);
+            const result = await resetGitState(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 resetResult = await resetGitState(validatedArgs, logicContext);
-                // Format the result as a JSON string within TextContent
-                const resultContent = {
-                    type: "text",
-                    // Stringify the entire GitResetResult object
-                    text: JSON.stringify(resetResult, null, 2), // Pretty-print JSON
-                    contentType: "application/json",
-                };
-                logger.info(`Tool ${TOOL_NAME} executed successfully: ${resetResult.message}`, logicContext);
-                // Success is determined by the logic function and included in the result object
-                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 mcpError = ErrorHandler.handleError(error, {
+                operation: `tool:${TOOL_NAME}`,
+                context: handlerContext,
+                input: params,
             });
-        });
-        logger.info(`Tool registered: ${TOOL_NAME}`, context);
-    }, { operation, context, critical: true });
-}
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error: ${mcpError.message}` }],
+                structuredContent: {
+                    code: mcpError.code,
+                    message: mcpError.message,
+                    details: mcpError.details,
+                },
+            };
+        }
+    });
+    logger.info(`Tool '${TOOL_NAME}' registered successfully.`, context);
+};

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

@@ -1,7 +1,5 @@
 /**
- * @fileoverview Barrel file for the git_set_working_dir tool.
- * Exports the registration function and potentially other related components.
+ * @fileoverview Barrel file for the gitSetWorkingDir tool.
+ * @module src/mcp-server/tools/gitSetWorkingDir/index
  */
-export { registerGitSetWorkingDirTool, initializeGitSetWorkingDirStateAccessors, } from "./registration.js";
-// Export types if needed elsewhere, e.g.:
-// export type { GitSetWorkingDirInput, GitSetWorkingDirResult } from './logic.js';
+export { registerGitSetWorkingDirTool } from "./registration.js";

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

@@ -1,159 +1,54 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_set_working_dir tool.
+ * @module src/mcp-server/tools/gitSetWorkingDir/logic
+ */
 import { execFile } from "child_process";
 import fs from "fs/promises";
 import { promisify } from "util";
 import { z } from "zod";
-import { BaseErrorCode, McpError } from "../../../types-global/errors.js"; // Direct import for types-global
-import { logger, sanitization } from "../../../utils/index.js"; // RequestContext (./utils/internal/requestContext.js), logger (./utils/internal/logger.js), sanitization (./utils/security/sanitization.js)
+import { logger, sanitization } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
 const execFileAsync = promisify(execFile);
-// Define the Zod schema for input validation
+// 1. DEFINE the Zod input schema.
 export const GitSetWorkingDirInputSchema = z.object({
-    path: z
-        .string()
-        .min(1, "Path cannot be empty.")
-        .describe("The absolute path to set as the default working directory for the current session. Set this before using other git_* tools."),
-    validateGitRepo: z
-        .boolean()
-        .default(true)
-        .describe("Whether to validate that the path is a Git repository"),
-    initializeIfNotPresent: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("If true and the directory is not a Git repository, attempt to initialize it with 'git init'."),
+    path: z.string().min(1).describe("The absolute path to set as the default working directory."),
+    validateGitRepo: z.boolean().default(true).describe("Validate that the path is a Git repository."),
+    initializeIfNotPresent: z.boolean().default(false).describe("If not a Git repository, initialize it with 'git init'."),
 });
+// 2. DEFINE the Zod response schema.
+export const GitSetWorkingDirOutputSchema = z.object({
+    success: z.boolean().describe("Indicates if the command was successful."),
+    message: z.string().describe("A summary message of the result."),
+    path: z.string().describe("The path that was set as the working directory."),
+    initialized: z.boolean().describe("Indicates if a new repository was initialized."),
+});
+async function checkIsGitRepo(path) {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--is-inside-work-tree"], { cwd: path }).catch(() => ({ stdout: "false" }));
+    return stdout.trim() === "true";
+}
 /**
- * Logic for the git_set_working_dir tool.
- * Sets a global working directory path for the current session.
- * Validates the path and optionally checks if it's a Git repository.
- *
- * @param {GitSetWorkingDirInput} input - The validated input arguments.
- * @param {RequestContext} context - The request context, potentially containing session ID.
- * @returns {Promise<GitSetWorkingDirResult>} The result of the operation.
- * @throws {McpError} Throws McpError for validation failures or operational errors.
+ * 4. IMPLEMENT the core logic function.
+ * @throws {McpError} If the logic encounters an unrecoverable issue.
  */
-export async function gitSetWorkingDirLogic(input, context) {
+export async function gitSetWorkingDirLogic(params, context) {
     const operation = "gitSetWorkingDirLogic";
-    logger.debug(`Executing ${operation}`, { ...context, input });
-    let sanitizedPath;
-    try {
-        // Sanitize the path. Must explicitly allow absolute paths for this tool.
-        // It normalizes and checks for traversal issues.
-        sanitizedPath = sanitization.sanitizePath(input.path, {
-            allowAbsolute: true,
-        }).sanitizedPath;
-        logger.debug(`Sanitized path: ${sanitizedPath}`, { ...context, operation });
+    logger.debug(`Executing ${operation}`, { ...context, params });
+    const sanitizedPath = sanitization.sanitizePath(params.path, { allowAbsolute: true }).sanitizedPath;
+    const stats = await fs.stat(sanitizedPath);
+    if (!stats.isDirectory()) {
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Path is not a directory: ${sanitizedPath}`);
     }
-    catch (error) {
-        logger.error("Path sanitization failed", error, { ...context, operation });
-        if (error instanceof McpError)
-            throw error;
-        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path provided: ${error.message}`, { context, operation });
-    }
-    // Check if the directory exists
-    try {
-        const stats = await fs.stat(sanitizedPath);
-        if (!stats.isDirectory()) {
-            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Path is not a directory: ${sanitizedPath}`, { context, operation });
-        }
-    }
-    catch (error) {
-        if (error.code === "ENOENT") {
-            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Directory does not exist: ${sanitizedPath}`, { context, operation });
-        }
-        logger.error("Failed to stat directory", error, {
-            ...context,
-            operation,
-            path: sanitizedPath,
-        });
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to access path: ${error.message}`, { context, operation });
-    }
-    let isGitRepo = false;
+    let isGitRepo = await checkIsGitRepo(sanitizedPath);
     let initializedRepo = false;
-    try {
-        const { stdout } = await execFileAsync("git", ["rev-parse", "--is-inside-work-tree"], {
-            cwd: sanitizedPath,
-        });
-        if (stdout.trim() === "true") {
-            isGitRepo = true;
-            logger.debug("Path is already a Git repository", {
-                ...context,
-                operation,
-                path: sanitizedPath,
-            });
-        }
-    }
-    catch (error) {
-        logger.debug("Path is not a Git repository (rev-parse failed or returned non-true)", {
-            ...context,
-            operation,
-            path: sanitizedPath,
-            error: error.message,
-        });
-        isGitRepo = false;
-    }
-    if (!isGitRepo && input.initializeIfNotPresent) {
-        logger.info(`Path is not a Git repository. Attempting to initialize (initializeIfNotPresent=true) with initial branch 'main'.`, { ...context, operation, path: sanitizedPath });
-        try {
-            await execFileAsync("git", ["init", "--initial-branch=main"], {
-                cwd: sanitizedPath,
-            });
-            initializedRepo = true;
-            isGitRepo = true; // Now it is a git repo
-            logger.info('Successfully initialized Git repository with initial branch "main".', { ...context, operation, path: sanitizedPath });
-        }
-        catch (initError) {
-            logger.error("Failed to initialize Git repository", initError, {
-                ...context,
-                operation,
-                path: sanitizedPath,
-            });
-            throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to initialize Git repository at ${sanitizedPath}: ${initError.message}`, { context, operation });
-        }
-    }
-    // After potential initialization, if validateGitRepo is true, it must now be a Git repo.
-    if (input.validateGitRepo && !isGitRepo) {
-        logger.warning("Path is not a valid Git repository and initialization was not performed or failed.", { ...context, operation, path: sanitizedPath });
-        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Path is not a valid Git repository: ${sanitizedPath}.`, { context, operation });
-    }
-    // --- Update Session State ---
-    // This part needs access to the session state mechanism defined in server.ts
-    // We assume the context provides a way to set the working directory for the current session.
-    try {
-        context.setWorkingDirectory(sanitizedPath);
-        const message = `Working directory set for session ${context.sessionId || "stdio"} to: ${sanitizedPath}`;
-        logger.info(message, { ...context, operation });
-    }
-    catch (error) {
-        logger.error("Failed to set working directory in session state", error, {
-            ...context,
-            operation,
-        });
-        // This indicates an internal logic error in how state is passed/managed.
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, "Failed to update session state.", { context, operation });
-    }
-    let message = `Working directory set to: ${sanitizedPath}`;
-    if (initializedRepo) {
-        message += " (New Git repository initialized).";
-    }
-    else if (isGitRepo && input.validateGitRepo) {
-        // Only state "Existing" if validation was on and it passed
-        message += " (Existing Git repository).";
-    }
-    else if (isGitRepo && !input.validateGitRepo) {
-        // It is a git repo, but we weren't asked to validate it
-        message += " (Is a Git repository, validation skipped).";
+    if (!isGitRepo && params.initializeIfNotPresent) {
+        await execFileAsync("git", ["init", "--initial-branch=main"], { cwd: sanitizedPath });
+        initializedRepo = true;
+        isGitRepo = true;
     }
-    else if (!isGitRepo &&
-        !input.validateGitRepo &&
-        !input.initializeIfNotPresent) {
-        // Not a git repo, validation off, no init request
-        message +=
-            " (Not a Git repository, validation skipped, no initialization requested).";
+    if (params.validateGitRepo && !isGitRepo) {
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Path is not a valid Git repository: ${sanitizedPath}.`);
     }
-    return {
-        success: true,
-        message: message,
-        path: sanitizedPath,
-        initialized: initializedRepo,
-    };
+    context.setWorkingDirectory(sanitizedPath);
+    const message = `Working directory set to: ${sanitizedPath}${initializedRepo ? " (New repository initialized)." : ""}`;
+    return { success: true, message, path: sanitizedPath, initialized: initializedRepo };
 }

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

@@ -1,94 +1,64 @@
-import { BaseErrorCode } from "../../../types-global/errors.js"; // Direct import for types-global
-import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js"; // ErrorHandler (./utils/internal/errorHandler.js), logger (./utils/internal/logger.js), requestContextService & RequestContext (./utils/internal/requestContext.js)
-import { GitSetWorkingDirInputSchema, gitSetWorkingDirLogic, } from "./logic.js";
-let _getWorkingDirectory; // Added getter
-let _setWorkingDirectory;
-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 setWdFn - Function to set 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_set_working_dir tool.
+ * @module src/mcp-server/tools/gitSetWorkingDir/registration
  */
-export function initializeGitSetWorkingDirStateAccessors(getWdFn, // Added getter parameter
-setWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn; // Store getter
-    _setWorkingDirectory = setWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_set_working_dir tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { gitSetWorkingDirLogic, GitSetWorkingDirInputSchema, GitSetWorkingDirOutputSchema, } from "./logic.js";
 const TOOL_NAME = "git_set_working_dir";
 const TOOL_DESCRIPTION = "Sets the default working directory for the current session. Subsequent Git tool calls within this session can use '.' for the `path` parameter, which will resolve to this directory. Optionally validates if the path is a Git repository (`validateGitRepo: true`). Can optionally initialize a Git repository with 'git init' if it's not already one and `initializeIfNotPresent: true` is set. Returns the result as a JSON object. IMPORTANT: The provided path must be absolute.";
 /**
- * Registers the git_set_working_dir tool with the MCP server.
- *
- * @param {McpServer} server - The MCP server instance.
- * @throws {Error} If state accessors are not initialized.
+ * Registers the git_set_working_dir tool with the MCP server instance.
+ * @param server The MCP server instance.
+ * @param setWorkingDirectory Function to set the session's working directory.
+ * @param getSessionId Function to get the session ID from context.
  */
-export async function registerGitSetWorkingDirTool(server) {
-    // Check all required accessors
-    if (!_getWorkingDirectory || !_setWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors (getWD, setWD, getSID) for git_set_working_dir must be initialized before registration.");
-    }
-    try {
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitSetWorkingDirInputSchema.shape, // Pass the shape for SDK validation
-        async (validatedArgs, callContext) => {
-            // Use callContext provided by SDK
-            const operation = "tool:git_set_working_dir";
-            // Create a request context, potentially inheriting from callContext if it provides relevant info
-            const requestContext = requestContextService.createRequestContext({
-                operation,
-                parentContext: callContext,
+export const registerGitSetWorkingDirTool = async (server, setWorkingDirectory, getSessionId) => {
+    const operation = "registerGitSetWorkingDirTool";
+    const context = requestContextService.createRequestContext({ operation });
+    server.registerTool(TOOL_NAME, {
+        title: "Git Set Working Directory",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitSetWorkingDirInputSchema.shape,
+        outputSchema: GitSetWorkingDirOutputSchema.shape,
+        annotations: {
+            readOnlyHint: true, // Modifies session state, but not external files
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
+        });
+        try {
+            const sessionId = getSessionId(handlerContext);
+            const result = await gitSetWorkingDirLogic(params, {
+                ...handlerContext,
+                setWorkingDirectory: (path) => setWorkingDirectory(sessionId, path),
             });
-            // Get session ID using the accessor function
-            const sessionId = _getSessionId(requestContext); // Non-null assertion as we checked initialization
-            // Define the session-specific setter function
-            const setWorkingDirectoryForSession = (path) => {
-                _setWorkingDirectory(sessionId, path); // Non-null assertion
-            };
-            // Define the session-specific getter function (needed by logic?)
-            // If the logic needs the current WD, pass the getter too. Assuming it might.
-            const getWorkingDirectoryForSession = () => {
-                return _getWorkingDirectory(sessionId); // Non-null assertion
-            };
-            // Enhance context with session ID and the getter/setter functions
-            const logicContext = {
-                ...requestContext,
-                sessionId: sessionId,
-                getWorkingDirectory: getWorkingDirectoryForSession, // Pass getter
-                setWorkingDirectory: setWorkingDirectoryForSession, // Pass setter
+            return {
+                structuredContent: result,
+                content: [{ type: "text", text: `Success: ${JSON.stringify(result, null, 2)}` }],
             };
-            return await ErrorHandler.tryCatch(async () => {
-                // Call the core logic function with validated args and enhanced context
-                const result = await gitSetWorkingDirLogic(validatedArgs, logicContext);
-                // Format the successful result for the MCP client
-                const responseContent = {
-                    type: "text",
-                    text: JSON.stringify(result, null, 2), // Pretty-print JSON result
-                    contentType: "application/json",
-                };
-                logger.info(`Tool ${TOOL_NAME} executed successfully`, {
-                    ...logicContext,
-                    result,
-                });
-                return { content: [responseContent] };
-            }, {
-                operation,
-                context: logicContext,
-                input: validatedArgs, // Log sanitized input
-                errorCode: BaseErrorCode.INTERNAL_ERROR, // Default error code if logic fails unexpectedly
-                // toolName: TOOL_NAME, // Removed as it's not part of ErrorHandlerOptions
+        }
+        catch (error) {
+            logger.error(`Error in ${TOOL_NAME} handler`, { error, ...handlerContext });
+            const mcpError = ErrorHandler.handleError(error, {
+                operation: `tool:${TOOL_NAME}`,
+                context: handlerContext,
+                input: params,
             });
-        });
-        logger.info(`Tool registered: ${TOOL_NAME}`);
-    }
-    catch (error) {
-        logger.error(`Failed to register tool: ${TOOL_NAME}`, {
-            error: error instanceof Error ? error.message : String(error),
-            stack: error instanceof Error ? error.stack : undefined,
-        });
-        // Propagate the error to prevent server startup if registration fails
-        throw error;
-    }
-}
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error: ${mcpError.message}` }],
+                structuredContent: {
+                    code: mcpError.code,
+                    message: mcpError.message,
+                    details: mcpError.details,
+                },
+            };
+        }
+    });
+    logger.info(`Tool '${TOOL_NAME}' registered successfully.`, context);
+};

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

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