@cyanheads/git-mcp-server 2.1.8 → 2.2.1

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 { 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 mcpError = ErrorHandler.handleError(error, {
+                operation: `tool:${TOOL_NAME}`,
+                context: handlerContext,
+                input: params,
+            });
+            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/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";

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

@@ -1,284 +1,89 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_log tool.
+ * @module src/mcp-server/tools/gitLog/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 structure for a single commit entry
-export const CommitEntrySchema = z.object({
+// 1. DEFINE the Zod input schema.
+export const GitLogInputSchema = z.object({
+    path: z.string().default(".").describe("Path to the Git repository."),
+    maxCount: z.number().int().positive().optional().describe("Limit the number of commits to output."),
+    author: z.string().optional().describe("Limit commits to those by a specific author."),
+    since: z.string().optional().describe("Show commits more recent than a specific date (e.g., '2 weeks ago')."),
+    until: z.string().optional().describe("Show commits older than a specific date."),
+    branchOrFile: z.string().optional().describe("Show logs for a specific branch, tag, or file path."),
+    showSignature: z.boolean().default(false).describe("Show signature verification status for commits."),
+});
+// 2. DEFINE the Zod response schema.
+const CommitEntrySchema = z.object({
     hash: z.string().describe("Full commit hash"),
     authorName: z.string().describe("Author's name"),
     authorEmail: z.string().email().describe("Author's email"),
-    timestamp: z
-        .number()
-        .int()
-        .positive()
-        .describe("Commit timestamp (Unix epoch seconds)"),
+    timestamp: z.number().int().positive().describe("Commit timestamp (Unix epoch seconds)"),
     subject: z.string().describe("Commit subject line"),
-    body: z.string().optional().describe("Commit body (optional)"),
+    body: z.string().optional().describe("Commit body"),
 });
-// Define the input schema for the git_log tool using Zod
-export const GitLogInputSchema = 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."),
-    maxCount: z
-        .number()
-        .int()
-        .positive()
-        .optional()
-        .describe("Limit the number of commits to output."),
-    author: z
-        .string()
-        .optional()
-        .describe("Limit commits to those matching the specified author pattern."),
-    since: z
-        .string()
-        .optional()
-        .describe("Show commits more recent than a specific date (e.g., '2 weeks ago', '2023-01-01')."),
-    until: z
-        .string()
-        .optional()
-        .describe("Show commits older than a specific date."),
-    branchOrFile: z
-        .string()
-        .optional()
-        .describe("Show logs for a specific branch (e.g., 'main'), tag, or file path (e.g., 'src/utils/logger.ts')."),
-    showSignature: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("Show signature verification status for commits. Returns raw output instead of parsed JSON."),
-    // Note: We use a fixed pretty format for reliable parsing unless showSignature is true.
+export const GitLogOutputSchema = z.object({
+    success: z.boolean().describe("Indicates if the command was successful."),
+    message: z.string().describe("A summary message of the result."),
+    commits: z.array(CommitEntrySchema).optional().describe("A list of commits."),
+    rawOutput: z.string().optional().describe("Raw output from the git log command, used when showSignature is true."),
 });
-// Delimiters for parsing the custom format
-const FIELD_SEP = "\x1f"; // Unit Separator
-const RECORD_SEP = "\x1e"; // Record Separator
-const GIT_LOG_FORMAT = `--pretty=format:%H${FIELD_SEP}%an${FIELD_SEP}%ae${FIELD_SEP}%at${FIELD_SEP}%s${FIELD_SEP}%b${RECORD_SEP}`; // %H=hash, %an=author name, %ae=author email, %at=timestamp, %s=subject, %b=body
+const FIELD_SEP = "\x1f";
+const RECORD_SEP = "\x1e";
+const GIT_LOG_FORMAT = `--pretty=format:%H${FIELD_SEP}%an${FIELD_SEP}%ae${FIELD_SEP}%at${FIELD_SEP}%s${FIELD_SEP}%b${RECORD_SEP}`;
 /**
- * Executes the 'git log' command with a specific format and returns structured JSON output.
- *
- * @param {GitLogInput} input - The validated input object.
- * @param {RequestContext} context - The request context for logging and error handling.
- * @returns {Promise<GitLogResult>} A promise that resolves with the structured log result (either flat or grouped).
- * @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 logGitHistory(input, context) {
-    // Return type updated to the union
+export async function logGitHistory(params, context) {
     const operation = "logGitHistory";
-    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.");
+    }
+    const targetPath = sanitization.sanitizePath(params.path === "." ? workingDir : params.path, { allowAbsolute: true }).sanitizedPath;
+    const args = ["-C", targetPath, "log"];
+    if (params.showSignature) {
+        args.push("--show-signature");
     }
-    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 });
+    else {
+        args.push(GIT_LOG_FORMAT);
     }
-    try {
-        const args = ["-C", targetPath, "log"];
-        let isRawOutput = false; // Flag to indicate if we should parse or return raw
-        if (input.showSignature) {
-            isRawOutput = true;
-            args.push("--show-signature");
-            logger.info("Show signature requested, returning raw output.", {
-                ...context,
-                operation,
-            });
-        }
-        else {
-            args.push(GIT_LOG_FORMAT);
-        }
-        if (input.maxCount) {
-            args.push(`-n${input.maxCount}`);
-        }
-        if (input.author) {
-            args.push(`--author=${input.author}`);
-        }
-        if (input.since) {
-            args.push(`--since=${input.since}`);
-        }
-        if (input.until) {
-            args.push(`--until=${input.until}`);
-        }
-        if (input.branchOrFile) {
-            args.push(input.branchOrFile);
-        }
-        logger.debug(`Executing command: git ${args.join(" ")}`, {
-            ...context,
-            operation,
-        });
-        // Increase maxBuffer if logs can be large
-        const { stdout, stderr } = await execFileAsync("git", args, {
-            maxBuffer: 1024 * 1024 * 10,
-        }); // 10MB buffer
-        if (stderr) {
-            // Log stderr as warning, as git log might sometimes use it for non-fatal info
-            // Exception: If showing signature, stderr about allowedSignersFile is expected, treat as info
-            if (isRawOutput &&
-                stderr.includes("allowedSignersFile needs to be configured")) {
-                logger.info(`Git log stderr (signature verification note): ${stderr.trim()}`, { ...context, operation });
-            }
-            else {
-                logger.warning(`Git log stderr: ${stderr.trim()}`, {
-                    ...context,
-                    operation,
-                });
-            }
-        }
-        // If raw output was requested, return it directly in the message field, omitting commits
-        if (isRawOutput) {
-            const message = `Raw log output (showSignature=true):\n${stdout}`;
-            logger.info(`${operation} completed successfully (raw output).`, {
-                ...context,
-                operation,
-                path: targetPath,
-            });
-            // Return without the 'commits' or 'groupedCommits' field
-            return { success: true, message: message };
-        }
-        // --- Parse the structured output into a flat list first ---
-        const flatCommits = [];
-        const commitRecords = stdout
-            .split(RECORD_SEP)
-            .filter((record) => record.trim() !== ""); // Split records and remove empty ones
-        for (const record of commitRecords) {
-            const trimmedRecord = record.trim(); // Trim leading/trailing whitespace (like newlines)
-            if (!trimmedRecord)
-                continue; // Skip empty records after trimming
-            const fields = trimmedRecord.split(FIELD_SEP); // Split the trimmed record
-            if (fields.length >= 5) {
-                // Need at least hash, name, email, timestamp, subject
-                try {
-                    const commitEntry = {
-                        hash: fields[0],
-                        authorName: fields[1],
-                        authorEmail: fields[2],
-                        timestamp: parseInt(fields[3], 10), // Unix timestamp
-                        subject: fields[4],
-                        body: fields[5] || undefined, // Body might be empty
-                    };
-                    // Validate parsed entry
-                    CommitEntrySchema.parse(commitEntry);
-                    flatCommits.push(commitEntry);
-                }
-                catch (parseError) {
-                    logger.warning(`Failed to parse commit record field`, {
-                        ...context,
-                        operation,
-                        fieldIndex: fields.findIndex((_, i) => i > 5),
-                        recordFragment: record.substring(0, 100),
-                        parseError,
-                    });
-                    // Decide whether to skip the commit or throw an error
-                }
-            }
-            else {
-                logger.warning(`Skipping commit record due to unexpected number of fields (${fields.length})`, { ...context, operation, recordFragment: record.substring(0, 100) });
-            }
-        }
-        // --- Group the flat list by author ---
-        const groupedCommitsMap = new Map();
-        for (const commit of flatCommits) {
-            const authorKey = `${commit.authorName} <${commit.authorEmail}>`;
-            const groupedInfo = {
-                hash: commit.hash,
-                timestamp: commit.timestamp,
-                subject: commit.subject,
-                body: commit.body,
-            };
-            if (groupedCommitsMap.has(authorKey)) {
-                groupedCommitsMap.get(authorKey).commits.push(groupedInfo);
-            }
-            else {
-                groupedCommitsMap.set(authorKey, {
-                    authorName: commit.authorName,
-                    authorEmail: commit.authorEmail,
-                    commits: [groupedInfo],
-                });
-            }
-        }
-        const groupedCommits = Array.from(groupedCommitsMap.values());
-        // --- Prepare final result ---
-        const commitCount = flatCommits.length;
-        const message = commitCount > 0
-            ? `${commitCount} commit(s) found.`
-            : "No commits found matching criteria.";
-        logger.info(message, {
-            ...context,
-            operation,
-            path: targetPath,
-            commitCount: commitCount,
-            authorGroupCount: groupedCommits.length,
-        });
-        return { success: true, groupedCommits, message }; // Return the grouped structure
+    if (params.maxCount)
+        args.push(`-n${params.maxCount}`);
+    if (params.author)
+        args.push(`--author=${params.author}`);
+    if (params.since)
+        args.push(`--since=${params.since}`);
+    if (params.until)
+        args.push(`--until=${params.until}`);
+    if (params.branchOrFile)
+        args.push(params.branchOrFile);
+    logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+    const { stdout, stderr } = await execFileAsync("git", args, { maxBuffer: 1024 * 1024 * 10 });
+    if (stderr && stderr.toLowerCase().includes("does not have any commits yet")) {
+        return { success: true, message: "Repository has no commits yet.", commits: [] };
     }
-    catch (error) {
-        logger.error(`Failed to execute git log 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
-        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("fatal: bad revision")) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Invalid branch, tag, or revision specified: '${input.branchOrFile}'. Error: ${errorMessage}`, { context, operation, originalError: error });
-        }
-        if (errorMessage.includes("fatal: ambiguous argument")) {
-            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Ambiguous argument provided (e.g., branch/tag/file conflict): '${input.branchOrFile}'. Error: ${errorMessage}`, { context, operation, originalError: error });
-        }
-        // Check if it's just that no commits were found
-        if (errorMessage.includes("does not have any commits yet")) {
-            logger.info("Repository has no commits yet.", {
-                ...context,
-                operation,
-                path: targetPath,
-            });
-            // Return the grouped structure even for no commits
-            return {
-                success: true,
-                groupedCommits: [],
-                message: "Repository has no commits yet.",
-            };
-        }
-        // Generic internal error for other failures
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to get git log for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+    if (params.showSignature) {
+        return { success: true, message: "Raw log output with signature status.", rawOutput: stdout };
     }
+    const commitRecords = stdout.split(RECORD_SEP).filter(r => r.trim());
+    const commits = commitRecords.map(record => {
+        const fields = record.trim().split(FIELD_SEP);
+        return {
+            hash: fields[0],
+            authorName: fields[1],
+            authorEmail: fields[2],
+            timestamp: parseInt(fields[3], 10),
+            subject: fields[4],
+            body: fields[5] || undefined,
+        };
+    });
+    return { success: true, message: `Found ${commits.length} commit(s).`, commits };
 }