@cyanheads/git-mcp-server 2.1.0 → 2.1.2

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

@@ -1,27 +1,49 @@
-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 base input schema without refinement
 const GitDiffInputBaseSchema = 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."),
-    commit1: z.string().optional().describe("First commit, branch, or ref for comparison. If omitted, compares against the working tree or index (depending on 'staged')."),
-    commit2: z.string().optional().describe("Second commit, branch, or ref for comparison. If omitted, compares commit1 against the working tree or index."),
-    staged: z.boolean().optional().default(false).describe("Show diff of changes staged for the next commit (compares index against HEAD). Overrides commit1/commit2 if true."),
-    file: z.string().optional().describe("Limit the diff output to a specific file path."),
-    includeUntracked: z.boolean().optional().default(false).describe("Include untracked files in the diff output (shows their full content as new files). This is a non-standard extension."),
+    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."),
+    commit1: z
+        .string()
+        .optional()
+        .describe("First commit, branch, or ref for comparison. If omitted, compares against the working tree or index (depending on 'staged')."),
+    commit2: z
+        .string()
+        .optional()
+        .describe("Second commit, branch, or ref for comparison. If omitted, compares commit1 against the working tree or index."),
+    staged: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Show diff of changes staged for the next commit (compares index against HEAD). Overrides commit1/commit2 if true."),
+    file: z
+        .string()
+        .optional()
+        .describe("Limit the diff output to a specific file path."),
+    includeUntracked: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Include untracked files in the diff output (shows their full content as new files). This is a non-standard extension."),
     // Add options like --name-only, --stat, context lines (-U<n>) if needed
 });
 // Export the shape for registration
 export const GitDiffInputShape = GitDiffInputBaseSchema.shape;
 // Define the final schema with refinement for validation during execution
-export const GitDiffInputSchema = GitDiffInputBaseSchema.refine(data => !(data.staged && (data.commit1 || data.commit2)), {
+export const GitDiffInputSchema = GitDiffInputBaseSchema.refine((data) => !(data.staged && (data.commit1 || data.commit2)), {
     message: "Cannot use 'staged' option with specific commit references (commit1 or commit2).",
     path: ["staged", "commit1", "commit2"], // Indicate related fields
 });
@@ -34,12 +56,12 @@ export const GitDiffInputSchema = GitDiffInputBaseSchema.refine(data => !(data.s
  * @throws {McpError} Throws an McpError if path resolution, validation, or the git command fails unexpectedly.
  */
 export async function diffGitChanges(input, context) {
-    const operation = 'diffGitChanges';
+    const operation = "diffGitChanges";
     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 {
@@ -49,26 +71,36 @@ export async function diffGitChanges(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 });
     }
     // Basic sanitization for refs and file path
-    const safeCommit1 = input.commit1?.replace(/[`$&;*()|<>]/g, '');
-    const safeCommit2 = input.commit2?.replace(/[`$&;*()|<>]/g, '');
-    const safeFile = input.file?.replace(/[`$&;*()|<>]/g, '');
-    let untrackedFilesDiff = '';
+    const safeCommit1 = input.commit1?.replace(/[`$&;*()|<>]/g, "");
+    const safeCommit2 = input.commit2?.replace(/[`$&;*()|<>]/g, "");
+    const safeFile = input.file?.replace(/[`$&;*()|<>]/g, "");
+    let untrackedFilesDiff = "";
     let untrackedFilesCount = 0;
     try {
         // Construct the standard git diff command
         let standardDiffCommand = `git -C "${targetPath}" diff`;
         if (input.staged) {
-            standardDiffCommand += ' --staged'; // Or --cached
+            standardDiffCommand += " --staged"; // Or --cached
         }
         else {
             // Add commit references if not doing staged diff
@@ -85,25 +117,38 @@ export async function diffGitChanges(input, context) {
         if (safeFile) {
             standardDiffCommand += ` -- "${safeFile}"`; // Use '--' to separate paths from revisions
         }
-        logger.debug(`Executing standard diff command: ${standardDiffCommand}`, { ...context, operation });
+        logger.debug(`Executing standard diff command: ${standardDiffCommand}`, {
+            ...context,
+            operation,
+        });
         const { stdout: standardStdout, stderr: standardStderr } = await execAsync(standardDiffCommand, { maxBuffer: 1024 * 1024 * 20 });
         if (standardStderr) {
-            logger.warning(`Git diff (standard) stderr: ${standardStderr}`, { ...context, operation });
+            logger.warning(`Git diff (standard) stderr: ${standardStderr}`, {
+                ...context,
+                operation,
+            });
         }
         let combinedDiffOutput = standardStdout;
         // Handle untracked files if requested
         if (input.includeUntracked) {
-            logger.debug('Including untracked files.', { ...context, operation });
+            logger.debug("Including untracked files.", { ...context, operation });
             const listUntrackedCommand = `git -C "${targetPath}" ls-files --others --exclude-standard`;
             try {
                 const { stdout: untrackedFilesStdOut } = await execAsync(listUntrackedCommand);
-                const untrackedFiles = untrackedFilesStdOut.trim().split('\n').filter(f => f); // Filter out empty lines
+                const untrackedFiles = untrackedFilesStdOut
+                    .trim()
+                    .split("\n")
+                    .filter((f) => f); // Filter out empty lines
                 if (untrackedFiles.length > 0) {
-                    logger.info(`Found ${untrackedFiles.length} untracked files.`, { ...context, operation, untrackedFiles });
-                    let individualUntrackedDiffs = '';
+                    logger.info(`Found ${untrackedFiles.length} untracked files.`, {
+                        ...context,
+                        operation,
+                        untrackedFiles,
+                    });
+                    let individualUntrackedDiffs = "";
                     for (const untrackedFile of untrackedFiles) {
                         // Sanitize each untracked file path before using in command
-                        const safeUntrackedFile = untrackedFile.replace(/[`$&;*()|<>]/g, '');
+                        const safeUntrackedFile = untrackedFile.replace(/[`$&;*()|<>]/g, "");
                         // Skip if file path becomes empty after sanitization (unlikely but safe)
                         if (!safeUntrackedFile)
                             continue;
@@ -127,7 +172,16 @@ export async function diffGitChanges(input, context) {
                             }
                             else {
                                 // If stdout is empty, then it's a more genuine failure.
-                                logger.warning(`Failed to diff untracked file: ${safeUntrackedFile}. Error: ${untrackedError.message}`, { ...context, operation, file: safeUntrackedFile, errorDetails: { stderr: untrackedError.stderr, stdout: untrackedError.stdout, code: untrackedError.code } });
+                                logger.warning(`Failed to diff untracked file: ${safeUntrackedFile}. Error: ${untrackedError.message}`, {
+                                    ...context,
+                                    operation,
+                                    file: safeUntrackedFile,
+                                    errorDetails: {
+                                        stderr: untrackedError.stderr,
+                                        stdout: untrackedError.stdout,
+                                        code: untrackedError.code,
+                                    },
+                                });
                                 individualUntrackedDiffs += `\n--- Diff for untracked file ${safeUntrackedFile} failed: ${untrackedError.message}\n`;
                             }
                         }
@@ -135,43 +189,69 @@ export async function diffGitChanges(input, context) {
                     if (individualUntrackedDiffs) {
                         // Add a separator if standard diff also had output
                         if (combinedDiffOutput.trim()) {
-                            combinedDiffOutput += '\n';
+                            combinedDiffOutput += "\n";
                         }
                         combinedDiffOutput += individualUntrackedDiffs;
                     }
                 }
                 else {
-                    logger.info('No untracked files found.', { ...context, operation });
+                    logger.info("No untracked files found.", { ...context, operation });
                 }
             }
             catch (lsFilesError) {
-                logger.warning(`Failed to list untracked files. Error: ${lsFilesError.message}`, { ...context, operation, error: lsFilesError.stderr || lsFilesError.stdout });
+                logger.warning(`Failed to list untracked files. Error: ${lsFilesError.message}`, {
+                    ...context,
+                    operation,
+                    error: lsFilesError.stderr || lsFilesError.stdout,
+                });
                 // Proceed without untracked files if listing fails
             }
         }
-        const isNoChanges = combinedDiffOutput.trim() === '';
-        const finalDiffOutput = isNoChanges ? 'No changes found.' : combinedDiffOutput;
-        let message = isNoChanges ? 'No changes found.' : 'Diff generated successfully.';
+        const isNoChanges = combinedDiffOutput.trim() === "";
+        const finalDiffOutput = isNoChanges
+            ? "No changes found."
+            : combinedDiffOutput;
+        let message = isNoChanges
+            ? "No changes found."
+            : "Diff generated successfully.";
         if (untrackedFilesCount > 0) {
             message += ` Included ${untrackedFilesCount} untracked file(s).`;
         }
-        logger.info(`${operation} completed successfully. ${message}`, { ...context, operation, path: targetPath });
-        return { success: true, diff: finalDiffOutput, message, untrackedFilesProcessed: untrackedFilesCount };
+        logger.info(message, {
+            ...context,
+            operation,
+            path: targetPath,
+            untrackedFilesProcessed: untrackedFilesCount,
+        });
+        return {
+            success: true,
+            diff: finalDiffOutput,
+            message,
+            untrackedFilesProcessed: untrackedFilesCount,
+        };
     }
     catch (error) {
         // This catch block now primarily handles errors from the *standard* diff command
         // or catastrophic failures before/after untracked file processing.
-        logger.error(`Failed to execute git diff operation`, { ...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 diff operation`, {
+            ...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 object') || errorMessage.includes('unknown revision or path not in the working tree')) {
+        if (errorMessage.includes("fatal: bad object") ||
+            errorMessage.includes("unknown revision or path not in the working tree")) {
             const invalidRef = input.commit1 || input.commit2 || input.file;
             throw new McpError(BaseErrorCode.NOT_FOUND, `Invalid commit reference or file path specified: '${invalidRef}'. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        if (errorMessage.includes('ambiguous argument')) {
+        if (errorMessage.includes("ambiguous argument")) {
             const ambiguousArg = input.commit1 || input.commit2 || input.file;
             throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Ambiguous argument provided: '${ambiguousArg}'. Error: ${errorMessage}`, { context, operation, originalError: error });
         }

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

@@ -1,12 +1,12 @@
 // Import utils from barrel (ErrorHandler from ../utils/internal/errorHandler.js)
-import { ErrorHandler } from '../../../utils/index.js';
+import { ErrorHandler } from "../../../utils/index.js";
 // 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 (requestContextService, RequestContext from ../utils/internal/requestContext.js)
-import { requestContextService } from '../../../utils/index.js';
+import { requestContextService } from "../../../utils/index.js";
 // Import the shape and the final schema/types
-import { BaseErrorCode } from '../../../types-global/errors.js'; // Keep direct import for types-global
-import { diffGitChanges, GitDiffInputShape } from './logic.js';
+import { BaseErrorCode } from "../../../types-global/errors.js"; // Keep direct import for types-global
+import { diffGitChanges, GitDiffInputShape, } from "./logic.js";
 let _getWorkingDirectory;
 let _getSessionId;
 /**
@@ -18,9 +18,9 @@ let _getSessionId;
 export function initializeGitDiffStateAccessors(getWdFn, getSidFn) {
     _getWorkingDirectory = getWdFn;
     _getSessionId = getSidFn;
-    logger.info('State accessors initialized for git_diff tool registration.');
+    logger.info("State accessors initialized for git_diff tool registration.");
 }
-const TOOL_NAME = 'git_diff';
+const TOOL_NAME = "git_diff";
 const TOOL_DESCRIPTION = "Shows changes between commits, commit and working tree, etc. Can show staged changes or diff specific files. An optional 'includeUntracked' parameter (boolean) can be used to also show the content of untracked files. Returns the diff output as plain text.";
 /**
  * Registers the git_diff tool with the MCP server.
@@ -30,16 +30,19 @@ const TOOL_DESCRIPTION = "Shows changes between commits, commit and working tree
  */
 export async function registerGitDiffTool(server) {
     if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error('State accessors for git_diff must be initialized before registration.');
+        throw new Error("State accessors for git_diff must be initialized before registration.");
     }
-    const operation = 'registerGitDiffTool';
+    const operation = "registerGitDiffTool";
     const context = requestContextService.createRequestContext({ operation });
     await ErrorHandler.tryCatch(async () => {
         // Use the exported shape for registration
         server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitDiffInputShape, // Provide the Zod base schema shape
         async (validatedArgs, callContext) => {
-            const toolOperation = 'tool:git_diff';
-            const requestContext = requestContextService.createRequestContext({ operation: toolOperation, parentContext: callContext });
+            const toolOperation = "tool:git_diff";
+            const requestContext = requestContextService.createRequestContext({
+                operation: toolOperation,
+                parentContext: callContext,
+            });
             const sessionId = _getSessionId(requestContext);
             const getWorkingDirectoryForSession = () => {
                 return _getWorkingDirectory(sessionId);
@@ -55,11 +58,11 @@ export async function registerGitDiffTool(server) {
                 const diffResult = await diffGitChanges(validatedArgs, logicContext);
                 // Format the result (the diff string) as plain text within TextContent
                 const resultContent = {
-                    type: 'text',
+                    type: "text",
                     // Return the raw diff output directly
                     text: diffResult.diff,
                     // Indicate the content type is plain text diff
-                    contentType: 'text/plain; charset=utf-8', // Or 'text/x-diff'
+                    contentType: "text/plain; charset=utf-8", // Or 'text/x-diff'
                 };
                 logger.info(`Tool ${TOOL_NAME} executed successfully: ${diffResult.message}`, logicContext);
                 // Success is determined by the logic function
@@ -74,4 +77,3 @@ export async function registerGitDiffTool(server) {
         logger.info(`Tool registered: ${TOOL_NAME}`, context);
     }, { operation, context, critical: true });
 }
-;

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

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

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

@@ -1,19 +1,35 @@
-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 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 directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
-    remote: z.string().optional().describe("The remote repository to fetch from (e.g., 'origin'). If omitted, fetches from 'origin' or the default configured remote."),
-    prune: z.boolean().optional().default(false).describe("Before fetching, remove any remote-tracking references that no longer exist on the remote."),
-    tags: z.boolean().optional().default(false).describe("Fetch all tags from the remote (in addition to whatever else is fetched)."),
+    path: z
+        .string()
+        .min(1)
+        .optional()
+        .default(".")
+        .describe("Path to the Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
+    remote: z
+        .string()
+        .optional()
+        .describe("The remote repository to fetch from (e.g., 'origin'). If omitted, fetches from 'origin' or the default configured remote."),
+    prune: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Before fetching, remove any remote-tracking references that no longer exist on the remote."),
+    tags: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Fetch all tags from the remote (in addition to whatever else is fetched)."),
     all: z.boolean().optional().default(false).describe("Fetch all remotes."),
     // Add options like --depth, specific refspecs if needed
 });
@@ -26,12 +42,12 @@ export const GitFetchInputSchema = z.object({
  * @throws {McpError} Throws an McpError if path resolution, validation, or the git command fails unexpectedly.
  */
 export async function fetchGitRemote(input, context) {
-    const operation = 'fetchGitRemote';
+    const operation = "fetchGitRemote";
     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 {
@@ -41,28 +57,38 @@ export async function fetchGitRemote(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 });
     }
     // Basic sanitization for remote name
-    const safeRemote = input.remote?.replace(/[^a-zA-Z0-9_.\-/]/g, '');
+    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';
+            command += " --prune";
         }
         if (input.tags) {
-            command += ' --tags';
+            command += " --tags";
         }
         if (input.all) {
-            command += ' --all';
+            command += " --all";
         }
         else if (safeRemote) {
             command += ` ${safeRemote}`; // Fetch specific remote if 'all' is not used
@@ -71,47 +97,50 @@ export async function fetchGitRemote(input, context) {
         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).';
+        logger.debug(`Git fetch stdout: ${stdout}`, { ...context, operation }); // stdout is usually empty
+        if (stderr) {
+            logger.debug(`Git fetch stderr: ${stderr}`, { ...context, operation }); // stderr contains fetch details
         }
-        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 });
+        // Analyze stderr for success/summary
+        const message = "Fetch successful.";
+        const summary = stderr.trim() || "No changes detected.";
+        logger.info(message, {
+            ...context,
+            operation,
+            path: targetPath,
+            summary,
+        });
         return { success: true, message, summary };
     }
     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 || '';
+        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')) {
+        if (errorMessage.toLowerCase().includes("not a git repository")) {
             throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`, { context, operation, originalError: error });
         }
-        if (errorMessage.includes('resolve host') || errorMessage.includes('Could not read from remote repository') || errorMessage.includes('Connection timed out')) {
-            throw new McpError(BaseErrorCode.SERVICE_UNAVAILABLE, `Failed to connect to remote repository '${input.remote || 'default'}'. Error: ${errorMessage}`, { context, operation, originalError: error });
+        if (errorMessage.includes("resolve host") ||
+            errorMessage.includes("Could not read from remote repository") ||
+            errorMessage.includes("Connection timed out")) {
+            throw new McpError(BaseErrorCode.SERVICE_UNAVAILABLE, `Failed to connect to remote repository '${input.remote || "default"}'. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        if (errorMessage.includes('fatal: ') && errorMessage.includes('couldn\'t find remote ref')) {
+        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("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 });
+        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

@@ -1,11 +1,11 @@
 // Import utils from barrel (ErrorHandler from ../utils/internal/errorHandler.js)
-import { ErrorHandler } from '../../../utils/index.js';
+import { ErrorHandler } from "../../../utils/index.js";
 // 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 (requestContextService, RequestContext from ../utils/internal/requestContext.js)
-import { BaseErrorCode } from '../../../types-global/errors.js'; // Keep direct import for types-global
-import { requestContextService } from '../../../utils/index.js';
-import { fetchGitRemote, GitFetchInputSchema } from './logic.js';
+import { BaseErrorCode } from "../../../types-global/errors.js"; // Keep direct import for types-global
+import { requestContextService } from "../../../utils/index.js";
+import { fetchGitRemote, GitFetchInputSchema, } from "./logic.js";
 let _getWorkingDirectory;
 let _getSessionId;
 /**
@@ -17,9 +17,9 @@ let _getSessionId;
 export function initializeGitFetchStateAccessors(getWdFn, getSidFn) {
     _getWorkingDirectory = getWdFn;
     _getSessionId = getSidFn;
-    logger.info('State accessors initialized for git_fetch tool registration.');
+    logger.info("State accessors initialized for git_fetch tool registration.");
 }
-const TOOL_NAME = 'git_fetch';
+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.
@@ -29,15 +29,18 @@ const TOOL_DESCRIPTION = "Downloads objects and refs from one or more other repo
  */
 export async function registerGitFetchTool(server) {
     if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error('State accessors for git_fetch must be initialized before registration.');
+        throw new Error("State accessors for git_fetch must be initialized before registration.");
     }
-    const operation = 'registerGitFetchTool';
+    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 toolOperation = "tool:git_fetch";
+            const requestContext = requestContextService.createRequestContext({
+                operation: toolOperation,
+                parentContext: callContext,
+            });
             const sessionId = _getSessionId(requestContext);
             const getWorkingDirectoryForSession = () => {
                 return _getWorkingDirectory(sessionId);
@@ -53,10 +56,10 @@ export async function registerGitFetchTool(server) {
                 const fetchResult = await fetchGitRemote(validatedArgs, logicContext);
                 // Format the result as a JSON string within TextContent
                 const resultContent = {
-                    type: 'text',
+                    type: "text",
                     // Stringify the entire GitFetchResult object
                     text: JSON.stringify(fetchResult, null, 2), // Pretty-print JSON
-                    contentType: 'application/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
@@ -71,4 +74,3 @@ export async function registerGitFetchTool(server) {
         logger.info(`Tool registered: ${TOOL_NAME}`, context);
     }, { operation, context, critical: true });
 }
-;

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

@@ -2,6 +2,6 @@
  * @fileoverview Barrel file for the git_init tool.
  * Exports the registration function and the state accessor initializer.
  */
-export { registerGitInitTool, initializeGitInitStateAccessors } from './registration.js';
+export { registerGitInitTool, initializeGitInitStateAccessors, } from "./registration.js";
 // Export types if needed elsewhere, e.g.:
 // export type { GitInitInput, GitInitResult } from './logic.js';