@cyanheads/git-mcp-server 2.0.1 → 2.0.3

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

@@ -0,0 +1,98 @@
+import path from 'path';
+import { z } from 'zod';
+import { BaseErrorCode, McpError } from '../../../types-global/errors.js';
+import { ErrorHandler, logger, requestContextService, sanitization } from '../../../utils/index.js';
+import { GitInitInputSchema, gitInitLogic } from './logic.js';
+const TOOL_NAME = 'git_init';
+const TOOL_DESCRIPTION = 'Initializes a new Git repository at the specified path. If path is relative or omitted, it resolves against the session working directory (if you have set the git_working_dir). Can optionally set the initial branch name and create a bare repository.';
+const RegistrationSchema = GitInitInputSchema.extend({
+    path: z.string().min(1).optional().default('.'),
+}).shape;
+// --- Module-level State Accessors ---
+// These will be populated by the initialize function called from server.ts
+let _getWorkingDirectory = () => undefined;
+let _getSessionIdFromContext = () => undefined;
+/**
+ * Initializes state accessor functions for the git_init tool.
+ * This function is called by the main server setup to provide the tool
+ * with a way to access session-specific state (like the working directory)
+ * without needing direct access to the server or transport layer internals.
+ *
+ * @param getWorkingDirectory - Function to retrieve the working directory for a given session ID.
+ * @param getSessionIdFromContext - Function to extract the session ID from a tool's execution context.
+ */
+export function initializeGitInitStateAccessors(getWorkingDirectory, getSessionIdFromContext) {
+    _getWorkingDirectory = getWorkingDirectory;
+    _getSessionIdFromContext = getSessionIdFromContext;
+    logger.debug(`State accessors initialized for ${TOOL_NAME}`);
+}
+/**
+ * Registers the git_init tool with the MCP server.
+ *
+ * @param {McpServer} server - The McpServer instance to register the tool with.
+ * @returns {Promise<void>}
+ * @throws {Error} If registration fails.
+ */
+export const registerGitInitTool = async (server) => {
+    const operation = 'registerGitInitTool';
+    const context = requestContextService.createRequestContext({ operation });
+    await ErrorHandler.tryCatch(async () => {
+        server.tool(TOOL_NAME, TOOL_DESCRIPTION, RegistrationSchema, async (validatedArgs, callContext) => {
+            const toolOperation = 'tool:git_init';
+            const requestContext = requestContextService.createRequestContext({ operation: toolOperation, parentContext: callContext });
+            // Use the initialized accessor to get the session ID
+            const sessionId = _getSessionIdFromContext(requestContext); // Pass the created context
+            if (!sessionId && !path.isAbsolute(validatedArgs.path)) {
+                // If path is relative, we NEED a session ID to resolve against a potential working dir
+                logger.error('Session ID is missing in context, cannot resolve relative path', requestContext);
+                throw new McpError(BaseErrorCode.INTERNAL_ERROR, 'Session context is unavailable for relative path resolution.', { context: requestContext, operation: toolOperation });
+            }
+            logger.info(`Executing tool: ${TOOL_NAME}`, requestContext);
+            return await ErrorHandler.tryCatch(async () => {
+                // Use the initialized accessor to get the working directory
+                const sessionWorkingDirectory = _getWorkingDirectory(sessionId);
+                const inputPath = validatedArgs.path;
+                let resolvedPath;
+                try {
+                    if (path.isAbsolute(inputPath)) {
+                        resolvedPath = sanitization.sanitizePath(inputPath);
+                        logger.debug(`Using absolute path: ${resolvedPath}`, requestContext);
+                    }
+                    else if (sessionWorkingDirectory) {
+                        resolvedPath = sanitization.sanitizePath(path.resolve(sessionWorkingDirectory, inputPath));
+                        logger.debug(`Resolved relative path '${inputPath}' to absolute path: ${resolvedPath} using session CWD`, requestContext);
+                    }
+                    else {
+                        // This case should now only be hit if the path is relative AND there's no session CWD set.
+                        logger.error(`Relative path '${inputPath}' provided but no session working directory is set.`, requestContext);
+                        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Relative path '${inputPath}' provided but no session working directory is set. Please provide an absolute path or set a working directory using git_set_working_dir.`, { context: requestContext, operation: toolOperation });
+                    }
+                }
+                catch (error) {
+                    logger.error('Path resolution or sanitization failed', { ...requestContext, operation: toolOperation, error });
+                    if (error instanceof McpError)
+                        throw error;
+                    throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path processing: ${error instanceof Error ? error.message : String(error)}`, { context: requestContext, operation: toolOperation, originalError: error });
+                }
+                const logicArgs = {
+                    ...validatedArgs,
+                    path: resolvedPath,
+                };
+                const initResult = await gitInitLogic(logicArgs, requestContext);
+                const resultContent = {
+                    type: 'text',
+                    text: JSON.stringify(initResult, null, 2), // Pretty-print JSON
+                    contentType: 'application/json',
+                };
+                logger.info(`Tool ${TOOL_NAME} executed successfully, returning JSON`, requestContext);
+                return { content: [resultContent] };
+            }, {
+                operation: toolOperation,
+                context: requestContext,
+                input: validatedArgs,
+                errorCode: BaseErrorCode.INTERNAL_ERROR,
+            });
+        });
+        logger.info(`Tool registered: ${TOOL_NAME}`, context);
+    }, { operation, context, critical: true });
+};

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

@@ -1,9 +1,12 @@
-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 structure for a single commit entry
 export const CommitEntrySchema = z.object({
@@ -16,13 +19,14 @@ export const CommitEntrySchema = z.object({
 });
 // Define the input schema for the git_log tool using Zod
 export const GitLogInputSchema = z.object({
-    path: z.string().min(1).optional().default('.').describe("Path to the Git repository. Defaults to the session's working directory if set."),
+    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, tag, or file path."),
-    // Note: We use a fixed pretty format for reliable parsing. Custom formats are not directly supported via input.
+    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
@@ -62,11 +66,29 @@ export async function logGitHistory(input, context) {
         throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path: ${error instanceof Error ? error.message : String(error)}`, { context, operation, originalError: error });
     }
     try {
-        // Construct the git log command
-        // Use a specific format for reliable parsing
-        let command = `git -C "${targetPath}" log ${GIT_LOG_FORMAT}`;
-        if (input.maxCount) {
-            command += ` -n ${input.maxCount}`;
+        let command;
+        let isRawOutput = false; // Flag to indicate if we should parse or return raw
+        if (input.showSignature) {
+            isRawOutput = true;
+            command = `git -C "${targetPath}" log --show-signature`;
+            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, '')}"`;
+            if (input.since)
+                command += ` --since="${input.since.replace(/[`"$&;*()|<>]/g, '')}"`;
+            if (input.until)
+                command += ` --until="${input.until.replace(/[`"$&;*()|<>]/g, '')}"`;
+            if (input.branchOrFile)
+                command += ` ${input.branchOrFile.replace(/[`"$&;*()|<>]/g, '')}`;
+        }
+        else {
+            // Construct the git log command with the fixed format for parsing
+            command = `git -C "${targetPath}" log ${GIT_LOG_FORMAT}`;
+            if (input.maxCount)
+                command += ` -n ${input.maxCount}`;
         }
         if (input.author) {
             // Basic sanitization for author string
@@ -90,13 +112,28 @@ export async function logGitHistory(input, context) {
         const { stdout, stderr } = await execAsync(command, { maxBuffer: 1024 * 1024 * 10 }); // 10MB buffer
         if (stderr) {
             // Log stderr as warning, as git log might sometimes use it for non-fatal info
-            logger.warning(`Git log stderr: ${stderr}`, { ...context, operation });
+            // Exception: If showing signature, stderr about allowedSignersFile is expected, treat as info
+            if (isRawOutput && stderr.includes('allowedSignersFile needs to be configured')) {
+                logger.info(`Git log stderr (signature verification note): ${stderr.trim()}`, { ...context, operation });
+            }
+            else {
+                logger.warning(`Git log stderr: ${stderr.trim()}`, { ...context, operation });
+            }
+        }
+        // If raw output was requested, return it directly
+        if (isRawOutput) {
+            const message = `Raw log output (showSignature=true):\n${stdout}`;
+            logger.info(`${operation} completed successfully (raw output).`, { ...context, operation, path: targetPath });
+            return { success: true, commits: [], message: message };
         }
-        // Parse the output
+        // Otherwise, parse the structured output
         const commits = [];
         const commitRecords = stdout.split(RECORD_SEP).filter(record => record.trim() !== ''); // Split records and remove empty ones
         for (const record of commitRecords) {
-            const fields = record.split(FIELD_SEP);
+            const trimmedRecord = record.trim(); // Trim leading/trailing whitespace (like newlines)
+            if (!trimmedRecord)
+                continue; // Skip empty records after trimming
+            const fields = trimmedRecord.split(FIELD_SEP); // Split the trimmed record
             if (fields.length >= 5) { // Need at least hash, name, email, timestamp, subject
                 try {
                     const commitEntry = {

package/{build → dist}/mcp-server/tools/gitLog/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 { GitLogInputSchema, logGitHistory } from './logic.js';
-import { BaseErrorCode } from '../../../types-global/errors.js';
 let _getWorkingDirectory;
 let _getSessionId;
 /**
@@ -17,7 +20,7 @@ export function initializeGitLogStateAccessors(getWdFn, getSidFn) {
     logger.info('State accessors initialized for git_log tool registration.');
 }
 const TOOL_NAME = 'git_log';
-const TOOL_DESCRIPTION = "Shows commit logs for the repository. Supports limiting count, filtering by author, date range, and specific branch/file. Returns a list of commit objects.";
+const TOOL_DESCRIPTION = "Shows commit logs for the repository. Supports limiting count, filtering by author, date range, and specific branch/file. Returns a list of commit objects by default. Can optionally show signature verification status (`showSignature: true`), which returns raw text output instead of JSON.";
 /**
  * Registers the git_log tool with the MCP server.
  *

package/{build → dist}/mcp-server/tools/gitMerge/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 path from 'path'; // Import path module
+import { sanitization } from '../../../utils/index.js';
 const execAsync = promisify(exec);
 // Define the input schema for the git_merge tool
 export const GitMergeInputSchema = 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."),
     branch: z.string().min(1).describe('The name of the branch to merge into the current branch.'),
     commitMessage: z.string().optional().describe('Commit message to use for the merge commit (if required, e.g., not fast-forward).'),
     noFf: z.boolean().default(false).describe('Create a merge commit even when the merge resolves as a fast-forward (`--no-ff`).'),

package/{build → dist}/mcp-server/tools/gitMerge/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 { gitMergeLogic, GitMergeInputSchema } 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 { GitMergeInputSchema, gitMergeLogic } from './logic.js';
 let _getWorkingDirectory;
 let _getSessionId;
 /**

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

@@ -1,15 +1,18 @@
-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_pull tool using Zod
 export const GitPullInputSchema = 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 pull from (e.g., 'origin'). Defaults to the tracked upstream or 'origin'."),
-    branch: z.string().optional().describe("The remote branch to pull. Defaults to the current branch's upstream."),
+    branch: z.string().optional().describe("The remote branch to pull (e.g., 'main'). Defaults to the current branch's upstream."),
     rebase: z.boolean().optional().default(false).describe("Use 'git pull --rebase' instead of merge."),
     ffOnly: z.boolean().optional().default(false).describe("Use '--ff-only' to only allow fast-forward merges."),
     // Add other relevant git pull options as needed (e.g., --prune, --tags, --depth)
@@ -125,7 +128,7 @@ export async function pullGitChanges(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')) {
-            throw new McpError(BaseErrorCode.NETWORK_ERROR, `Failed to connect to remote repository. Error: ${errorMessage}`, { context, operation, originalError: error });
+            throw new McpError(BaseErrorCode.SERVICE_UNAVAILABLE, `Failed to connect to remote repository. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
         if (errorMessage.includes('merge conflict') || errorMessage.includes('fix conflicts')) {
             // This might be caught here if execAsync throws due to non-zero exit code during conflict

package/{build → dist}/mcp-server/tools/gitPull/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 { GitPullInputSchema, pullGitChanges } from './logic.js';
-import { BaseErrorCode } from '../../../types-global/errors.js';
 let _getWorkingDirectory;
 let _getSessionId;
 /**

package/{build → dist}/mcp-server/tools/gitPush/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_push tool using Zod
 export const GitPushInputSchema = 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 push to (e.g., 'origin'). Defaults to the tracked upstream or 'origin'."),
-    branch: z.string().optional().describe("The local branch to push. Defaults to the current branch."),
-    remoteBranch: z.string().optional().describe("The remote branch to push to. Defaults to the same name as the local branch."),
+    branch: z.string().optional().describe("The local branch to push (e.g., 'main', 'feat/new-login'). Defaults to the current branch."),
+    remoteBranch: z.string().optional().describe("The remote branch to push to (e.g., 'main', 'develop'). Defaults to the same name as the local branch."),
     force: z.boolean().optional().default(false).describe("Force the push (use with caution: `--force-with-lease` is generally safer)."),
     forceWithLease: z.boolean().optional().default(false).describe("Force the push only if the remote ref is the expected value (`--force-with-lease`). Safer than --force."),
     setUpstream: z.boolean().optional().default(false).describe("Set the upstream tracking configuration (`-u` or `--set-upstream`)."),
@@ -169,7 +172,7 @@ export async function pushGitChanges(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. Error: ${errorMessage}`, { context, operation, originalError: error });
+            throw new McpError(BaseErrorCode.SERVICE_UNAVAILABLE, `Failed to connect to remote repository. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
         if (errorMessage.includes('rejected') || errorMessage.includes('failed to push some refs')) {
             // This might be caught here if execAsync throws due to non-zero exit code on rejection

package/{build → dist}/mcp-server/tools/gitPush/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 { GitPushInputSchema, pushGitChanges } from './logic.js';
-import { BaseErrorCode } from '../../../types-global/errors.js';
 let _getWorkingDirectory;
 let _getSessionId;
 /**

package/{build → dist}/mcp-server/tools/gitRebase/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 for the git_rebase tool using Zod
 export const GitRebaseBaseSchema = 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."),
     mode: z.enum(['start', 'continue', 'abort', 'skip']).default('start').describe("Rebase operation mode: 'start' (initiate rebase), 'continue', 'abort', 'skip' (manage ongoing rebase)."),
     upstream: z.string().min(1).optional().describe("The upstream branch or commit to rebase onto. Required for 'start' mode unless 'interactive' is true with default base."),
     branch: z.string().min(1).optional().describe("The branch to rebase. Defaults to the current branch if omitted."),

package/{build → dist}/mcp-server/tools/gitRebase/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 { gitRebaseLogic, GitRebaseBaseSchema } 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 { GitRebaseBaseSchema, gitRebaseLogic } from './logic.js';
 let _getWorkingDirectory;
 let _getSessionId;
 /**

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

@@ -1,16 +1,15 @@
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { z } from 'zod';
-import { BaseErrorCode, McpError } from '../../../types-global/errors.js';
-import { logger } from '../../../utils/logger.js';
-import { sanitization } from '../../../utils/sanitization.js';
+import { BaseErrorCode, McpError } from '../../../types-global/errors.js'; // Direct import for types-global
+import { logger, sanitization } from '../../../utils/index.js'; // Logger (./utils/internal/logger.js) & RequestContext (./utils/internal/requestContext.js) & sanitization (./utils/security/sanitization.js)
 const execAsync = promisify(exec);
 // Define the input schema for the git_remote tool using Zod
 export const GitRemoteInputSchema = 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."),
     mode: z.enum(['list', 'add', 'remove', 'show']).describe("Operation mode: 'list', 'add', 'remove', 'show'"),
     name: z.string().min(1).optional().describe("Remote name (required for 'add', 'remove', 'show')"),
-    url: z.string().url().optional().describe("Remote URL (required for 'add')"),
+    url: z.string().optional().describe("Remote URL (required for 'add')"), // Removed .url() validation
 });
 /**
  * Executes git remote commands based on the specified mode.

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

@@ -1,7 +1,5 @@
-import { BaseErrorCode } from '../../../types-global/errors.js';
-import { ErrorHandler } from '../../../utils/errorHandler.js';
-import { logger } from '../../../utils/logger.js';
-import { requestContextService } from '../../../utils/requestContext.js';
+import { BaseErrorCode } from '../../../types-global/errors.js'; // Direct import for types-global
+import { ErrorHandler, logger, requestContextService } from '../../../utils/index.js'; // ErrorHandler (./utils/internal/errorHandler.js), logger (./utils/internal/logger.js), requestContextService (./utils/internal/requestContext.js)
 import { GitRemoteInputSchema, gitRemoteLogic } from './logic.js';
 let _getWorkingDirectory;
 let _getSessionId;

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

@@ -1,15 +1,14 @@
-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 { BaseErrorCode, McpError } from '../../../types-global/errors.js'; // Direct import for types-global
+import { logger, sanitization } from '../../../utils/index.js'; // logger (./utils/internal/logger.js), RequestContext (./utils/internal/requestContext.js), sanitization (./utils/security/sanitization.js)
 const execAsync = promisify(exec);
 // Define the reset modes
 const ResetModeEnum = z.enum(['soft', 'mixed', 'hard', 'merge', 'keep']);
 // Define the input schema for the git_reset tool using Zod
 export const GitResetInputSchema = 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."),
     mode: ResetModeEnum.optional().default('mixed').describe("Reset mode: 'soft' (reset HEAD only), 'mixed' (reset HEAD and index, default), 'hard' (reset HEAD, index, and working tree - USE WITH CAUTION), 'merge', 'keep'."),
     commit: z.string().optional().describe("Commit, branch, or ref to reset to. Defaults to HEAD (useful for unstaging with 'mixed' mode)."),
     // file: z.string().optional().describe("If specified, reset only this file in the index (unstaging). Mode must be 'mixed' or omitted."), // Git reset [<mode>] [<tree-ish>] [--] <paths>… is complex, handle separately if needed

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

@@ -1,8 +1,6 @@
-import { ErrorHandler } from '../../../utils/errorHandler.js';
-import { logger } from '../../../utils/logger.js';
-import { requestContextService } from '../../../utils/requestContext.js';
+import { BaseErrorCode } from '../../../types-global/errors.js'; // Direct import for types-global
+import { ErrorHandler, logger, requestContextService } from '../../../utils/index.js'; // ErrorHandler (./utils/internal/errorHandler.js), logger (./utils/internal/logger.js), requestContextService & RequestContext (./utils/internal/requestContext.js)
 import { GitResetInputSchema, resetGitState } from './logic.js';
-import { BaseErrorCode } from '../../../types-global/errors.js';
 let _getWorkingDirectory;
 let _getSessionId;
 /**

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

@@ -1,14 +1,13 @@
-import { z } from 'zod';
 import { exec } from 'child_process';
-import { promisify } from 'util';
 import fs from 'fs/promises';
-import { McpError, BaseErrorCode } from '../../../types-global/errors.js';
-import { logger } from '../../../utils/logger.js';
-import { sanitization } from '../../../utils/sanitization.js';
+import { promisify } from 'util';
+import { z } from 'zod';
+import { BaseErrorCode, McpError } from '../../../types-global/errors.js'; // Direct import for types-global
+import { logger, sanitization } from '../../../utils/index.js'; // RequestContext (./utils/internal/requestContext.js), logger (./utils/internal/logger.js), sanitization (./utils/security/sanitization.js)
 const execAsync = promisify(exec);
 // Define the Zod schema for input validation
 export const GitSetWorkingDirInputSchema = z.object({
-    path: z.string().min(1, "Path cannot be empty.").describe("The absolute path to set as the default working directory for the current session."),
+    path: z.string().min(1, "Path cannot be empty.").describe("The absolute path to set as the default working directory for the current session. Set this before using other git_* tools."),
     validateGitRepo: z.boolean().default(true).describe("Whether to validate that the path is a Git repository"),
 });
 /**

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

@@ -1,19 +1,21 @@
-import { ErrorHandler } from '../../../utils/errorHandler.js';
-import { logger } from '../../../utils/logger.js';
-import { requestContextService } from '../../../utils/requestContext.js';
+import { BaseErrorCode } from '../../../types-global/errors.js'; // Direct import for types-global
+import { ErrorHandler, logger, requestContextService } from '../../../utils/index.js'; // ErrorHandler (./utils/internal/errorHandler.js), logger (./utils/internal/logger.js), requestContextService & RequestContext (./utils/internal/requestContext.js)
 import { GitSetWorkingDirInputSchema, gitSetWorkingDirLogic } from './logic.js';
-import { BaseErrorCode } from '../../../types-global/errors.js';
+let _getWorkingDirectory; // Added getter
 let _setWorkingDirectory;
 let _getSessionId;
 /**
  * Initializes the state accessors needed by the tool registration.
  * This should be called once during server setup.
- * @param setFn - Function to set the working directory for a session.
- * @param getFn - Function to get the session ID from context.
+ * @param getWdFn - Function to get the working directory for a session.
+ * @param setWdFn - Function to set the working directory for a session.
+ * @param getSidFn - Function to get the session ID from context.
  */
-export function initializeGitSetWorkingDirStateAccessors(setFn, getFn) {
-    _setWorkingDirectory = setFn;
-    _getSessionId = getFn;
+export function initializeGitSetWorkingDirStateAccessors(getWdFn, // Added getter parameter
+setWdFn, getSidFn) {
+    _getWorkingDirectory = getWdFn; // Store getter
+    _setWorkingDirectory = setWdFn;
+    _getSessionId = getSidFn;
     logger.info('State accessors initialized for git_set_working_dir tool registration.');
 }
 const TOOL_NAME = 'git_set_working_dir';
@@ -25,8 +27,9 @@ const TOOL_DESCRIPTION = "Sets the default working directory for the current ses
  * @throws {Error} If state accessors are not initialized.
  */
 export async function registerGitSetWorkingDirTool(server) {
-    if (!_setWorkingDirectory || !_getSessionId) {
-        throw new Error('State accessors for git_set_working_dir must be initialized before registration.');
+    // Check all required accessors
+    if (!_getWorkingDirectory || !_setWorkingDirectory || !_getSessionId) {
+        throw new Error('State accessors (getWD, setWD, getSID) for git_set_working_dir must be initialized before registration.');
     }
     try {
         server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitSetWorkingDirInputSchema.shape, // Pass the shape for SDK validation
@@ -40,11 +43,17 @@ export async function registerGitSetWorkingDirTool(server) {
             const setWorkingDirectoryForSession = (path) => {
                 _setWorkingDirectory(sessionId, path); // Non-null assertion
             };
-            // Enhance context with session ID and the setter function
+            // Define the session-specific getter function (needed by logic?)
+            // If the logic needs the current WD, pass the getter too. Assuming it might.
+            const getWorkingDirectoryForSession = () => {
+                return _getWorkingDirectory(sessionId); // Non-null assertion
+            };
+            // Enhance context with session ID and the getter/setter functions
             const logicContext = {
                 ...requestContext,
                 sessionId: sessionId,
-                setWorkingDirectory: setWorkingDirectoryForSession,
+                getWorkingDirectory: getWorkingDirectoryForSession, // Pass getter
+                setWorkingDirectory: setWorkingDirectoryForSession, // Pass setter
             };
             return await ErrorHandler.tryCatch(async () => {
                 // Call the core logic function with validated args and enhanced context