@cyanheads/git-mcp-server 2.1.7 → 2.2.0

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

@@ -1,175 +1,69 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_init tool.
+ * @module src/mcp-server/tools/gitInit/logic
+ */
 import { execFile } from "child_process";
 import fs from "fs/promises";
 import path from "path";
 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_init tool using Zod
+// 1. DEFINE the Zod input schema.
 export const GitInitInputSchema = z.object({
-    path: z
-        .string()
-        .min(1)
-        .optional()
-        .default(".")
-        .describe("Path where the new Git repository should be initialized. Can be relative or absolute. If relative or '.', it resolves against the directory set via `git_set_working_dir` for the session. If absolute, it's used directly. If omitted, defaults to '.' (resolved against session git working directory)."),
-    initialBranch: z
-        .string()
-        .optional()
-        .describe("Optional name for the initial branch (e.g., 'main'). Uses Git's default if not specified."),
-    bare: z
-        .boolean()
-        .default(false)
-        .describe("Create a bare repository (no working directory)."),
-    quiet: z
-        .boolean()
-        .default(false)
-        .describe("Only print error and warning messages; all other output will be suppressed."),
+    path: z.string().default(".").describe("Path where the new Git repository should be initialized."),
+    initialBranch: z.string().optional().describe("The name for the initial branch (e.g., 'main')."),
+    bare: z.boolean().default(false).describe("Create a bare repository with no working directory."),
+    quiet: z.boolean().default(false).describe("Suppress all output except for errors and warnings."),
+});
+// 2. DEFINE the Zod response schema.
+export const GitInitOutputSchema = 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 where the repository was initialized."),
+    gitDirExists: z.boolean().describe("Confirms the .git directory was created."),
 });
 /**
- * Executes the 'git init' command to initialize a new Git repository.
- *
- * @param {GitInitInput} input - The validated input object.
- * @param {RequestContext} context - The request context for logging and error handling.
- * @returns {Promise<GitInitResult>} A promise that resolves with the structured init result.
- * @throws {McpError} Throws an McpError if path validation fails or the git command fails unexpectedly.
+ * 4. IMPLEMENT the core logic function.
+ * @throws {McpError} If the logic encounters an unrecoverable issue.
  */
-export async function gitInitLogic(input, context) {
+export async function gitInitLogic(params, context) {
     const operation = "gitInitLogic";
-    logger.debug(`Executing ${operation}`, { ...context, input });
-    let targetPath;
+    logger.debug(`Executing ${operation}`, { ...context, params });
+    const targetPath = sanitization.sanitizePath(params.path, { allowAbsolute: true }).sanitizedPath;
+    const parentDir = path.dirname(targetPath);
     try {
-        // Sanitize the provided absolute path
-        targetPath = sanitization.sanitizePath(input.path, {
-            allowAbsolute: true,
-        }).sanitizedPath;
-        logger.debug("Sanitized path", {
-            ...context,
-            operation,
-            sanitizedPath: targetPath,
-        });
-        // Ensure the target directory exists before trying to init inside it
-        // git init creates the directory if it doesn't exist, but we might want to ensure the parent exists
-        const parentDir = path.dirname(targetPath);
-        try {
-            await fs.access(parentDir, fs.constants.W_OK); // Check write access in parent
-        }
-        catch (accessError) {
-            logger.error(`Parent directory check failed for ${targetPath}`, {
-                ...context,
-                operation,
-                error: accessError.message,
-            });
-            if (accessError.code === "ENOENT") {
-                throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Parent directory does not exist: ${parentDir}`, { context, operation });
-            }
-            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Cannot access parent directory: ${parentDir}. Error: ${accessError.message}`, { context, operation });
-        }
+        await fs.access(parentDir, fs.constants.W_OK);
     }
     catch (error) {
-        logger.error("Path validation 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 });
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Cannot access parent directory: ${parentDir}`);
     }
+    const args = ["init"];
+    if (params.quiet)
+        args.push("--quiet");
+    if (params.bare)
+        args.push("--bare");
+    args.push(`--initial-branch=${params.initialBranch || 'main'}`);
+    args.push(targetPath);
     try {
-        // Construct the git init command
-        const args = ["init"];
-        if (input.quiet) {
-            args.push("--quiet");
-        }
-        if (input.bare) {
-            args.push("--bare");
-        }
-        // Determine the initial branch name, defaulting to 'main' if not provided
-        const branchNameToUse = input.initialBranch || "main";
-        args.push("-b", branchNameToUse);
-        // Add the target directory path at the end
-        args.push(targetPath);
-        logger.debug(`Executing command: git ${args.join(" ")}`, {
-            ...context,
-            operation,
-        });
-        const { stdout, stderr } = await execFileAsync("git", args);
-        if (stderr && !input.quiet) {
-            // Log stderr as warning but proceed, as init might still succeed (e.g., reinitializing)
-            logger.warning(`Git init command produced stderr`, {
-                ...context,
-                operation,
-                stderr,
-            });
-        }
-        if (stdout && !input.quiet) {
-            // Log stdout at debug level for cleaner info logs
-            logger.debug(`Git init command produced stdout`, {
-                ...context,
-                operation,
-                stdout,
-            });
-        }
-        // Verify .git directory exists (or equivalent for bare repo)
-        const gitDirPath = input.bare ? targetPath : path.join(targetPath, ".git");
-        let gitDirExists = false;
-        try {
-            await fs.access(gitDirPath);
-            gitDirExists = true;
-        }
-        catch (e) {
-            logger.warning(`Could not verify existence of ${gitDirPath} after git init`, { ...context, operation });
-        }
-        const successMessage = `Successfully initialized Git repository in ${targetPath}`;
-        logger.info(successMessage, {
-            ...context,
-            operation,
-            path: targetPath,
-            bare: input.bare,
-            initialBranch: input.initialBranch || "default",
-        });
-        return {
-            success: true,
-            message: stdout.trim() || successMessage, // Return stdout to user if available
-            path: targetPath,
-            gitDirExists: gitDirExists,
-        };
+        logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+        const { stdout } = await execFileAsync("git", args);
+        const gitDirPath = params.bare ? targetPath : path.join(targetPath, ".git");
+        const gitDirExists = await fs.access(gitDirPath).then(() => true).catch(() => false);
+        const successMessage = stdout.trim() || `Successfully initialized Git repository in ${targetPath}`;
+        return { success: true, message: successMessage, path: targetPath, gitDirExists };
     }
     catch (error) {
         const errorMessage = error.stderr || error.message || "";
-        logger.error(`Failed to execute git init command`, {
-            ...context,
-            operation,
-            path: targetPath,
-            error: errorMessage,
-            stderr: error.stderr,
-            stdout: error.stdout,
-        });
-        // Handle specific error cases
-        if (errorMessage.toLowerCase().includes("already exists") &&
-            errorMessage.toLowerCase().includes("git repository")) {
-            // Reinitializing is often okay, treat as success but mention it.
-            logger.info(`Repository already exists, reinitialized: ${targetPath}`, {
-                ...context,
-                operation,
-            });
-            return {
-                success: true, // Treat reinitialization as success
-                message: `Reinitialized existing Git repository in ${targetPath}`,
-                path: targetPath,
-                gitDirExists: true, // Assume it exists if reinit message appears
-            };
-        }
+        logger.error(`Failed to execute git init command`, { ...context, operation, errorMessage });
         if (errorMessage.toLowerCase().includes("permission denied")) {
-            throw new McpError(BaseErrorCode.FORBIDDEN, `Permission denied to initialize repository at: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+            throw new McpError(BaseErrorCode.FORBIDDEN, `Permission denied to initialize repository at: ${targetPath}`);
+        }
+        // Re-initializing is not an error, so we check for it and return a success response.
+        if (errorMessage.toLowerCase().includes("reinitialized existing git repository")) {
+            return { success: true, message: `Reinitialized existing Git repository in ${targetPath}`, path: targetPath, gitDirExists: true };
         }
-        // Generic internal error for other failures
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to initialize repository at: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to initialize repository: ${errorMessage}`);
     }
 }

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

@@ -1,112 +1,60 @@
-import path from "path";
-import { z } from "zod";
-import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
-import { ErrorHandler, logger, requestContextService, sanitization, } from "../../../utils/index.js";
-import { GitInitInputSchema, gitInitLogic, } from "./logic.js";
-const TOOL_NAME = "git_init";
-const TOOL_DESCRIPTION = "Initializes a new Git repository at the specified path. If path is relative or omitted, it resolves against the session working directory (if you have set the git_working_dir). Can optionally set the initial branch name and create a bare repository.";
-const RegistrationSchema = GitInitInputSchema.extend({
-    path: z.string().min(1).optional().default("."),
-}).shape;
-// --- Module-level State Accessors ---
-// These will be populated by the initialize function called from server.ts
-let _getWorkingDirectory = () => undefined;
-let _getSessionIdFromContext = () => undefined;
 /**
- * Initializes state accessor functions for the git_init tool.
- * This function is called by the main server setup to provide the tool
- * with a way to access session-specific state (like the working directory)
- * without needing direct access to the server or transport layer internals.
- *
- * @param getWorkingDirectory - Function to retrieve the working directory for a given session ID.
- * @param getSessionIdFromContext - Function to extract the session ID from a tool's execution context.
+ * @fileoverview Handles registration and error handling for the git_init tool.
+ * @module src/mcp-server/tools/gitInit/registration
  */
-export function initializeGitInitStateAccessors(getWorkingDirectory, getSessionIdFromContext) {
-    _getWorkingDirectory = getWorkingDirectory;
-    _getSessionIdFromContext = getSessionIdFromContext;
-    logger.debug(`State accessors initialized for ${TOOL_NAME}`);
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
+import { gitInitLogic, GitInitInputSchema, GitInitOutputSchema, } from "./logic.js";
+const TOOL_NAME = "git_init";
+const TOOL_DESCRIPTION = "Initializes a new Git repository at the specified path. If path is relative or omitted, it resolves against the session working directory (if you have set the git_working_dir). Can optionally set the initial branch name and create a bare repository.";
 /**
- * Registers the git_init tool with the MCP server.
- *
- * @param {McpServer} server - The McpServer instance to register the tool with.
- * @returns {Promise<void>}
- * @throws {Error} If registration fails.
+ * Registers the git_init tool with the MCP server instance.
+ * @param server The MCP server instance.
+ * @param getSessionId Function to get the session ID from context.
  */
-export const registerGitInitTool = async (server) => {
+export const registerGitInitTool = async (server, getSessionId) => {
     const operation = "registerGitInitTool";
     const context = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(async () => {
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, RegistrationSchema, async (validatedArgs, callContext) => {
-            // Removed explicit type for callContext
-            const toolOperation = "tool:git_init";
-            const requestContext = requestContextService.createRequestContext({
-                operation: toolOperation,
-                parentContext: callContext,
-            });
-            // Use the initialized accessor to get the session ID
-            const sessionId = _getSessionIdFromContext(requestContext); // Pass the created context
-            if (!sessionId && !path.isAbsolute(validatedArgs.path)) {
-                // If path is relative, we NEED a session ID to resolve against a potential working dir
-                logger.error("Session ID is missing in context, cannot resolve relative path", requestContext);
-                throw new McpError(BaseErrorCode.INTERNAL_ERROR, "Session context is unavailable for relative path resolution.", { context: requestContext, operation: toolOperation });
-            }
-            logger.info(`Executing tool: ${TOOL_NAME}`, requestContext);
-            return await ErrorHandler.tryCatch(async () => {
-                // Use the initialized accessor to get the working directory
-                const sessionWorkingDirectory = _getWorkingDirectory(sessionId);
-                const inputPath = validatedArgs.path;
-                let resolvedPath;
-                try {
-                    if (path.isAbsolute(inputPath)) {
-                        resolvedPath = sanitization.sanitizePath(inputPath, {
-                            allowAbsolute: true,
-                        }).sanitizedPath;
-                        logger.debug(`Using absolute path: ${resolvedPath}`, requestContext);
-                    }
-                    else if (sessionWorkingDirectory) {
-                        resolvedPath = sanitization.sanitizePath(path.resolve(sessionWorkingDirectory, inputPath), { allowAbsolute: true }).sanitizedPath;
-                        logger.debug(`Resolved relative path '${inputPath}' to absolute path: ${resolvedPath} using session CWD`, requestContext);
-                    }
-                    else {
-                        // This case should now only be hit if the path is relative AND there's no session CWD set.
-                        logger.error(`Relative path '${inputPath}' provided but no session working directory is set.`, requestContext);
-                        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Relative path '${inputPath}' provided but no session working directory is set. Please provide an absolute path or set a working directory using git_set_working_dir.`, { context: requestContext, operation: toolOperation });
-                    }
-                }
-                catch (error) {
-                    logger.error("Path resolution or sanitization failed", {
-                        ...requestContext,
-                        operation: toolOperation,
-                        error,
-                    });
-                    if (error instanceof McpError)
-                        throw error;
-                    throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path processing: ${error instanceof Error ? error.message : String(error)}`, {
-                        context: requestContext,
-                        operation: toolOperation,
-                        originalError: error,
-                    });
-                }
-                const logicArgs = {
-                    ...validatedArgs,
-                    path: resolvedPath,
-                };
-                const initResult = await gitInitLogic(logicArgs, requestContext);
-                const resultContent = {
-                    type: "text",
-                    text: JSON.stringify(initResult, null, 2), // Pretty-print JSON
-                    contentType: "application/json",
-                };
-                logger.info(`Tool ${TOOL_NAME} executed successfully, returning JSON`, requestContext);
-                return { content: [resultContent] };
-            }, {
-                operation: toolOperation,
-                context: requestContext,
-                input: validatedArgs,
-                errorCode: BaseErrorCode.INTERNAL_ERROR,
-            });
+    server.registerTool(TOOL_NAME, {
+        title: "Git Initialize",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitInitInputSchema.shape,
+        outputSchema: GitInitOutputSchema.shape,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true, // Creates a .git directory
+            idempotentHint: true, // Re-initializing is idempotent
+            openWorldHint: false,
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
         });
-        logger.info(`Tool registered: ${TOOL_NAME}`, context);
-    }, { operation, context, critical: true });
+        try {
+            // The logic function now handles path resolution.
+            const result = await gitInitLogic(params, handlerContext);
+            return {
+                structuredContent: result,
+                content: [{ type: "text", text: `Success: ${JSON.stringify(result, null, 2)}` }],
+            };
+        }
+        catch (error) {
+            logger.error(`Error in ${TOOL_NAME} handler`, { error, ...handlerContext });
+            const handledError = ErrorHandler.handleError(error, {
+                operation: `tool:${TOOL_NAME}`,
+                context: handlerContext,
+                input: params,
+            });
+            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/gitLog/index.js

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