@cyanheads/git-mcp-server 1.2.4 → 2.0.2

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

@@ -0,0 +1,158 @@
+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';
+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."),
+    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')"),
+});
+/**
+ * Executes git remote commands based on the specified mode.
+ *
+ * @param {GitRemoteInput} input - The validated input object.
+ * @param {RequestContext} context - The request context for logging and error handling.
+ * @returns {Promise<GitRemoteResult>} A promise that resolves with the structured result.
+ * @throws {McpError} Throws an McpError for path resolution/validation failures or unexpected errors.
+ */
+export async function gitRemoteLogic(input, context) {
+    const operation = `gitRemoteLogic:${input.mode}`;
+    logger.debug(`Executing ${operation}`, { ...context, input });
+    let targetPath;
+    try {
+        // Resolve and sanitize the target path
+        const workingDir = context.getWorkingDirectory();
+        targetPath = (input.path && input.path !== '.')
+            ? input.path
+            : workingDir ?? '.'; // Default to '.' if no working dir set and no path provided
+        if (targetPath === '.' && !workingDir) {
+            logger.warning("Executing git remote in server's CWD as no path provided and no session WD set.", { ...context, operation });
+            // Allow execution in CWD but log it clearly. Consider if an error is more appropriate.
+            // For now, let's proceed but be aware.
+            targetPath = process.cwd(); // Use actual CWD if '.' was the default
+        }
+        else if (targetPath === '.' && workingDir) {
+            targetPath = workingDir;
+            logger.debug(`Using session working directory: ${targetPath}`, { ...context, operation, sessionId: context.sessionId });
+        }
+        else {
+            logger.debug(`Using provided path: ${targetPath}`, { ...context, operation });
+        }
+        targetPath = sanitization.sanitizePath(targetPath); // Sanitize the final resolved path
+        logger.debug('Sanitized path', { ...context, operation, sanitizedPath: targetPath });
+    }
+    catch (error) {
+        logger.error('Path resolution or sanitization failed', { ...context, operation, error });
+        if (error instanceof McpError)
+            throw error;
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path: ${error instanceof Error ? error.message : String(error)}`, { context, operation, originalError: error });
+    }
+    try {
+        let command;
+        let result;
+        switch (input.mode) {
+            case 'list':
+                command = `git -C "${targetPath}" remote -v`;
+                logger.debug(`Executing command: ${command}`, { ...context, operation });
+                const { stdout: listStdout } = await execAsync(command);
+                const remotes = [];
+                const lines = listStdout.trim().split('\n');
+                const remoteMap = new Map();
+                lines.forEach(line => {
+                    const parts = line.split(/\s+/);
+                    if (parts.length >= 3) {
+                        const name = parts[0];
+                        const url = parts[1];
+                        const type = parts[2].replace(/[()]/g, ''); // Remove parentheses around (fetch) or (push)
+                        if (!remoteMap.has(name)) {
+                            remoteMap.set(name, {});
+                        }
+                        if (type === 'fetch') {
+                            remoteMap.get(name).fetchUrl = url;
+                        }
+                        else if (type === 'push') {
+                            remoteMap.get(name).pushUrl = url;
+                        }
+                    }
+                });
+                remoteMap.forEach((urls, name) => {
+                    // Ensure both URLs are present, defaulting to fetch URL if push is missing (common case)
+                    remotes.push({
+                        name,
+                        fetchUrl: urls.fetchUrl || 'N/A',
+                        pushUrl: urls.pushUrl || urls.fetchUrl || 'N/A',
+                    });
+                });
+                result = { success: true, mode: 'list', remotes };
+                break;
+            case 'add':
+                if (!input.name || !input.url) {
+                    throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Remote 'name' and 'url' are required for 'add' mode.", { context, operation });
+                }
+                // Basic validation for remote name (avoiding shell injection characters)
+                if (!/^[a-zA-Z0-9_.-]+$/.test(input.name)) {
+                    throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid remote name: ${input.name}`, { context, operation });
+                }
+                command = `git -C "${targetPath}" remote add "${input.name}" "${input.url}"`;
+                logger.debug(`Executing command: ${command}`, { ...context, operation });
+                await execAsync(command);
+                result = { success: true, mode: 'add', message: `Remote '${input.name}' added successfully.` };
+                break;
+            case 'remove':
+                if (!input.name) {
+                    throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Remote 'name' is required for 'remove' mode.", { context, operation });
+                }
+                if (!/^[a-zA-Z0-9_.-]+$/.test(input.name)) {
+                    throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid remote name: ${input.name}`, { context, operation });
+                }
+                command = `git -C "${targetPath}" remote remove "${input.name}"`;
+                logger.debug(`Executing command: ${command}`, { ...context, operation });
+                await execAsync(command);
+                result = { success: true, mode: 'remove', message: `Remote '${input.name}' removed successfully.` };
+                break;
+            case 'show':
+                if (!input.name) {
+                    throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Remote 'name' is required for 'show' mode.", { context, operation });
+                }
+                if (!/^[a-zA-Z0-9_.-]+$/.test(input.name)) {
+                    throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid remote name: ${input.name}`, { context, operation });
+                }
+                command = `git -C "${targetPath}" remote show "${input.name}"`;
+                logger.debug(`Executing command: ${command}`, { ...context, operation });
+                const { stdout: showStdout } = await execAsync(command);
+                result = { success: true, mode: 'show', details: showStdout.trim() };
+                break;
+            default:
+                // Should not happen due to Zod validation, but good practice
+                throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid mode: ${input.mode}`, { context, operation });
+        }
+        logger.info(`${operation} executed successfully`, { ...context, operation, path: targetPath });
+        return result;
+    }
+    catch (error) {
+        const errorMessage = error.stderr || error.message || '';
+        logger.error(`Failed to execute git remote command`, { ...context, operation, path: targetPath, error: errorMessage, stderr: error.stderr, stdout: error.stdout });
+        // Specific error handling
+        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 (input.mode === 'add' && errorMessage.toLowerCase().includes('already exists')) {
+            return { success: false, mode: 'add', message: `Failed to add remote: Remote '${input.name}' already exists.`, error: errorMessage };
+        }
+        if ((input.mode === 'remove' || input.mode === 'show') && errorMessage.toLowerCase().includes('no such remote')) {
+            return { success: false, mode: input.mode, message: `Failed to ${input.mode} remote: Remote '${input.name}' does not exist.`, error: errorMessage };
+        }
+        // Return structured failure for other git errors
+        return {
+            success: false,
+            mode: input.mode,
+            message: `Git remote ${input.mode} failed for path: ${targetPath}.`,
+            error: errorMessage
+        };
+    }
+}

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

@@ -0,0 +1,76 @@
+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 { GitRemoteInputSchema, gitRemoteLogic } from './logic.js';
+let _getWorkingDirectory;
+let _getSessionId;
+/**
+ * Initializes the state accessors needed by the git_remote tool registration.
+ * @param getWdFn - Function to get the working directory for a session.
+ * @param getSidFn - Function to get the session ID from context.
+ */
+export function initializeGitRemoteStateAccessors(getWdFn, getSidFn) {
+    _getWorkingDirectory = getWdFn;
+    _getSessionId = getSidFn;
+    logger.info('State accessors initialized for git_remote tool registration.');
+}
+const TOOL_NAME = 'git_remote';
+const TOOL_DESCRIPTION = 'Manages remote repositories (list, add, remove, show).';
+/**
+ * Registers the git_remote tool with the MCP server.
+ *
+ * @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 registerGitRemoteTool = async (server) => {
+    if (!_getWorkingDirectory || !_getSessionId) {
+        throw new Error('State accessors for git_remote must be initialized before registration.');
+    }
+    const operation = 'registerGitRemoteTool';
+    const context = requestContextService.createRequestContext({ operation });
+    await ErrorHandler.tryCatch(async () => {
+        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitRemoteInputSchema.shape, // Provide the Zod schema shape
+        async (validatedArgs, callContext) => {
+            const toolOperation = `tool:${TOOL_NAME}:${validatedArgs.mode}`; // Include mode in operation
+            const requestContext = requestContextService.createRequestContext({ operation: toolOperation, parentContext: callContext });
+            const sessionId = _getSessionId(requestContext);
+            const getWorkingDirectoryForSession = () => {
+                return _getWorkingDirectory(sessionId);
+            };
+            const logicContext = {
+                ...requestContext,
+                sessionId: sessionId,
+                getWorkingDirectory: getWorkingDirectoryForSession,
+            };
+            logger.info(`Executing tool: ${TOOL_NAME} (mode: ${validatedArgs.mode})`, logicContext);
+            return await ErrorHandler.tryCatch(async () => {
+                // Call the core logic function which returns a GitRemoteResult object
+                const remoteResult = await gitRemoteLogic(validatedArgs, logicContext);
+                // Format the result as a JSON string within TextContent
+                const resultContent = {
+                    type: 'text',
+                    text: JSON.stringify(remoteResult, null, 2), // Pretty-print JSON
+                    contentType: 'application/json',
+                };
+                // Log based on the success flag in the result
+                if (remoteResult.success) {
+                    logger.info(`Tool ${TOOL_NAME} (mode: ${validatedArgs.mode}) executed successfully, returning JSON`, logicContext);
+                }
+                else {
+                    // Log specific failure message from the result
+                    logger.warning(`Tool ${TOOL_NAME} (mode: ${validatedArgs.mode}) failed: ${remoteResult.message}`, { ...logicContext, errorDetails: remoteResult.error });
+                }
+                // Return the result, whether success or structured failure
+                return { content: [resultContent] };
+            }, {
+                operation: toolOperation,
+                context: logicContext,
+                input: validatedArgs,
+                errorCode: BaseErrorCode.INTERNAL_ERROR, // Default if unexpected error occurs in logic/wrapper
+            });
+        });
+        logger.info(`Tool registered: ${TOOL_NAME}`, context);
+    }, { operation, context, critical: true }); // Mark registration as critical
+};

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

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Barrel file for the gitReset tool.
+ */
+export { registerGitResetTool, initializeGitResetStateAccessors } from './registration.js';
+// Export types if needed elsewhere, e.g.:
+// export type { GitResetInput, GitResetResult } from './logic.js';

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

@@ -0,0 +1,116 @@
+import { z } from 'zod';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+import { logger } from '../../../utils/logger.js';
+import { McpError, BaseErrorCode } from '../../../types-global/errors.js';
+import { sanitization } from '../../../utils/sanitization.js';
+const execAsync = promisify(exec);
+// Define the 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."),
+    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
+});
+/**
+ * Executes the 'git reset' command and returns structured JSON output.
+ *
+ * @param {GitResetInput} input - The validated input object.
+ * @param {RequestContext} context - The request context for logging and error handling.
+ * @returns {Promise<GitResetResult>} A promise that resolves with the structured reset result.
+ * @throws {McpError} Throws an McpError if path resolution, validation, or the git command fails unexpectedly.
+ */
+export async function resetGitState(input, context) {
+    const operation = 'resetGitState';
+    logger.debug(`Executing ${operation}`, { ...context, input });
+    // Validate input combinations (e.g., file path usage) if refinement wasn't used
+    // if (input.file && input.mode && input.mode !== 'mixed') {
+    //   throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Resetting specific files is only supported with 'mixed' mode (or default).", { context, operation });
+    // }
+    // if (input.file && input.commit) {
+    //    throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Cannot specify both a commit and file paths for reset.", { context, operation });
+    // }
+    let targetPath;
+    try {
+        // Resolve and sanitize the target path
+        if (input.path && input.path !== '.') {
+            targetPath = input.path;
+        }
+        else {
+            const workingDir = context.getWorkingDirectory();
+            if (!workingDir) {
+                throw new McpError(BaseErrorCode.VALIDATION_ERROR, "No path provided and no working directory set for the session.", { context, operation });
+            }
+            targetPath = workingDir;
+        }
+        targetPath = sanitization.sanitizePath(targetPath);
+        logger.debug('Sanitized path', { ...context, operation, sanitizedPath: targetPath });
+    }
+    catch (error) {
+        logger.error('Path resolution or sanitization failed', { ...context, operation, error });
+        if (error instanceof McpError)
+            throw error;
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path: ${error instanceof Error ? error.message : String(error)}`, { context, operation, originalError: error });
+    }
+    // Basic sanitization for commit ref
+    const safeCommit = input.commit?.replace(/[`$&;*()|<>]/g, '');
+    try {
+        // Construct the git reset command
+        let command = `git -C "${targetPath}" reset`;
+        if (input.mode) {
+            command += ` --${input.mode}`;
+        }
+        if (safeCommit) {
+            command += ` ${safeCommit}`;
+        }
+        // Handling file paths requires careful command construction, often without a commit ref.
+        // Example: `git reset HEAD -- path/to/file` or `git reset -- path/to/file` (unstages)
+        // For simplicity, this initial version focuses on resetting the whole HEAD/index/tree.
+        // Add file path logic here if needed, adjusting command structure.
+        logger.debug(`Executing command: ${command}`, { ...context, operation });
+        // Execute command. Reset output is often minimal on success, but stderr might indicate issues.
+        const { stdout, stderr } = await execAsync(command);
+        logger.info(`Git reset stdout: ${stdout}`, { ...context, operation });
+        if (stderr) {
+            // Log stderr as info, as it often contains the primary status message
+            logger.info(`Git reset stderr: ${stderr}`, { ...context, operation });
+        }
+        // Analyze output (primarily stderr for reset)
+        let message = stderr.trim() || stdout.trim() || `Reset successful (mode: ${input.mode || 'mixed'}).`; // Default success message
+        let changesSummary = undefined;
+        if (stderr.includes('Unstaged changes after reset')) {
+            message = `Reset successful (mode: ${input.mode || 'mixed'}).`;
+            changesSummary = stderr; // Include the list of unstaged changes
+        }
+        else if (stderr.match(/HEAD is now at [a-f0-9]+ /)) {
+            message = stderr.trim(); // Use the direct message from git
+        }
+        else if (!stderr && !stdout) {
+            // If no output, assume success but provide context
+            message = `Reset successful (mode: ${input.mode || 'mixed'}, commit: ${input.commit || 'HEAD'}). No specific output.`;
+        }
+        logger.info(`${operation} completed successfully. ${message}`, { ...context, operation, path: targetPath });
+        return { success: true, message, changesSummary };
+    }
+    catch (error) {
+        logger.error(`Failed to execute git reset command`, { ...context, operation, path: targetPath, error: error.message, stderr: error.stderr, stdout: error.stdout });
+        const errorMessage = error.stderr || error.stdout || error.message || '';
+        // Handle specific error cases
+        if (errorMessage.toLowerCase().includes('not a git repository')) {
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`, { context, operation, originalError: error });
+        }
+        if (errorMessage.includes('fatal: bad revision') || errorMessage.includes('unknown revision')) {
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Invalid commit reference specified: '${input.commit}'. Error: ${errorMessage}`, { context, operation, originalError: error });
+        }
+        if (errorMessage.includes('Cannot reset paths') && errorMessage.includes('mode')) {
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid mode ('${input.mode}') used with file paths. Error: ${errorMessage}`, { context, operation, originalError: error });
+        }
+        if (errorMessage.includes('unmerged paths')) {
+            throw new McpError(BaseErrorCode.CONFLICT, `Cannot reset due to unmerged files. Please resolve conflicts first. Error: ${errorMessage}`, { context, operation, originalError: error });
+        }
+        // Generic internal error for other failures
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to git reset for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+    }
+}

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

@@ -0,0 +1,71 @@
+import { ErrorHandler } from '../../../utils/errorHandler.js';
+import { logger } from '../../../utils/logger.js';
+import { requestContextService } from '../../../utils/requestContext.js';
+import { GitResetInputSchema, resetGitState } from './logic.js';
+import { BaseErrorCode } from '../../../types-global/errors.js';
+let _getWorkingDirectory;
+let _getSessionId;
+/**
+ * Initializes the state accessors needed by the tool registration.
+ * This should be called once during server setup.
+ * @param getWdFn - Function to get the working directory for a session.
+ * @param getSidFn - Function to get the session ID from context.
+ */
+export function initializeGitResetStateAccessors(getWdFn, getSidFn) {
+    _getWorkingDirectory = getWdFn;
+    _getSessionId = getSidFn;
+    logger.info('State accessors initialized for git_reset tool registration.');
+}
+const TOOL_NAME = 'git_reset';
+const TOOL_DESCRIPTION = "Resets the current HEAD to a specified state. Supports different modes ('soft', 'mixed', 'hard', 'merge', 'keep') to control how the index and working tree are affected. Can reset to a specific commit. USE 'hard' MODE WITH EXTREME CAUTION as it discards local changes.";
+/**
+ * Registers the git_reset tool with the MCP server.
+ *
+ * @param {McpServer} server - The MCP server instance.
+ * @throws {Error} If state accessors are not initialized.
+ */
+export async function registerGitResetTool(server) {
+    if (!_getWorkingDirectory || !_getSessionId) {
+        throw new Error('State accessors for git_reset must be initialized before registration.');
+    }
+    const operation = 'registerGitResetTool';
+    const context = requestContextService.createRequestContext({ operation });
+    await ErrorHandler.tryCatch(async () => {
+        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitResetInputSchema.shape, // Provide the Zod schema shape
+        async (validatedArgs, callContext) => {
+            const toolOperation = 'tool:git_reset';
+            const requestContext = requestContextService.createRequestContext({ operation: toolOperation, parentContext: callContext });
+            const sessionId = _getSessionId(requestContext);
+            const getWorkingDirectoryForSession = () => {
+                return _getWorkingDirectory(sessionId);
+            };
+            const logicContext = {
+                ...requestContext,
+                sessionId: sessionId,
+                getWorkingDirectory: getWorkingDirectoryForSession,
+            };
+            logger.info(`Executing tool: ${TOOL_NAME}`, logicContext);
+            return await ErrorHandler.tryCatch(async () => {
+                // Call the core logic function
+                const resetResult = await resetGitState(validatedArgs, logicContext);
+                // Format the result as a JSON string within TextContent
+                const resultContent = {
+                    type: 'text',
+                    // Stringify the entire GitResetResult object
+                    text: JSON.stringify(resetResult, null, 2), // Pretty-print JSON
+                    contentType: 'application/json',
+                };
+                logger.info(`Tool ${TOOL_NAME} executed successfully: ${resetResult.message}`, logicContext);
+                // Success is determined by the logic function and included in the result object
+                return { content: [resultContent] };
+            }, {
+                operation: toolOperation,
+                context: logicContext,
+                input: validatedArgs,
+                errorCode: BaseErrorCode.INTERNAL_ERROR, // Default if unexpected error in logic
+            });
+        });
+        logger.info(`Tool registered: ${TOOL_NAME}`, context);
+    }, { operation, context, critical: true });
+}
+;

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

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Barrel file for the git_set_working_dir tool.
+ * Exports the registration function and potentially other related components.
+ */
+export { registerGitSetWorkingDirTool, initializeGitSetWorkingDirStateAccessors } from './registration.js';
+// Export types if needed elsewhere, e.g.:
+// export type { GitSetWorkingDirInput, GitSetWorkingDirResult } from './logic.js';

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

@@ -0,0 +1,91 @@
+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';
+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."),
+    validateGitRepo: z.boolean().default(true).describe("Whether to validate that the path is a Git repository"),
+});
+/**
+ * Logic for the git_set_working_dir tool.
+ * Sets a global working directory path for the current session.
+ * Validates the path and optionally checks if it's a Git repository.
+ *
+ * @param {GitSetWorkingDirInput} input - The validated input arguments.
+ * @param {RequestContext} context - The request context, potentially containing session ID.
+ * @returns {Promise<GitSetWorkingDirResult>} The result of the operation.
+ * @throws {McpError} Throws McpError for validation failures or operational errors.
+ */
+export async function gitSetWorkingDirLogic(input, context // Assuming context provides session info and setter
+) {
+    const operation = 'gitSetWorkingDirLogic';
+    logger.info('Executing git_set_working_dir logic', { ...context, operation, inputPath: input.path });
+    let sanitizedPath;
+    try {
+        // Sanitize the path. By default, sanitizePath allows absolute paths.
+        // It normalizes and checks for traversal issues.
+        sanitizedPath = sanitization.sanitizePath(input.path);
+        logger.debug(`Sanitized path: ${sanitizedPath}`, { ...context, operation });
+    }
+    catch (error) {
+        logger.error('Path sanitization failed', error, { ...context, operation });
+        if (error instanceof McpError)
+            throw error;
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path provided: ${error.message}`, { context, operation });
+    }
+    // Check if the directory exists
+    try {
+        const stats = await fs.stat(sanitizedPath);
+        if (!stats.isDirectory()) {
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Path is not a directory: ${sanitizedPath}`, { context, operation });
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Directory does not exist: ${sanitizedPath}`, { context, operation });
+        }
+        logger.error('Failed to stat directory', error, { ...context, operation, path: sanitizedPath });
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to access path: ${error.message}`, { context, operation });
+    }
+    // Optionally validate if it's a Git repository
+    if (input.validateGitRepo) {
+        logger.debug('Validating if path is a Git repository', { ...context, operation, path: sanitizedPath });
+        try {
+            // A common way to check is using 'git rev-parse --is-inside-work-tree'
+            // or checking for the existence of a .git directory/file.
+            // Using rev-parse is generally more robust.
+            const { stdout } = await execAsync('git rev-parse --is-inside-work-tree', { cwd: sanitizedPath });
+            if (stdout.trim() !== 'true') {
+                // This case should ideally not happen if rev-parse succeeds, but good to check.
+                throw new Error('Not a Git repository (rev-parse returned non-true)');
+            }
+            logger.debug('Path validated as Git repository', { ...context, operation, path: sanitizedPath });
+        }
+        catch (error) {
+            logger.warning('Path is not a valid Git repository', { ...context, operation, path: sanitizedPath, error: error.message });
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Path is not a valid Git repository: ${sanitizedPath}. Error: ${error.message}`, { context, operation });
+        }
+    }
+    // --- Update Session State ---
+    // This part needs access to the session state mechanism defined in server.ts
+    // We assume the context provides a way to set the working directory for the current session.
+    try {
+        context.setWorkingDirectory(sanitizedPath);
+        logger.info(`Working directory set for session ${context.sessionId || 'stdio'} to: ${sanitizedPath}`, { ...context, operation });
+    }
+    catch (error) {
+        logger.error('Failed to set working directory in session state', error, { ...context, operation });
+        // This indicates an internal logic error in how state is passed/managed.
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, 'Failed to update session state.', { context, operation });
+    }
+    return {
+        success: true,
+        message: `Working directory set to: ${sanitizedPath}`,
+        path: sanitizedPath,
+    };
+}

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

@@ -0,0 +1,78 @@
+import { ErrorHandler } from '../../../utils/errorHandler.js';
+import { logger } from '../../../utils/logger.js';
+import { requestContextService } from '../../../utils/requestContext.js';
+import { GitSetWorkingDirInputSchema, gitSetWorkingDirLogic } from './logic.js';
+import { BaseErrorCode } from '../../../types-global/errors.js';
+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.
+ */
+export function initializeGitSetWorkingDirStateAccessors(setFn, getFn) {
+    _setWorkingDirectory = setFn;
+    _getSessionId = getFn;
+    logger.info('State accessors initialized for git_set_working_dir tool registration.');
+}
+const TOOL_NAME = 'git_set_working_dir';
+const TOOL_DESCRIPTION = "Sets the default working directory for the current session. Subsequent Git tool calls within this session can use '.' for the `path` parameter, which will resolve to this directory. Optionally validates if the path is a Git repository (`validateGitRepo: true`). Returns the result as a JSON object. IMPORTANT: The provided path must be absolute.";
+/**
+ * Registers the git_set_working_dir tool with the MCP server.
+ *
+ * @param {McpServer} server - The MCP server instance.
+ * @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.');
+    }
+    try {
+        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitSetWorkingDirInputSchema.shape, // Pass the shape for SDK validation
+        async (validatedArgs, callContext) => {
+            const operation = 'tool:git_set_working_dir';
+            // Create a request context, potentially inheriting from callContext if it provides relevant info
+            const requestContext = requestContextService.createRequestContext({ operation, parentContext: callContext });
+            // Get session ID using the accessor function
+            const sessionId = _getSessionId(requestContext); // Non-null assertion as we checked initialization
+            // Define the session-specific setter function
+            const setWorkingDirectoryForSession = (path) => {
+                _setWorkingDirectory(sessionId, path); // Non-null assertion
+            };
+            // Enhance context with session ID and the setter function
+            const logicContext = {
+                ...requestContext,
+                sessionId: sessionId,
+                setWorkingDirectory: setWorkingDirectoryForSession,
+            };
+            return await ErrorHandler.tryCatch(async () => {
+                // Call the core logic function with validated args and enhanced context
+                const result = await gitSetWorkingDirLogic(validatedArgs, logicContext);
+                // Format the successful result for the MCP client
+                const responseContent = {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2), // Pretty-print JSON result
+                    contentType: 'application/json',
+                };
+                logger.info(`Tool ${TOOL_NAME} executed successfully`, { ...logicContext, result });
+                return { content: [responseContent] };
+            }, {
+                operation,
+                context: logicContext,
+                input: validatedArgs, // Log sanitized input
+                errorCode: BaseErrorCode.INTERNAL_ERROR, // Default error code if logic fails unexpectedly
+                // toolName: TOOL_NAME, // Removed as it's not part of ErrorHandlerOptions
+            });
+        });
+        logger.info(`Tool registered: ${TOOL_NAME}`);
+    }
+    catch (error) {
+        logger.error(`Failed to register tool: ${TOOL_NAME}`, {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined,
+        });
+        // Propagate the error to prevent server startup if registration fails
+        throw error;
+    }
+}

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

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