@cyanheads/git-mcp-server 2.1.0 → 2.1.2

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

@@ -1,21 +1,35 @@
-import { exec } from 'child_process';
-import fs from 'fs/promises';
-import path from 'path';
-import { promisify } from 'util';
-import { z } from 'zod';
+import { exec } 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 { 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 { 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 { sanitization } from "../../../utils/index.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).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()
+        .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."),
 });
 /**
  * Executes the 'git init' command to initialize a new Git repository.
@@ -26,13 +40,19 @@ export const GitInitInputSchema = z.object({
  * @throws {McpError} Throws an McpError if path validation fails or the git command fails unexpectedly.
  */
 export async function gitInitLogic(input, context) {
-    const operation = 'gitInitLogic';
+    const operation = "gitInitLogic";
     logger.debug(`Executing ${operation}`, { ...context, input });
     let targetPath;
     try {
         // Sanitize the provided absolute path
-        targetPath = sanitization.sanitizePath(input.path, { allowAbsolute: true }).sanitizedPath;
-        logger.debug('Sanitized path', { ...context, operation, sanitizedPath: targetPath });
+        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);
@@ -40,15 +60,23 @@ export async function gitInitLogic(input, context) {
             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') {
+            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 });
+        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 });
@@ -57,13 +85,13 @@ export async function gitInitLogic(input, context) {
         // Construct the git init command
         let command = `git init`;
         if (input.quiet) {
-            command += ' --quiet';
+            command += " --quiet";
         }
         if (input.bare) {
-            command += ' --bare';
+            command += " --bare";
         }
         // Determine the initial branch name, defaulting to 'main' if not provided
-        const branchNameToUse = input.initialBranch || 'main';
+        const branchNameToUse = input.initialBranch || "main";
         command += ` -b "${branchNameToUse.replace(/"/g, '\\"')}"`;
         // Add the target directory path at the end
         command += ` "${targetPath}"`;
@@ -71,13 +99,22 @@ export async function gitInitLogic(input, context) {
         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 });
+            logger.warning(`Git init command produced stderr`, {
+                ...context,
+                operation,
+                stderr,
+            });
         }
         if (stdout && !input.quiet) {
-            logger.info(`Git init command produced stdout`, { ...context, operation, stdout });
+            // 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');
+        const gitDirPath = input.bare ? targetPath : path.join(targetPath, ".git");
         let gitDirExists = false;
         try {
             await fs.access(gitDirPath);
@@ -86,30 +123,47 @@ export async function gitInitLogic(input, context) {
         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 });
+        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: successMessage,
+            message: stdout.trim() || successMessage, // Return stdout to user if available
             path: targetPath,
-            gitDirExists: gitDirExists
+            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 });
+        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')) {
+        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 });
+            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
+                gitDirExists: true, // Assume it exists if reinit message appears
             };
         }
-        if (errorMessage.toLowerCase().includes('permission denied')) {
+        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

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

@@ -1,12 +1,12 @@
-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.';
+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('.'),
+    path: z.string().min(1).optional().default("."),
 }).shape;
 // --- Module-level State Accessors ---
 // These will be populated by the initialize function called from server.ts
@@ -34,18 +34,22 @@ export function initializeGitInitStateAccessors(getWorkingDirectory, getSessionI
  * @throws {Error} If registration fails.
  */
 export const registerGitInitTool = async (server) => {
-    const operation = 'registerGitInitTool';
+    const operation = "registerGitInitTool";
     const context = requestContextService.createRequestContext({ operation });
     await ErrorHandler.tryCatch(async () => {
         server.tool(TOOL_NAME, TOOL_DESCRIPTION, RegistrationSchema, async (validatedArgs, callContext) => {
-            const toolOperation = 'tool:git_init';
-            const requestContext = requestContextService.createRequestContext({ operation: toolOperation, parentContext: 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.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 () => {
@@ -55,7 +59,9 @@ export const registerGitInitTool = async (server) => {
                 let resolvedPath;
                 try {
                     if (path.isAbsolute(inputPath)) {
-                        resolvedPath = sanitization.sanitizePath(inputPath, { allowAbsolute: true }).sanitizedPath;
+                        resolvedPath = sanitization.sanitizePath(inputPath, {
+                            allowAbsolute: true,
+                        }).sanitizedPath;
                         logger.debug(`Using absolute path: ${resolvedPath}`, requestContext);
                     }
                     else if (sessionWorkingDirectory) {
@@ -69,10 +75,18 @@ export const registerGitInitTool = async (server) => {
                     }
                 }
                 catch (error) {
-                    logger.error('Path resolution or sanitization failed', { ...requestContext, operation: toolOperation, 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 });
+                    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,
@@ -80,9 +94,9 @@ export const registerGitInitTool = async (server) => {
                 };
                 const initResult = await gitInitLogic(logicArgs, requestContext);
                 const resultContent = {
-                    type: 'text',
+                    type: "text",
                     text: JSON.stringify(initResult, null, 2), // Pretty-print JSON
-                    contentType: 'application/json',
+                    contentType: "application/json",
                 };
                 logger.info(`Tool ${TOOL_NAME} executed successfully, returning JSON`, requestContext);
                 return { content: [resultContent] };

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

@@ -1,6 +1,6 @@
 /**
  * @fileoverview Barrel file for the gitLog tool.
  */
-export { registerGitLogTool, initializeGitLogStateAccessors } from './registration.js';
+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

@@ -1,36 +1,66 @@
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { z } from 'zod';
+import { exec } 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 { 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 { 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 { sanitization } from "../../../utils/index.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)"),
+    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 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."),
+    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.
 });
 // Delimiters for parsing the custom format
-const FIELD_SEP = '\x1f'; // Unit Separator
-const RECORD_SEP = '\x1e'; // Record Separator
+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.
@@ -41,12 +71,13 @@ const GIT_LOG_FORMAT = `--pretty=format:%H${FIELD_SEP}%an${FIELD_SEP}%ae${FIELD_
  * @throws {McpError} Throws an McpError if path resolution, validation, or the git command fails unexpectedly.
  */
 export async function logGitHistory(input, context) {
-    const operation = 'logGitHistory';
+    // Return type updated to the union
+    const operation = "logGitHistory";
     logger.debug(`Executing ${operation}`, { ...context, input });
     let targetPath;
     try {
         // Resolve and sanitize the target path
-        if (input.path && input.path !== '.') {
+        if (input.path && input.path !== ".") {
             targetPath = input.path;
         }
         else {
@@ -56,11 +87,21 @@ export async function logGitHistory(input, context) {
             }
             targetPath = workingDir;
         }
-        targetPath = sanitization.sanitizePath(targetPath, { allowAbsolute: true }).sanitizedPath;
-        logger.debug('Sanitized path', { ...context, operation, sanitizedPath: targetPath });
+        targetPath = sanitization.sanitizePath(targetPath, {
+            allowAbsolute: true,
+        }).sanitizedPath;
+        logger.debug("Sanitized path", {
+            ...context,
+            operation,
+            sanitizedPath: targetPath,
+        });
     }
     catch (error) {
-        logger.error('Path resolution or sanitization failed', { ...context, operation, 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 });
@@ -71,18 +112,21 @@ export async function logGitHistory(input, context) {
         if (input.showSignature) {
             isRawOutput = true;
             command = `git -C "${targetPath}" log --show-signature`;
-            logger.info('Show signature requested, returning raw output.', { ...context, operation });
+            logger.info("Show signature requested, returning raw output.", {
+                ...context,
+                operation,
+            });
             // Append other filters if provided
             if (input.maxCount)
                 command += ` -n ${input.maxCount}`;
             if (input.author)
-                command += ` --author="${input.author.replace(/[`"$&;*()|<>]/g, '')}"`;
+                command += ` --author="${input.author.replace(/[`"$&;*()|<>]/g, "")}"`;
             if (input.since)
-                command += ` --since="${input.since.replace(/[`"$&;*()|<>]/g, '')}"`;
+                command += ` --since="${input.since.replace(/[`"$&;*()|<>]/g, "")}"`;
             if (input.until)
-                command += ` --until="${input.until.replace(/[`"$&;*()|<>]/g, '')}"`;
+                command += ` --until="${input.until.replace(/[`"$&;*()|<>]/g, "")}"`;
             if (input.branchOrFile)
-                command += ` ${input.branchOrFile.replace(/[`"$&;*()|<>]/g, '')}`;
+                command += ` ${input.branchOrFile.replace(/[`"$&;*()|<>]/g, "")}`;
         }
         else {
             // Construct the git log command with the fixed format for parsing
@@ -92,50 +136,63 @@ export async function logGitHistory(input, context) {
         }
         if (input.author) {
             // Basic sanitization for author string
-            const safeAuthor = input.author.replace(/[`"$&;*()|<>]/g, '');
+            const safeAuthor = input.author.replace(/[`"$&;*()|<>]/g, "");
             command += ` --author="${safeAuthor}"`;
         }
         if (input.since) {
-            const safeSince = input.since.replace(/[`"$&;*()|<>]/g, '');
+            const safeSince = input.since.replace(/[`"$&;*()|<>]/g, "");
             command += ` --since="${safeSince}"`;
         }
         if (input.until) {
-            const safeUntil = input.until.replace(/[`"$&;*()|<>]/g, '');
+            const safeUntil = input.until.replace(/[`"$&;*()|<>]/g, "");
             command += ` --until="${safeUntil}"`;
         }
         if (input.branchOrFile) {
-            const safeBranchOrFile = input.branchOrFile.replace(/[`"$&;*()|<>]/g, '');
+            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
+        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
             // Exception: If showing signature, stderr about allowedSignersFile is expected, treat as info
-            if (isRawOutput && stderr.includes('allowedSignersFile needs to be configured')) {
+            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 });
+                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 });
+            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
+        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
+            if (fields.length >= 5) {
+                // Need at least hash, name, email, timestamp, subject
                 try {
                     const commitEntry = {
                         hash: fields[0],
@@ -150,7 +207,13 @@ export async function logGitHistory(input, context) {
                     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 });
+                    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
                 }
             }
@@ -182,28 +245,51 @@ export async function logGitHistory(input, context) {
         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(`${operation} completed successfully. ${message}`, { ...context, operation, path: targetPath, commitCount: commitCount, authorGroupCount: groupedCommits.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
     }
     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 || '';
+        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')) {
+        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')) {
+        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')) {
+        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 });
+        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.' };
+            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 });