@cyanheads/git-mcp-server 1.2.4 → 2.0.2

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

@@ -0,0 +1,116 @@
+import { z } from 'zod';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+import { logger } from '../../../utils/logger.js';
+import { McpError, BaseErrorCode } from '../../../types-global/errors.js';
+import { sanitization } from '../../../utils/sanitization.js';
+const execAsync = promisify(exec);
+// Define the input schema for the git_fetch tool using Zod
+export const GitFetchInputSchema = z.object({
+    path: z.string().min(1).optional().default('.').describe("Path to the Git repository. Defaults to the session's working directory if 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
+});
+/**
+ * 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.
+ */
+export async function fetchGitRemote(input, 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);
+        logger.debug('Sanitized path', { ...context, operation, sanitizedPath: targetPath });
+    }
+    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 });
+    }
+    // Basic sanitization for remote name
+    const safeRemote = input.remote?.replace(/[^a-zA-Z0-9_.\-/]/g, '');
+    try {
+        // Construct the git fetch command
+        let command = `git -C "${targetPath}" fetch`;
+        if (input.prune) {
+            command += ' --prune';
+        }
+        if (input.tags) {
+            command += ' --tags';
+        }
+        if (input.all) {
+            command += ' --all';
+        }
+        else if (safeRemote) {
+            command += ` ${safeRemote}`; // 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: ${command}`, { ...context, operation });
+        // Execute command. Fetch output is primarily on stderr.
+        const { stdout, stderr } = await execAsync(command);
+        logger.info(`Git fetch stdout: ${stdout}`, { ...context, operation }); // stdout is usually empty
+        logger.info(`Git fetch stderr: ${stderr}`, { ...context, operation }); // stderr contains fetch details
+        // Analyze stderr for success/summary
+        let message = stderr.trim() || 'Fetch command executed.'; // Use stderr as the primary message
+        let summary = undefined;
+        // Check for common patterns in stderr
+        if (stderr.includes('Updating') || stderr.includes('->') || stderr.includes('new tag') || stderr.includes('new branch')) {
+            message = 'Fetch successful.';
+            summary = stderr.trim(); // Use the full stderr as summary
+        }
+        else if (stderr.trim() === '') {
+            // Sometimes fetch completes successfully with no output if nothing changed
+            message = 'Fetch successful (no changes detected).';
+        }
+        else if (message.includes('fatal:')) {
+            // Should be caught by catch block, but double-check
+            logger.error(`Git fetch command indicated failure: ${message}`, { ...context, operation, stdout, stderr });
+            // Re-throw as an internal error if not caught below
+            throw new Error(`Fetch failed: ${message}`);
+        }
+        logger.info(`${operation} completed successfully. ${message}`, { ...context, operation, path: targetPath });
+        return { success: true, message, summary };
+    }
+    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
+        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.NETWORK_ERROR, `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 });
+        }
+        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('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 });
+        }
+        // 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 });
+    }
+}

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

@@ -0,0 +1,71 @@
+import { ErrorHandler } from '../../../utils/errorHandler.js';
+import { logger } from '../../../utils/logger.js';
+import { requestContextService } from '../../../utils/requestContext.js';
+import { GitFetchInputSchema, fetchGitRemote } from './logic.js';
+import { BaseErrorCode } from '../../../types-global/errors.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.
+ */
+export function initializeGitFetchStateAccessors(getWdFn, getSidFn) {
+    _getWorkingDirectory = getWdFn;
+    _getSessionId = getSidFn;
+    logger.info('State accessors initialized for git_fetch tool registration.');
+}
+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.";
+/**
+ * Registers the git_fetch tool with the MCP server.
+ *
+ * @param {McpServer} server - The MCP server instance.
+ * @throws {Error} If state accessors are not initialized.
+ */
+export async function registerGitFetchTool(server) {
+    if (!_getWorkingDirectory || !_getSessionId) {
+        throw new Error('State accessors for git_fetch must be initialized before registration.');
+    }
+    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 });
+            const sessionId = _getSessionId(requestContext);
+            const getWorkingDirectoryForSession = () => {
+                return _getWorkingDirectory(sessionId);
+            };
+            const logicContext = {
+                ...requestContext,
+                sessionId: sessionId,
+                getWorkingDirectory: getWorkingDirectoryForSession,
+            };
+            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
+            });
+        });
+        logger.info(`Tool registered: ${TOOL_NAME}`, context);
+    }, { operation, context, critical: true });
+}
+;

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

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Barrel file for the git_init tool.
+ * Exports the registration function.
+ */
+export { registerGitInitTool } from './registration.js';
+// Export types if needed elsewhere, e.g.:
+// export type { GitInitInput, GitInitResult } from './logic.js';

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

@@ -0,0 +1,117 @@
+import { z } from 'zod';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import { logger } from '../../../utils/logger.js';
+import { McpError, BaseErrorCode } from '../../../types-global/errors.js';
+import { sanitization } from '../../../utils/sanitization.js';
+const execAsync = promisify(exec);
+// Define the input schema for the git_init tool using Zod
+export const GitInitInputSchema = z.object({
+    path: z.string().min(1).describe("The absolute path where the new Git repository should be initialized."),
+    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."),
+});
+/**
+ * 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.
+ */
+export async function gitInitLogic(input, context) {
+    const operation = 'gitInitLogic';
+    logger.debug(`Executing ${operation}`, { ...context, input });
+    let targetPath;
+    try {
+        // Sanitize the provided absolute path
+        targetPath = sanitization.sanitizePath(input.path);
+        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 });
+        }
+    }
+    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 });
+    }
+    try {
+        // Construct the git init command
+        let command = `git init`;
+        if (input.quiet) {
+            command += ' --quiet';
+        }
+        if (input.bare) {
+            command += ' --bare';
+        }
+        if (input.initialBranch) {
+            // Use -b for modern Git versions, older might need --initial-branch=
+            // Sticking with -b as it's common now. Add quotes around branch name.
+            command += ` -b "${input.initialBranch.replace(/"/g, '\\"')}"`;
+        }
+        // Add the target directory path at the end
+        command += ` "${targetPath}"`;
+        logger.debug(`Executing command: ${command}`, { ...context, operation });
+        const { stdout, stderr } = await execAsync(command);
+        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) {
+            logger.info(`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 = stdout.trim() || `Initialized empty Git repository in ${targetPath}`;
+        logger.info(`${operation} executed successfully`, { ...context, operation, path: targetPath });
+        return {
+            success: true,
+            message: successMessage,
+            path: targetPath,
+            gitDirExists: 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
+            };
+        }
+        if (errorMessage.toLowerCase().includes('permission denied')) {
+            throw new McpError(BaseErrorCode.FORBIDDEN, `Permission denied to initialize repository at: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+        }
+        // Generic internal error for other failures
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to initialize repository at: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+    }
+}

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

@@ -0,0 +1,44 @@
+import { ErrorHandler } from '../../../utils/errorHandler.js';
+import { logger } from '../../../utils/logger.js';
+import { requestContextService } from '../../../utils/requestContext.js';
+import { GitInitInputSchema, gitInitLogic } from './logic.js';
+import { BaseErrorCode } from '../../../types-global/errors.js';
+const TOOL_NAME = 'git_init';
+const TOOL_DESCRIPTION = 'Initializes a new Git repository at the specified absolute path. 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.
+ */
+export const registerGitInitTool = async (server) => {
+    const operation = 'registerGitInitTool';
+    const context = requestContextService.createRequestContext({ operation });
+    await ErrorHandler.tryCatch(async () => {
+        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitInitInputSchema.shape, // Provide the Zod schema shape
+        async (validatedArgs, callContext) => {
+            const toolOperation = 'tool:git_init';
+            const requestContext = requestContextService.createRequestContext({ operation: toolOperation, parentContext: callContext });
+            logger.info(`Executing tool: ${TOOL_NAME}`, requestContext);
+            return await ErrorHandler.tryCatch(async () => {
+                // Call the core logic function
+                const initResult = await gitInitLogic(validatedArgs, requestContext);
+                // Format the result as a JSON string within TextContent
+                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, // Default if unexpected error occurs
+            });
+        });
+        logger.info(`Tool registered: ${TOOL_NAME}`, context);
+    }, { operation, context, critical: true }); // Mark registration as critical
+};

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

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

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

@@ -0,0 +1,148 @@
+import { z } from 'zod';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+import { logger } from '../../../utils/logger.js';
+import { McpError, BaseErrorCode } from '../../../types-global/errors.js';
+import { sanitization } from '../../../utils/sanitization.js';
+const execAsync = promisify(exec);
+// Define the structure for a single commit entry
+export 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)"),
+    subject: z.string().describe("Commit subject line"),
+    body: z.string().optional().describe("Commit body (optional)"),
+});
+// 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 session's working directory if 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, tag, or file path."),
+    // Note: We use a fixed pretty format for reliable parsing. Custom formats are not directly supported via input.
+});
+// 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
+/**
+ * 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.
+ * @throws {McpError} Throws an McpError if path resolution, validation, or the git command fails unexpectedly.
+ */
+export async function logGitHistory(input, 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);
+        logger.debug('Sanitized path', { ...context, operation, sanitizedPath: targetPath });
+    }
+    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 });
+    }
+    try {
+        // Construct the git log command
+        // Use a specific format for reliable parsing
+        let command = `git -C "${targetPath}" log ${GIT_LOG_FORMAT}`;
+        if (input.maxCount) {
+            command += ` -n ${input.maxCount}`;
+        }
+        if (input.author) {
+            // Basic sanitization for author string
+            const safeAuthor = input.author.replace(/[`"$&;*()|<>]/g, '');
+            command += ` --author="${safeAuthor}"`;
+        }
+        if (input.since) {
+            const safeSince = input.since.replace(/[`"$&;*()|<>]/g, '');
+            command += ` --since="${safeSince}"`;
+        }
+        if (input.until) {
+            const safeUntil = input.until.replace(/[`"$&;*()|<>]/g, '');
+            command += ` --until="${safeUntil}"`;
+        }
+        if (input.branchOrFile) {
+            const safeBranchOrFile = input.branchOrFile.replace(/[`"$&;*()|<>]/g, '');
+            command += ` ${safeBranchOrFile}`; // Add branch or file path at the end
+        }
+        logger.debug(`Executing command: ${command}`, { ...context, operation });
+        // Increase maxBuffer if logs can be large
+        const { stdout, stderr } = await execAsync(command, { maxBuffer: 1024 * 1024 * 10 }); // 10MB buffer
+        if (stderr) {
+            // Log stderr as warning, as git log might sometimes use it for non-fatal info
+            logger.warning(`Git log stderr: ${stderr}`, { ...context, operation });
+        }
+        // Parse the output
+        const commits = [];
+        const commitRecords = stdout.split(RECORD_SEP).filter(record => record.trim() !== ''); // Split records and remove empty ones
+        for (const record of commitRecords) {
+            const fields = record.split(FIELD_SEP);
+            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 (optional but recommended)
+                    CommitEntrySchema.parse(commitEntry);
+                    commits.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) });
+            }
+        }
+        const message = commits.length > 0 ? `${commits.length} commit(s) found.` : 'No commits found matching criteria.';
+        logger.info(`${operation} completed successfully. ${message}`, { ...context, operation, path: targetPath, commitCount: commits.length });
+        return { success: true, commits, message };
+    }
+    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 (which git might treat as an error in some cases, though usually not for log)
+        if (errorMessage.includes('does not have any commits yet')) {
+            logger.info('Repository has no commits yet.', { ...context, operation, path: targetPath });
+            return { success: true, commits: [], 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 });
+    }
+}

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

@@ -0,0 +1,71 @@
+import { ErrorHandler } from '../../../utils/errorHandler.js';
+import { logger } from '../../../utils/logger.js';
+import { requestContextService } from '../../../utils/requestContext.js';
+import { GitLogInputSchema, logGitHistory } from './logic.js';
+import { BaseErrorCode } from '../../../types-global/errors.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.
+ */
+export function initializeGitLogStateAccessors(getWdFn, getSidFn) {
+    _getWorkingDirectory = getWdFn;
+    _getSessionId = getSidFn;
+    logger.info('State accessors initialized for git_log tool registration.');
+}
+const TOOL_NAME = 'git_log';
+const TOOL_DESCRIPTION = "Shows commit logs for the repository. Supports limiting count, filtering by author, date range, and specific branch/file. Returns a list of commit objects.";
+/**
+ * Registers the git_log tool with the MCP server.
+ *
+ * @param {McpServer} server - The MCP server instance.
+ * @throws {Error} If state accessors are not initialized.
+ */
+export async function registerGitLogTool(server) {
+    if (!_getWorkingDirectory || !_getSessionId) {
+        throw new Error('State accessors for git_log must be initialized before registration.');
+    }
+    const operation = 'registerGitLogTool';
+    const context = requestContextService.createRequestContext({ operation });
+    await ErrorHandler.tryCatch(async () => {
+        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitLogInputSchema.shape, // Provide the Zod schema shape
+        async (validatedArgs, callContext) => {
+            const toolOperation = 'tool:git_log';
+            const requestContext = requestContextService.createRequestContext({ operation: toolOperation, parentContext: callContext });
+            const sessionId = _getSessionId(requestContext);
+            const getWorkingDirectoryForSession = () => {
+                return _getWorkingDirectory(sessionId);
+            };
+            const logicContext = {
+                ...requestContext,
+                sessionId: sessionId,
+                getWorkingDirectory: getWorkingDirectoryForSession,
+            };
+            logger.info(`Executing tool: ${TOOL_NAME}`, logicContext);
+            return await ErrorHandler.tryCatch(async () => {
+                // Call the core logic function
+                const logResult = await logGitHistory(validatedArgs, logicContext);
+                // Format the result (array of commits) as a JSON string within TextContent
+                const resultContent = {
+                    type: 'text',
+                    // Stringify the entire GitLogResult object which includes the commits array and success flag
+                    text: JSON.stringify(logResult, null, 2), // Pretty-print JSON
+                    contentType: 'application/json',
+                };
+                logger.info(`Tool ${TOOL_NAME} executed successfully, returning JSON`, 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
+            });
+        });
+        logger.info(`Tool registered: ${TOOL_NAME}`, context);
+    }, { operation, context, critical: true });
+}
+;

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

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Barrel file for the git_merge tool.
+ * Exports the registration function and state accessor initialization function.
+ */
+export { registerGitMergeTool, initializeGitMergeStateAccessors } from './registration.js';
+// Export types if needed elsewhere, e.g.:
+// export type { GitMergeInput, GitMergeResult } from './logic.js';