@cyanheads/git-mcp-server 2.0.1 → 2.0.3

package/{build → dist}/mcp-server/tools/gitCherryPick/logic.js

@@ -1,16 +1,19 @@
-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';
+import { promisify } from 'util';
+import { z } from 'zod';
+// Import utils from barrel (logger from ../utils/internal/logger.js)
+import { logger } from '../../../utils/index.js';
+// Import utils from barrel (RequestContext from ../utils/internal/requestContext.js)
+import { BaseErrorCode, McpError } from '../../../types-global/errors.js'; // Keep direct import for types-global
+// Import utils from barrel (sanitization from ../utils/security/sanitization.js)
+import { sanitization } from '../../../utils/index.js';
 const execAsync = promisify(exec);
 // Define the input schema for the git_cherry-pick tool using Zod
 export const GitCherryPickInputSchema = z.object({
-    path: z.string().min(1).optional().default('.').describe("Path to the local Git repository. If omitted, defaults to the path set by `git_set_working_dir` for the current session, or the server's CWD if no session path is set."),
+    path: z.string().min(1).optional().default('.').describe("Path to the local Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
     commitRef: z.string().min(1).describe("The commit reference(s) to cherry-pick (e.g., 'hash1', 'hash1..hash3', 'branchName~3..branchName')."),
     mainline: z.number().int().min(1).optional().describe("Specify the parent number (starting from 1) when cherry-picking a merge commit."),
-    strategy: z.enum(['recursive', 'resolve', 'ours', 'theirs', 'octopus', 'subtree']).optional().describe("Specifies the merge strategy to use."),
+    strategy: z.enum(['recursive', 'resolve', 'ours', 'theirs', 'octopus', 'subtree']).optional().describe("Specifies a merge strategy *option* (passed via -X)."),
     noCommit: z.boolean().default(false).describe("Apply the changes but do not create a commit."),
     signoff: z.boolean().default(false).describe("Add a Signed-off-by line to the commit message."),
     // Add options for conflict handling? (e.g., --continue, --abort, --skip) - Maybe separate tool or mode?

package/{build → dist}/mcp-server/tools/gitCherryPick/registration.js

@@ -1,8 +1,11 @@
-import { logger } from '../../../utils/logger.js';
-import { ErrorHandler } from '../../../utils/errorHandler.js';
-import { requestContextService } from '../../../utils/requestContext.js';
-import { gitCherryPickLogic, GitCherryPickInputSchema } from './logic.js';
-import { BaseErrorCode } from '../../../types-global/errors.js';
+// Import utils from barrel (logger from ../utils/internal/logger.js)
+import { logger } from '../../../utils/index.js';
+// Import utils from barrel (ErrorHandler from ../utils/internal/errorHandler.js)
+import { ErrorHandler } from '../../../utils/index.js';
+// Import utils from barrel (requestContextService 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 { GitCherryPickInputSchema, gitCherryPickLogic } from './logic.js';
 let _getWorkingDirectory;
 let _getSessionId;
 /**

package/{build → dist}/mcp-server/tools/gitClean/logic.js

@@ -1,14 +1,17 @@
-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';
+import { promisify } from 'util';
+import { z } from 'zod';
+// Import utils from barrel (logger from ../utils/internal/logger.js)
+import { logger } from '../../../utils/index.js';
+// Import utils from barrel (RequestContext from ../utils/internal/requestContext.js)
+import { BaseErrorCode, McpError } from '../../../types-global/errors.js'; // Keep direct import for types-global
+// Import utils from barrel (sanitization from ../utils/security/sanitization.js)
+import { sanitization } from '../../../utils/index.js';
 const execAsync = promisify(exec);
 // Define the input schema for the git_clean tool using Zod
 // No refinements needed here, but the 'force' check is critical in the logic
 export const GitCleanInputSchema = z.object({
-    path: z.string().min(1).optional().default('.').describe("Path to the local Git repository. If omitted, defaults to the path set by `git_set_working_dir` for the current session, or the server's CWD if no session path is set."),
+    path: z.string().min(1).optional().default('.').describe("Path to the local Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
     force: z.boolean().describe("REQUIRED confirmation to run the command. Must be explicitly set to true to perform the clean operation. If false or omitted, the command will not run."),
     dryRun: z.boolean().default(false).describe("Show what would be deleted without actually deleting (-n flag)."),
     directories: z.boolean().default(false).describe("Remove untracked directories in addition to files (-d flag)."),

package/{build → dist}/mcp-server/tools/gitClean/registration.js

@@ -1,9 +1,12 @@
-import { logger } from '../../../utils/logger.js';
-import { ErrorHandler } from '../../../utils/errorHandler.js';
-import { requestContextService } from '../../../utils/requestContext.js';
+// Import utils from barrel (logger from ../utils/internal/logger.js)
+import { logger } from '../../../utils/index.js';
+// Import utils from barrel (ErrorHandler from ../utils/internal/errorHandler.js)
+import { ErrorHandler } from '../../../utils/index.js';
+// Import utils from barrel (requestContextService from ../utils/internal/requestContext.js)
+import { requestContextService } from '../../../utils/index.js';
 // Import the schema and types
-import { gitCleanLogic, GitCleanInputSchema } from './logic.js';
-import { BaseErrorCode } from '../../../types-global/errors.js';
+import { BaseErrorCode } from '../../../types-global/errors.js'; // Keep direct import for types-global
+import { GitCleanInputSchema, gitCleanLogic } from './logic.js';
 let _getWorkingDirectory;
 let _getSessionId;
 /**

package/{build → dist}/mcp-server/tools/gitClearWorkingDir/logic.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
-import { logger } from '../../../utils/logger.js';
-import { McpError, BaseErrorCode } from '../../../types-global/errors.js';
+// Import utils from barrel (logger from ../utils/internal/logger.js)
+import { BaseErrorCode, McpError } from '../../../types-global/errors.js'; // Keep direct import for types-global
+import { logger } from '../../../utils/index.js';
 // Define the Zod schema for input validation (no arguments needed)
 export const GitClearWorkingDirInputSchema = z.object({});
 /**

package/{build → dist}/mcp-server/tools/gitClearWorkingDir/registration.js

@@ -1,8 +1,11 @@
-import { ErrorHandler } from '../../../utils/errorHandler.js';
-import { logger } from '../../../utils/logger.js';
-import { requestContextService } from '../../../utils/requestContext.js';
+// Import utils from barrel (ErrorHandler from ../utils/internal/errorHandler.js)
+import { ErrorHandler } from '../../../utils/index.js';
+// Import utils from barrel (logger from ../utils/internal/logger.js)
+import { logger } from '../../../utils/index.js';
+// Import utils from barrel (requestContextService, RequestContext from ../utils/internal/requestContext.js)
+import { BaseErrorCode } from '../../../types-global/errors.js'; // Keep direct import for types-global
+import { requestContextService } from '../../../utils/index.js';
 import { GitClearWorkingDirInputSchema, gitClearWorkingDirLogic } from './logic.js';
-import { BaseErrorCode } from '../../../types-global/errors.js';
 let _clearWorkingDirectory;
 let _getSessionId;
 /**

package/{build → dist}/mcp-server/tools/gitClone/logic.js

@@ -1,10 +1,13 @@
-import { z } from 'zod';
-import { promisify } from 'util';
 import { exec } from 'child_process';
 import fs from 'fs/promises';
-import { logger } from '../../../utils/logger.js';
-import { McpError, BaseErrorCode } from '../../../types-global/errors.js';
-import { sanitization } from '../../../utils/sanitization.js';
+import { promisify } from 'util';
+import { z } from 'zod';
+// Import utils from barrel (logger from ../utils/internal/logger.js)
+import { logger } from '../../../utils/index.js';
+// Import utils from barrel (RequestContext from ../utils/internal/requestContext.js)
+import { BaseErrorCode, McpError } from '../../../types-global/errors.js'; // Keep direct import for types-global
+// Import utils from barrel (sanitization from ../utils/security/sanitization.js)
+import { sanitization } from '../../../utils/index.js';
 const execAsync = promisify(exec);
 // Define the input schema for the git_clone tool using Zod
 export const GitCloneInputSchema = z.object({

package/{build → dist}/mcp-server/tools/gitClone/registration.js

@@ -1,8 +1,11 @@
-import { ErrorHandler } from '../../../utils/errorHandler.js';
-import { logger } from '../../../utils/logger.js';
-import { requestContextService } from '../../../utils/requestContext.js';
+// Import utils from barrel (ErrorHandler from ../utils/internal/errorHandler.js)
+import { ErrorHandler } from '../../../utils/index.js';
+// Import utils from barrel (logger from ../utils/internal/logger.js)
+import { logger } from '../../../utils/index.js';
+// Import utils from barrel (requestContextService from ../utils/internal/requestContext.js)
+import { requestContextService } from '../../../utils/index.js';
 import { GitCloneInputSchema, gitCloneLogic } from './logic.js';
-import { BaseErrorCode } from '../../../types-global/errors.js';
+import { BaseErrorCode } from '../../../types-global/errors.js'; // Keep direct import for types-global
 const TOOL_NAME = 'git_clone';
 const TOOL_DESCRIPTION = 'Clones a Git repository from a given URL into a specified absolute directory path. Supports cloning specific branches and setting clone depth.';
 /**

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

@@ -0,0 +1,207 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { z } from 'zod';
+import { BaseErrorCode, McpError } from '../../../types-global/errors.js'; // Keep direct import for types-global
+// Import utils from barrel (logger from ../utils/internal/logger.js)
+import { logger } from '../../../utils/index.js';
+// Import utils from barrel (sanitization from ../utils/security/sanitization.js)
+import { sanitization } from '../../../utils/index.js';
+// Import config to check signing flag
+import { config } from '../../../config/index.js';
+const execAsync = promisify(exec);
+// Define the input schema for the git_commit tool using Zod
+export const GitCommitInputSchema = 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."),
+    message: z.string().min(1).describe('Commit message. Follow Conventional Commits format: `type(scope): subject`. Example: `feat(api): add user signup endpoint`'),
+    author: z.object({
+        name: z.string().describe('Author name for the commit'),
+        email: z.string().email().describe('Author email for the commit'),
+    }).optional().describe('Overrides the commit author information (name and email). Use only when necessary (e.g., applying external patches).'),
+    allowEmpty: z.boolean().default(false).describe('Allow creating empty commits'),
+    amend: z.boolean().default(false).describe('Amend the previous commit instead of creating a new one'),
+    forceUnsignedOnFailure: z.boolean().default(false).describe('If true and signing is enabled but fails, attempt the commit without signing instead of failing.'),
+});
+/**
+ * Executes the 'git commit' command and returns structured JSON output.
+ *
+ * @param {GitCommitInput} input - The validated input object.
+ * @param {RequestContext} context - The request context for logging and error handling.
+ * @returns {Promise<GitCommitResult>} A promise that resolves with the structured commit result.
+ * @throws {McpError} Throws an McpError if path resolution or validation fails, or if the git command fails unexpectedly.
+ */
+export async function commitGitChanges(input, context // Add getter to context
+) {
+    const operation = 'commitGitChanges';
+    logger.debug(`Executing ${operation}`, { ...context, input });
+    let targetPath;
+    try {
+        // Resolve the target path
+        if (input.path && input.path !== '.') {
+            targetPath = input.path;
+            logger.debug(`Using provided path: ${targetPath}`, { ...context, operation });
+        }
+        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;
+            logger.debug(`Using session working directory: ${targetPath}`, { ...context, operation, sessionId: context.sessionId });
+        }
+        // Sanitize the resolved path
+        const sanitizedPath = sanitization.sanitizePath(targetPath);
+        logger.debug('Sanitized path', { ...context, operation, sanitizedPath });
+        targetPath = sanitizedPath; // Use the sanitized path going forward
+    }
+    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 {
+        // Escape message for shell safety
+        const escapeShellArg = (arg) => {
+            // Escape backslashes first, then other special chars
+            return arg.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/`/g, '\\`').replace(/\$/g, '\\$');
+        };
+        const escapedMessage = escapeShellArg(input.message);
+        // Construct the git commit command using the resolved targetPath
+        let command = `git -C "${targetPath}" commit -m "${escapedMessage}"`;
+        if (input.allowEmpty) {
+            command += ' --allow-empty';
+        }
+        if (input.amend) {
+            command += ' --amend --no-edit';
+        }
+        if (input.author) {
+            // Escape author details as well
+            const escapedAuthorName = escapeShellArg(input.author.name);
+            const escapedAuthorEmail = escapeShellArg(input.author.email); // Email typically safe, but escape anyway
+            // Use -c flags to override author for this commit, using the already escaped message
+            command = `git -C "${targetPath}" -c user.name="${escapedAuthorName}" -c user.email="${escapedAuthorEmail}" commit -m "${escapedMessage}"`;
+        }
+        // Append common flags (ensure they are appended to the potentially modified command from author block)
+        if (input.allowEmpty && !command.includes(' --allow-empty'))
+            command += ' --allow-empty';
+        if (input.amend && !command.includes(' --amend'))
+            command += ' --amend --no-edit'; // Avoid double adding if author block modified command
+        // Append signing flag if configured via GIT_SIGN_COMMITS env var
+        if (config.gitSignCommits) {
+            command += ' -S'; // Add signing flag (-S)
+            logger.info('Signing enabled via GIT_SIGN_COMMITS=true, adding -S flag.', { ...context, operation });
+        }
+        logger.debug(`Executing initial command attempt: ${command}`, { ...context, operation });
+        let stdout;
+        let stderr;
+        let commitResult;
+        try {
+            // Initial attempt (potentially with -S flag)
+            const execResult = await execAsync(command);
+            stdout = execResult.stdout;
+            stderr = execResult.stderr;
+        }
+        catch (error) {
+            const initialErrorMessage = error.stderr || error.message || '';
+            const isSigningError = initialErrorMessage.includes('gpg failed to sign') || initialErrorMessage.includes('signing failed');
+            if (isSigningError && input.forceUnsignedOnFailure) {
+                logger.warning('Initial commit attempt failed due to signing error. Retrying without signing as forceUnsignedOnFailure=true.', { ...context, operation, initialError: initialErrorMessage });
+                // Construct command *without* -S flag, using escaped message/author
+                const escapeShellArg = (arg) => {
+                    return arg.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/`/g, '\\`').replace(/\$/g, '\\$');
+                };
+                const escapedMessage = escapeShellArg(input.message);
+                let unsignedCommand = `git -C "${targetPath}" commit -m "${escapedMessage}"`;
+                if (input.allowEmpty)
+                    unsignedCommand += ' --allow-empty';
+                if (input.amend)
+                    unsignedCommand += ' --amend --no-edit';
+                if (input.author) {
+                    const escapedAuthorName = escapeShellArg(input.author.name);
+                    const escapedAuthorEmail = escapeShellArg(input.author.email);
+                    unsignedCommand = `git -C "${targetPath}" -c user.name="${escapedAuthorName}" -c user.email="${escapedAuthorEmail}" commit -m "${escapedMessage}"`;
+                    // Re-append common flags if author block overwrote command
+                    if (input.allowEmpty && !unsignedCommand.includes(' --allow-empty'))
+                        unsignedCommand += ' --allow-empty';
+                    if (input.amend && !unsignedCommand.includes(' --amend'))
+                        unsignedCommand += ' --amend --no-edit';
+                }
+                logger.debug(`Executing unsigned fallback command: ${unsignedCommand}`, { ...context, operation });
+                try {
+                    // Retry commit without signing
+                    const fallbackResult = await execAsync(unsignedCommand);
+                    stdout = fallbackResult.stdout;
+                    stderr = fallbackResult.stderr;
+                    // Add a note to the status message indicating signing was skipped
+                    commitResult = {
+                        success: true,
+                        statusMessage: `Commit successful (unsigned, signing failed): ${stdout.trim()}`, // Default message, hash parsed below
+                        commitHash: undefined // Will be parsed below
+                    };
+                }
+                catch (fallbackError) {
+                    // If the unsigned commit *also* fails, re-throw that error
+                    logger.error('Unsigned fallback commit attempt also failed.', { ...context, operation, fallbackError: fallbackError.message, stderr: fallbackError.stderr });
+                    throw fallbackError; // Re-throw the error from the unsigned attempt
+                }
+            }
+            else {
+                // If it wasn't a signing error, or forceUnsignedOnFailure is false, re-throw the original error
+                throw error;
+            }
+        }
+        // Process result (either from initial attempt or fallback)
+        // Check stderr first for common non-error messages
+        if (stderr && !commitResult) { // Don't overwrite fallback message if stderr also exists
+            if (stderr.includes('nothing to commit, working tree clean') || stderr.includes('no changes added to commit')) {
+                const msg = stderr.includes('nothing to commit') ? 'Nothing to commit, working tree clean.' : 'No changes added to commit.';
+                logger.info(msg, { ...context, operation, path: targetPath });
+                // Use statusMessage
+                return { success: true, statusMessage: msg, nothingToCommit: true };
+            }
+            // Log other stderr as warning but continue, as commit might still succeed
+            logger.warning(`Git commit command produced stderr`, { ...context, operation, stderr });
+        }
+        // Extract commit hash (more robustly)
+        let commitHash = undefined;
+        const hashMatch = stdout.match(/([a-f0-9]{7,40})/); // Look for typical short or long hash
+        if (hashMatch) {
+            commitHash = hashMatch[1];
+        }
+        else {
+            // Fallback parsing if needed, or rely on success message
+            logger.warning('Could not parse commit hash from stdout', { ...context, operation, stdout });
+        }
+        // Use statusMessage, potentially using the one set during fallback
+        const finalStatusMsg = commitResult?.statusMessage || (commitHash
+            ? `Commit successful: ${commitHash}`
+            : `Commit successful (stdout: ${stdout.trim()})`);
+        logger.info(`${operation} executed successfully`, { ...context, operation, path: targetPath, commitHash, signed: !commitResult }); // Log if it was signed (not fallback)
+        return {
+            success: true,
+            statusMessage: finalStatusMsg, // Use potentially modified message
+            commitHash: commitHash
+        };
+    }
+    catch (error) { // This catch block now primarily handles non-signing errors or errors from the fallback attempt
+        logger.error(`Failed to execute git commit command`, { ...context, operation, path: targetPath, error: error.message, stderr: error.stderr });
+        const errorMessage = error.stderr || error.message || '';
+        // Handle specific error cases first
+        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('nothing to commit') || errorMessage.includes('no changes added to commit')) {
+            // This might happen if git exits with error despite these messages
+            const msg = errorMessage.includes('nothing to commit') ? 'Nothing to commit, working tree clean.' : 'No changes added to commit.';
+            logger.info(msg + ' (caught as error)', { ...context, operation, path: targetPath, errorMessage });
+            // Return success=false but indicate the reason using statusMessage
+            return { success: false, statusMessage: msg, nothingToCommit: true };
+        }
+        if (errorMessage.includes('conflicts')) {
+            throw new McpError(BaseErrorCode.CONFLICT, `Commit failed due to unresolved conflicts in ${targetPath}`, { context, operation, originalError: error });
+        }
+        // Generic internal error for other failures
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to commit changes for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+    }
+}

package/{build → dist}/mcp-server/tools/gitCommit/registration.js

@@ -1,8 +1,11 @@
-import { ErrorHandler } from '../../../utils/errorHandler.js';
-import { logger } from '../../../utils/logger.js';
-import { requestContextService } from '../../../utils/requestContext.js';
+// Import utils from barrel (ErrorHandler from ../utils/internal/errorHandler.js)
+import { ErrorHandler } from '../../../utils/index.js';
+// Import utils from barrel (logger from ../utils/internal/logger.js)
+import { logger } from '../../../utils/index.js';
+// Import utils from barrel (requestContextService from ../utils/internal/requestContext.js)
+import { requestContextService } from '../../../utils/index.js';
 // Import the result type along with the function and input schema
-import { BaseErrorCode } from '../../../types-global/errors.js'; // Import BaseErrorCode
+import { BaseErrorCode } from '../../../types-global/errors.js'; // Keep direct import for types-global
 import { commitGitChanges, GitCommitInputSchema } from './logic.js';
 let _getWorkingDirectory;
 let _getSessionId;
@@ -26,28 +29,32 @@ Write clear, concise commit messages using the Conventional Commits format: \`ty
 - \`(scope)\`: Optional context (e.g., \`auth\`, \`ui\`, filename).
 - \`subject\`: Imperative, present tense description (e.g., "add login button", not "added login button").
 
+I want to understand what you did and why. Use the body for detailed explanations, if necessary.
+
 **Example Commit Message:**
 \`\`\`
 feat(auth): implement password reset endpoint
 
-Adds the /api/auth/reset-password endpoint to allow users
-to reset their password via an email link. Includes input
-validation and rate limiting.
+- Adds the /api/auth/reset-password endpoint to allow users to reset their password via an email link. 
+- Includes input validation and rate limiting.
 
 Closes #123 (if applicable).
 \`\`\`
 
 **Best Practice:** Commit related changes together in logical units. If you've modified multiple files for a single feature or fix, stage and commit them together with a message that describes the overall change.
 
-**Path Handling:** If the 'path' parameter is omitted or set to '.', the tool uses the working directory set by 'git_set_working_dir'. Providing a full, absolute path overrides this default and ensures explicitness.`;
+**Path Handling:** If the 'path' parameter is omitted or set to '.', the tool uses the working directory set by 'git_set_working_dir'. Providing a full, absolute path overrides this default and ensures explicitness.
+
+**Commit Signing:** If the server is configured with the \`GIT_SIGN_COMMITS=true\` environment variable, this tool adds the \`-S\` flag to the \`git commit\` command, requesting a signature. Signing requires proper GPG or SSH key setup and Git configuration on the server machine.
+- **Fallback:** If signing is enabled but fails (e.g., key not found, agent issue), the commit will **fail by default**. However, if the optional \`forceUnsignedOnFailure: true\` parameter is provided in the tool call, the tool will attempt the commit again *without* the \`-S\` flag, resulting in an unsigned commit.`;
 /**
- * Registers the git_commit tool with the MCP server.
- * Uses the high-level server.tool() method for registration, schema validation, and routing.
- *
- * @param {McpServer} server - The McpServer instance to register the tool with.
- * @returns {Promise<void>}
- * @throws {Error} If registration fails or state accessors are not initialized.
- */
+* Registers the git_commit tool with the MCP server.
+* Uses the high-level server.tool() method for registration, schema validation, and routing.
+*
+* @param {McpServer} server - The McpServer instance to register the tool with.
+* @returns {Promise<void>}
+* @throws {Error} If registration fails or state accessors are not initialized.
+*/
 export const registerGitCommitTool = async (server) => {
     if (!_getWorkingDirectory || !_getSessionId) {
         throw new Error('State accessors for git_commit must be initialized before registration.');

package/{build → dist}/mcp-server/tools/gitDiff/logic.js

@@ -1,13 +1,16 @@
-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';
+import { promisify } from 'util';
+import { z } from 'zod';
+// Import utils from barrel (logger from ../utils/internal/logger.js)
+import { logger } from '../../../utils/index.js';
+// Import utils from barrel (RequestContext from ../utils/internal/requestContext.js)
+import { BaseErrorCode, McpError } from '../../../types-global/errors.js'; // Keep direct import for types-global
+// Import utils from barrel (sanitization from ../utils/security/sanitization.js)
+import { sanitization } from '../../../utils/index.js';
 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 session's working directory if set."),
+    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."),

package/{build → dist}/mcp-server/tools/gitDiff/registration.js

@@ -1,9 +1,12 @@
-import { ErrorHandler } from '../../../utils/errorHandler.js';
-import { logger } from '../../../utils/logger.js';
-import { requestContextService } from '../../../utils/requestContext.js';
+// Import utils from barrel (ErrorHandler from ../utils/internal/errorHandler.js)
+import { ErrorHandler } from '../../../utils/index.js';
+// Import utils from barrel (logger from ../utils/internal/logger.js)
+import { logger } from '../../../utils/index.js';
+// Import utils from barrel (requestContextService, RequestContext from ../utils/internal/requestContext.js)
+import { requestContextService } from '../../../utils/index.js';
 // Import the shape and the final schema/types
-import { GitDiffInputShape, diffGitChanges } from './logic.js';
-import { BaseErrorCode } from '../../../types-global/errors.js';
+import { BaseErrorCode } from '../../../types-global/errors.js'; // Keep direct import for types-global
+import { diffGitChanges, GitDiffInputShape } from './logic.js';
 let _getWorkingDirectory;
 let _getSessionId;
 /**

package/{build → dist}/mcp-server/tools/gitFetch/logic.js

@@ -1,13 +1,16 @@
-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';
+import { promisify } from 'util';
+import { z } from 'zod';
+// Import utils from barrel (logger from ../utils/internal/logger.js)
+import { logger } from '../../../utils/index.js';
+// Import utils from barrel (RequestContext from ../utils/internal/requestContext.js)
+import { BaseErrorCode, McpError } from '../../../types-global/errors.js'; // Keep direct import for types-global
+// Import utils from barrel (sanitization from ../utils/security/sanitization.js)
+import { sanitization } from '../../../utils/index.js';
 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."),
+    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)."),
@@ -99,7 +102,7 @@ export async function fetchGitRemote(input, context) {
             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 });
+            throw new McpError(BaseErrorCode.SERVICE_UNAVAILABLE, `Failed to connect to remote repository '${input.remote || 'default'}'. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
         if (errorMessage.includes('fatal: ') && errorMessage.includes('couldn\'t find remote ref')) {
             throw new McpError(BaseErrorCode.NOT_FOUND, `Remote ref not found. Error: ${errorMessage}`, { context, operation, originalError: error });

package/{build → dist}/mcp-server/tools/gitFetch/registration.js

@@ -1,8 +1,11 @@
-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';
+// Import utils from barrel (ErrorHandler from ../utils/internal/errorHandler.js)
+import { ErrorHandler } from '../../../utils/index.js';
+// Import utils from barrel (logger from ../utils/internal/logger.js)
+import { logger } from '../../../utils/index.js';
+// Import utils from barrel (requestContextService, RequestContext from ../utils/internal/requestContext.js)
+import { BaseErrorCode } from '../../../types-global/errors.js'; // Keep direct import for types-global
+import { requestContextService } from '../../../utils/index.js';
+import { fetchGitRemote, GitFetchInputSchema } from './logic.js';
 let _getWorkingDirectory;
 let _getSessionId;
 /**

package/{build → dist}/mcp-server/tools/gitInit/index.js

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

package/{build → dist}/mcp-server/tools/gitInit/logic.js

@@ -1,15 +1,18 @@
-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';
+import { promisify } from 'util';
+import { z } from 'zod';
+// Import utils from barrel (logger from ../utils/internal/logger.js)
+import { logger } from '../../../utils/index.js';
+// Import utils from barrel (RequestContext from ../utils/internal/requestContext.js)
+import { BaseErrorCode, McpError } from '../../../types-global/errors.js'; // Keep direct import for types-global
+// Import utils from barrel (sanitization from ../utils/security/sanitization.js)
+import { sanitization } from '../../../utils/index.js';
 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."),
+    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."),