@cyanheads/git-mcp-server 2.1.8 → 2.2.0

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

@@ -1,79 +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 { requestContextService } from "../../../utils/index.js";
-// Import the shape and the final schema/types
-import { BaseErrorCode } from "../../../types-global/errors.js"; // Keep direct import for types-global
-import { diffGitChanges, GitDiffInputShape, } 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_diff tool.
+ * @module src/mcp-server/tools/gitDiff/registration
  */
-export function initializeGitDiffStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_diff tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
+import { diffGitChanges, GitDiffOutputSchema, GitDiffBaseSchema, } from "./logic.js";
 const TOOL_NAME = "git_diff";
 const TOOL_DESCRIPTION = "Shows changes between commits, commit and working tree, etc. Can show staged changes or diff specific files. An optional 'includeUntracked' parameter (boolean) can be used to also show the content of untracked files. Returns the diff output as plain text.";
 /**
- * Registers the git_diff tool with the MCP server.
- *
- * @param {McpServer} server - The MCP server instance.
- * @throws {Error} If state accessors are not initialized.
+ * Registers the git_diff 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 registerGitDiffTool(server) {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_diff must be initialized before registration.");
-    }
+export const registerGitDiffTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitDiffTool";
     const context = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(async () => {
-        // Use the exported shape for registration
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitDiffInputShape, // Provide the Zod base schema shape
-        async (validatedArgs, callContext) => {
-            const toolOperation = "tool:git_diff";
-            const requestContext = requestContextService.createRequestContext({
-                operation: toolOperation,
-                parentContext: callContext,
+    server.registerTool(TOOL_NAME, {
+        title: "Git Diff",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitDiffBaseSchema.shape,
+        outputSchema: GitDiffOutputSchema.shape,
+        annotations: {
+            readOnlyHint: true,
+            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 diffGitChanges(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: result.diff, contentType: "text/plain; charset=utf-8" }],
             };
-            logger.info(`Executing tool: ${TOOL_NAME}`, logicContext);
-            return await ErrorHandler.tryCatch(async () => {
-                // Call the core logic function
-                const diffResult = await diffGitChanges(validatedArgs, logicContext);
-                // Format the result (the diff string) as plain text within TextContent
-                const resultContent = {
-                    type: "text",
-                    // Return the raw diff output directly
-                    text: diffResult.diff,
-                    // Indicate the content type is plain text diff
-                    contentType: "text/plain; charset=utf-8", // Or 'text/x-diff'
-                };
-                logger.info(`Tool ${TOOL_NAME} executed successfully: ${diffResult.message}`, logicContext);
-                // Success is determined by the logic function
-                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/gitFetch/index.js

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

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

@@ -1,149 +1,67 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_fetch tool.
+ * @module src/mcp-server/tools/gitFetch/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_fetch tool using Zod
+// 1. DEFINE the Zod input schema.
 export const GitFetchInputSchema = 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."),
-    remote: z
-        .string()
-        .optional()
-        .describe("The remote repository to fetch from (e.g., 'origin'). If omitted, fetches from 'origin' or the default configured remote."),
-    prune: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("Before fetching, remove any remote-tracking references that no longer exist on the remote."),
-    tags: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("Fetch all tags from the remote (in addition to whatever else is fetched)."),
-    all: z.boolean().optional().default(false).describe("Fetch all remotes."),
-    // Add options like --depth, specific refspecs if needed
+    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."),
+    remote: z.string().optional().describe("The remote repository to fetch from (e.g., 'origin')."),
+    prune: z.boolean().default(false).describe("Remove remote-tracking references that no longer exist on the remote."),
+    tags: z.boolean().default(false).describe("Fetch all tags from the remote."),
+    all: z.boolean().default(false).describe("Fetch all remotes."),
+});
+// 2. DEFINE the Zod response schema.
+export const GitFetchOutputSchema = z.object({
+    success: z.boolean().describe("Indicates if the command was successful."),
+    message: z.string().describe("A summary message of the result."),
 });
 /**
- * Executes the 'git fetch' command and returns structured JSON output.
- *
- * @param {GitFetchInput} input - The validated input object.
- * @param {RequestContext} context - The request context for logging and error handling.
- * @returns {Promise<GitFetchResult>} A promise that resolves with the structured fetch 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 fetchGitRemote(input, context) {
+export async function fetchGitRemote(params, context) {
     const operation = "fetchGitRemote";
-    logger.debug(`Executing ${operation}`, { ...context, input });
-    let targetPath;
-    try {
-        // Resolve and sanitize the target path
-        if (input.path && input.path !== ".") {
-            targetPath = input.path;
-        }
-        else {
-            const workingDir = context.getWorkingDirectory();
-            if (!workingDir) {
-                throw new McpError(BaseErrorCode.VALIDATION_ERROR, "No path provided and no working directory set for the session.", { context, operation });
-            }
-            targetPath = workingDir;
-        }
-        targetPath = sanitization.sanitizePath(targetPath, {
-            allowAbsolute: true,
-        }).sanitizedPath;
-        logger.debug("Sanitized path", {
-            ...context,
-            operation,
-            sanitizedPath: targetPath,
-        });
+    logger.debug(`Executing ${operation}`, { ...context, params });
+    const workingDir = context.getWorkingDirectory();
+    if (params.path === "." && !workingDir) {
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, "No session working directory set. Please specify a 'path' or use 'git_set_working_dir' first.");
     }
-    catch (error) {
-        logger.error("Path resolution or sanitization failed", {
-            ...context,
-            operation,
-            error,
-        });
-        if (error instanceof McpError)
-            throw error;
-        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path: ${error instanceof Error ? error.message : String(error)}`, { context, operation, originalError: error });
+    const targetPath = sanitization.sanitizePath(params.path === "." ? workingDir : params.path, { allowAbsolute: true }).sanitizedPath;
+    const args = ["-C", targetPath, "fetch"];
+    if (params.prune)
+        args.push("--prune");
+    if (params.tags)
+        args.push("--tags");
+    if (params.all) {
+        args.push("--all");
+    }
+    else if (params.remote) {
+        args.push(params.remote);
     }
     try {
-        // Construct the git fetch command
-        const args = ["-C", targetPath, "fetch"];
-        if (input.prune) {
-            args.push("--prune");
-        }
-        if (input.tags) {
-            args.push("--tags");
-        }
-        if (input.all) {
-            args.push("--all");
-        }
-        else if (input.remote) {
-            args.push(input.remote); // Fetch specific remote if 'all' is not used
-        }
-        // If neither 'all' nor 'remote' is specified, git fetch defaults to 'origin' or configured upstream.
-        logger.debug(`Executing command: git ${args.join(" ")}`, {
-            ...context,
-            operation,
-        });
-        // Execute command. Fetch output is primarily on stderr.
-        const { stdout, stderr } = await execFileAsync("git", args);
-        logger.debug(`Git fetch stdout: ${stdout}`, { ...context, operation }); // stdout is usually empty
-        if (stderr) {
-            logger.debug(`Git fetch stderr: ${stderr}`, { ...context, operation }); // stderr contains fetch details
-        }
-        // Analyze stderr for success/summary
-        const message = "Fetch successful.";
-        const summary = stderr.trim() || "No changes detected.";
-        logger.info(message, {
-            ...context,
-            operation,
-            path: targetPath,
-            summary,
-        });
-        return { success: true, message, summary };
+        logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+        const { stderr } = await execFileAsync("git", args);
+        const message = stderr.trim() || "Fetch successful.";
+        return { success: true, message };
     }
     catch (error) {
-        logger.error(`Failed to execute git fetch 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
+        const errorMessage = error.stderr || error.message || "";
+        logger.error(`Failed to execute git fetch command`, { ...context, operation, errorMessage });
         if (errorMessage.toLowerCase().includes("not a git repository")) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`, { context, operation, originalError: error });
-        }
-        if (errorMessage.includes("resolve host") ||
-            errorMessage.includes("Could not read from remote repository") ||
-            errorMessage.includes("Connection timed out")) {
-            throw new McpError(BaseErrorCode.SERVICE_UNAVAILABLE, `Failed to connect to remote repository '${input.remote || "default"}'. Error: ${errorMessage}`, { context, operation, originalError: error });
-        }
-        if (errorMessage.includes("fatal: ") &&
-            errorMessage.includes("couldn't find remote ref")) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Remote ref not found. Error: ${errorMessage}`, { context, operation, originalError: error });
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`);
         }
-        if (errorMessage.includes("Authentication failed") ||
-            errorMessage.includes("Permission denied")) {
-            throw new McpError(BaseErrorCode.UNAUTHORIZED, `Authentication failed for remote repository '${input.remote || "default"}'. Error: ${errorMessage}`, { context, operation, originalError: error });
+        if (errorMessage.includes("Could not read from remote repository")) {
+            throw new McpError(BaseErrorCode.SERVICE_UNAVAILABLE, `Failed to connect to remote repository '${params.remote || "default"}'.`);
         }
-        if (errorMessage.includes("does not appear to be a git repository")) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Remote '${input.remote || "default"}' does not appear to be a git repository. Error: ${errorMessage}`, { context, operation, originalError: error });
+        if (errorMessage.includes("Authentication failed")) {
+            throw new McpError(BaseErrorCode.UNAUTHORIZED, `Authentication failed for remote repository '${params.remote || "default"}'.`);
         }
-        // Generic internal error for other failures
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to git fetch for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git fetch failed: ${errorMessage}`);
     }
 }

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

@@ -1,76 +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 { fetchGitRemote, GitFetchInputSchema, } 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_fetch tool.
+ * @module src/mcp-server/tools/gitFetch/registration
  */
-export function initializeGitFetchStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_fetch tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
+import { fetchGitRemote, GitFetchInputSchema, GitFetchOutputSchema, } from "./logic.js";
 const TOOL_NAME = "git_fetch";
-const TOOL_DESCRIPTION = "Downloads objects and refs from one or more other repositories. Can fetch specific remotes or all, prune stale branches, and fetch tags.";
+const TOOL_DESCRIPTION = "Downloads objects and refs from one or more repositories. Can fetch specific remotes or all, prune stale branches, and fetch tags.";
 /**
- * Registers the git_fetch tool with the MCP server.
- *
- * @param {McpServer} server - The MCP server instance.
- * @throws {Error} If state accessors are not initialized.
+ * Registers the git_fetch 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 registerGitFetchTool(server) {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_fetch must be initialized before registration.");
-    }
+export const registerGitFetchTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitFetchTool";
     const context = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(async () => {
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitFetchInputSchema.shape, // Provide the Zod schema shape
-        async (validatedArgs, callContext) => {
-            const toolOperation = "tool:git_fetch";
-            const requestContext = requestContextService.createRequestContext({
-                operation: toolOperation,
-                parentContext: callContext,
+    server.registerTool(TOOL_NAME, {
+        title: "Git Fetch",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitFetchInputSchema.shape,
+        outputSchema: GitFetchOutputSchema.shape,
+        annotations: {
+            readOnlyHint: false, // Modifies local refs
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true, // Interacts with remote repositories
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
+        });
+        try {
+            const sessionId = getSessionId(handlerContext);
+            const result = await fetchGitRemote(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 fetchResult = await fetchGitRemote(validatedArgs, logicContext);
-                // Format the result as a JSON string within TextContent
-                const resultContent = {
-                    type: "text",
-                    // Stringify the entire GitFetchResult object
-                    text: JSON.stringify(fetchResult, null, 2), // Pretty-print JSON
-                    contentType: "application/json",
-                };
-                logger.info(`Tool ${TOOL_NAME} executed successfully: ${fetchResult.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 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/gitInit/index.js

@@ -1,7 +1,5 @@
 /**
- * @fileoverview Barrel file for the git_init tool.
- * Exports the registration function and the state accessor initializer.
+ * @fileoverview Barrel file for the gitInit tool.
+ * @module src/mcp-server/tools/gitInit/index
  */
-export { registerGitInitTool, initializeGitInitStateAccessors, } from "./registration.js";
-// Export types if needed elsewhere, e.g.:
-// export type { GitInitInput, GitInitResult } from './logic.js';
+export { registerGitInitTool } from "./registration.js";