@cyanheads/git-mcp-server 1.2.4 → 2.0.2

package/dist/mcp-server/tools/gitCheckout/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 { GitCheckoutInputSchema, checkoutGit } 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 initializeGitCheckoutStateAccessors(getWdFn, getSidFn) {
+    _getWorkingDirectory = getWdFn;
+    _getSessionId = getSidFn;
+    logger.info('State accessors initialized for git_checkout tool registration.');
+}
+const TOOL_NAME = 'git_checkout';
+const TOOL_DESCRIPTION = "Switches branches or restores working tree files. Can checkout branches, commits, tags, or specific file paths. Supports creating new branches and forcing checkout.";
+/**
+ * Registers the git_checkout tool with the MCP server.
+ *
+ * @param {McpServer} server - The MCP server instance.
+ * @throws {Error} If state accessors are not initialized.
+ */
+export async function registerGitCheckoutTool(server) {
+    if (!_getWorkingDirectory || !_getSessionId) {
+        throw new Error('State accessors for git_checkout must be initialized before registration.');
+    }
+    const operation = 'registerGitCheckoutTool';
+    const context = requestContextService.createRequestContext({ operation });
+    await ErrorHandler.tryCatch(async () => {
+        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitCheckoutInputSchema.shape, // Provide the Zod schema shape
+        async (validatedArgs, callContext) => {
+            const toolOperation = 'tool:git_checkout';
+            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 checkoutResult = await checkoutGit(validatedArgs, logicContext);
+                // Format the result as a JSON string within TextContent
+                const resultContent = {
+                    type: 'text',
+                    text: JSON.stringify(checkoutResult, null, 2), // Pretty-print JSON
+                    contentType: 'application/json',
+                };
+                // Log based on the success flag in the result
+                if (checkoutResult.success) {
+                    logger.info(`Tool ${TOOL_NAME} executed successfully: ${checkoutResult.message}`, logicContext);
+                }
+                else {
+                    // Log non-fatal conditions like conflicts differently if needed
+                    logger.info(`Tool ${TOOL_NAME} completed with status: ${checkoutResult.message}`, logicContext);
+                }
+                // Even if success is false (e.g., due to conflicts reported by logic),
+                // it's not a tool execution error unless the logic threw an McpError.
+                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/gitCherryPick/index.js

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

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

@@ -0,0 +1,115 @@
+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 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."),
+    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."),
+    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?
+});
+/**
+ * Executes the 'git cherry-pick' command.
+ *
+ * @param {GitCherryPickInput} input - The validated input object.
+ * @param {RequestContext} context - The request context for logging and error handling.
+ * @returns {Promise<GitCherryPickResult>} A promise that resolves with the structured result.
+ * @throws {McpError} Throws an McpError for path resolution/validation failures or unexpected errors.
+ */
+export async function gitCherryPickLogic(input, context) {
+    const operation = 'gitCherryPickLogic';
+    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 ?? '.';
+        if (targetPath === '.' && !workingDir) {
+            logger.warning("Executing git cherry-pick in server's CWD as no path provided and no session WD set.", { ...context, operation });
+            targetPath = process.cwd();
+        }
+        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);
+        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 = `git -C "${targetPath}" cherry-pick`;
+        if (input.mainline)
+            command += ` -m ${input.mainline}`;
+        if (input.strategy)
+            command += ` -X${input.strategy}`; // Note: -X for strategy options
+        if (input.noCommit)
+            command += ' --no-commit';
+        if (input.signoff)
+            command += ' --signoff';
+        // Add the commit reference(s) - ensure it's treated as a single argument potentially containing special chars like '..'
+        command += ` "${input.commitRef.replace(/"/g, '\\"')}"`;
+        logger.debug(`Executing command: ${command}`, { ...context, operation });
+        try {
+            const { stdout, stderr } = await execAsync(command);
+            // Check stdout/stderr for conflict messages, although exit code 0 usually means success
+            const output = stdout + stderr;
+            const conflicts = /conflict/i.test(output);
+            const commitCreated = !input.noCommit && !conflicts;
+            const message = conflicts
+                ? `Cherry-pick resulted in conflicts for commit(s) '${input.commitRef}'. Manual resolution required.`
+                : `Successfully cherry-picked commit(s) '${input.commitRef}'.` + (commitCreated ? ' New commit created.' : (input.noCommit ? ' Changes staged.' : ''));
+            logger.info(message, { ...context, operation, path: targetPath, conflicts, commitCreated });
+            return { success: true, message, commitCreated, conflicts };
+        }
+        catch (cherryPickError) {
+            const errorMessage = cherryPickError.stderr || cherryPickError.stdout || cherryPickError.message || '';
+            if (/conflict/i.test(errorMessage)) {
+                logger.warning(`Cherry-pick failed due to conflicts for commit(s) '${input.commitRef}'.`, { ...context, operation, path: targetPath, error: errorMessage });
+                return { success: false, message: `Failed to cherry-pick commit(s) '${input.commitRef}' due to conflicts. Resolve conflicts manually and potentially use 'git cherry-pick --continue' or '--abort'.`, error: errorMessage, conflicts: true };
+            }
+            // Rethrow other errors to be caught by the outer try-catch
+            throw cherryPickError;
+        }
+    }
+    catch (error) {
+        const errorMessage = error.stderr || error.stdout || error.message || '';
+        logger.error(`Failed to execute git cherry-pick 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 (/bad revision/i.test(errorMessage)) {
+            return { success: false, message: `Failed to cherry-pick: Invalid commit reference '${input.commitRef}'.`, error: errorMessage };
+        }
+        if (/after resolving the conflicts/i.test(errorMessage)) {
+            // This might indicate a previous conflict state
+            return { success: false, message: `Failed to cherry-pick: Unresolved conflicts from a previous operation exist. Resolve conflicts and use 'git cherry-pick --continue' or '--abort'.`, error: errorMessage, conflicts: true };
+        }
+        if (/your local changes would be overwritten/i.test(errorMessage)) {
+            return { success: false, message: `Failed to cherry-pick: Your local changes to tracked files would be overwritten. Please commit or stash them.`, error: errorMessage };
+        }
+        // Return structured failure for other git errors
+        return {
+            success: false,
+            message: `Git cherry-pick failed for path: ${targetPath}.`,
+            error: errorMessage
+        };
+    }
+}

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

@@ -0,0 +1,69 @@
+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';
+let _getWorkingDirectory;
+let _getSessionId;
+/**
+ * Initializes the state accessors needed by the git_cherry_pick 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 initializeGitCherryPickStateAccessors(getWdFn, getSidFn) {
+    _getWorkingDirectory = getWdFn;
+    _getSessionId = getSidFn;
+    logger.info('State accessors initialized for git_cherry_pick tool registration.');
+}
+const TOOL_NAME = 'git_cherry_pick';
+const TOOL_DESCRIPTION = 'Applies the changes introduced by existing commits. Supports picking single commits or ranges, handling merge commits, and options like --no-commit and --signoff. Returns results as a JSON object, indicating success, failure, or conflicts.';
+/**
+ * Registers the git_cherry_pick 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 registerGitCherryPickTool = async (server) => {
+    if (!_getWorkingDirectory || !_getSessionId) {
+        throw new Error('State accessors for git_cherry_pick must be initialized before registration.');
+    }
+    const operation = 'registerGitCherryPickTool';
+    const context = requestContextService.createRequestContext({ operation });
+    await ErrorHandler.tryCatch(async () => {
+        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitCherryPickInputSchema.shape, async (validatedArgs, callContext) => {
+            const toolInput = validatedArgs;
+            const toolOperation = `tool:${TOOL_NAME}`;
+            const requestContext = requestContextService.createRequestContext({ operation: toolOperation, parentContext: callContext });
+            const sessionId = _getSessionId(requestContext);
+            const getWorkingDirectoryForSession = () => _getWorkingDirectory(sessionId);
+            const logicContext = {
+                ...requestContext,
+                sessionId: sessionId,
+                getWorkingDirectory: getWorkingDirectoryForSession,
+            };
+            logger.info(`Executing tool: ${TOOL_NAME}`, logicContext);
+            return await ErrorHandler.tryCatch(async () => {
+                const cherryPickResult = await gitCherryPickLogic(toolInput, logicContext);
+                const resultContent = {
+                    type: 'text',
+                    text: JSON.stringify(cherryPickResult, null, 2), // Pretty-print JSON
+                    contentType: 'application/json',
+                };
+                if (cherryPickResult.success) {
+                    logger.info(`Tool ${TOOL_NAME} executed successfully (Conflicts: ${!!cherryPickResult.conflicts}), returning JSON`, logicContext);
+                }
+                else {
+                    logger.warning(`Tool ${TOOL_NAME} failed: ${cherryPickResult.message}`, { ...logicContext, errorDetails: cherryPickResult.error, conflicts: cherryPickResult.conflicts });
+                }
+                return { content: [resultContent] };
+            }, {
+                operation: toolOperation,
+                context: logicContext,
+                input: validatedArgs,
+                errorCode: BaseErrorCode.INTERNAL_ERROR,
+            });
+        });
+        logger.info(`Tool registered: ${TOOL_NAME}`, context);
+    }, { operation, context, critical: true });
+};

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

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

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

@@ -0,0 +1,110 @@
+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 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."),
+    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)."),
+    ignored: z.boolean().default(false).describe("Remove ignored files as well (-x flag). Use with extreme caution."),
+    // exclude: z.string().optional().describe("Exclude files matching pattern (-e <pattern>)"), // Consider adding later
+});
+/**
+ * Executes the 'git clean' command to remove untracked files.
+ * CRITICAL: Requires the 'force' parameter to be explicitly true.
+ *
+ * @param {GitCleanInput} input - The validated input object.
+ * @param {RequestContext} context - The request context for logging and error handling.
+ * @returns {Promise<GitCleanResult>} A promise that resolves with the structured result.
+ * @throws {McpError} Throws an McpError for path/validation failures, if force=false, or unexpected errors.
+ */
+export async function gitCleanLogic(input, context) {
+    const operation = 'gitCleanLogic';
+    logger.debug(`Executing ${operation}`, { ...context, input });
+    // --- CRITICAL SAFETY CHECK ---
+    if (!input.force) {
+        logger.error("Attempted to run git clean without force=true.", { ...context, operation });
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Operation aborted: 'force' parameter must be explicitly set to true to execute 'git clean'. This is a destructive command.", { context, operation });
+    }
+    // Log that the force check passed
+    logger.warning("Executing 'git clean' with force=true. This is a destructive operation.", { ...context, operation });
+    let targetPath;
+    try {
+        // Resolve and sanitize the target path
+        const workingDir = context.getWorkingDirectory();
+        targetPath = (input.path && input.path !== '.')
+            ? input.path
+            : workingDir ?? '.';
+        if (targetPath === '.' && !workingDir) {
+            logger.warning("Executing git clean in server's CWD as no path provided and no session WD set.", { ...context, operation });
+            targetPath = process.cwd();
+        }
+        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);
+        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 {
+        // Construct the command
+        // Force (-f) is always added because the logic checks input.force
+        let command = `git -C "${targetPath}" clean -f`;
+        if (input.dryRun) {
+            command += ' -n';
+        }
+        if (input.directories) {
+            command += ' -d';
+        }
+        if (input.ignored) {
+            command += ' -x';
+        }
+        logger.debug(`Executing command: ${command}`, { ...context, operation });
+        const { stdout, stderr } = await execAsync(command);
+        if (stderr) {
+            // Log stderr as warning, as git clean might report non-fatal issues here
+            logger.warning(`Git clean command produced stderr`, { ...context, operation, stderr });
+        }
+        // Parse stdout to list affected files
+        const filesAffected = stdout.trim().split('\n')
+            .map(line => line.replace(/^Would remove /i, '').replace(/^Removing /i, '').trim()) // Clean up prefixes
+            .filter(file => file); // Remove empty lines
+        const message = input.dryRun
+            ? `Dry run complete. Files that would be removed: ${filesAffected.length}`
+            : `Clean operation complete. Files removed: ${filesAffected.length}`;
+        logger.info(`${operation} executed successfully`, { ...context, operation, path: targetPath, dryRun: input.dryRun, filesAffectedCount: filesAffected.length });
+        return { success: true, message, filesAffected, dryRun: input.dryRun };
+    }
+    catch (error) {
+        const errorMessage = error.stderr || error.message || '';
+        logger.error(`Failed to execute git clean 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 });
+        }
+        // Git clean usually doesn't fail with specific messages like others,
+        // but returns non-zero exit code on general failure.
+        // Return structured failure for other git errors
+        return {
+            success: false,
+            message: `Git clean failed for path: ${targetPath}.`,
+            error: errorMessage,
+            dryRun: input.dryRun // Still report dryRun status
+        };
+    }
+}

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

@@ -0,0 +1,98 @@
+import { logger } from '../../../utils/logger.js';
+import { ErrorHandler } from '../../../utils/errorHandler.js';
+import { requestContextService } from '../../../utils/requestContext.js';
+// Import the schema and types
+import { gitCleanLogic, GitCleanInputSchema } from './logic.js';
+import { BaseErrorCode } from '../../../types-global/errors.js';
+let _getWorkingDirectory;
+let _getSessionId;
+/**
+ * Initializes the state accessors needed by the git_clean 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 initializeGitCleanStateAccessors(getWdFn, getSidFn) {
+    _getWorkingDirectory = getWdFn;
+    _getSessionId = getSidFn;
+    logger.info('State accessors initialized for git_clean tool registration.');
+}
+const TOOL_NAME = 'git_clean';
+const TOOL_DESCRIPTION = 'Removes untracked files from the working directory. Supports dry runs, removing directories, and removing ignored files. CRITICAL: Requires explicit `force: true` parameter for safety as this is a destructive operation. Returns results as a JSON object.';
+/**
+ * Registers the git_clean 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 registerGitCleanTool = async (server) => {
+    if (!_getWorkingDirectory || !_getSessionId) {
+        throw new Error('State accessors for git_clean must be initialized before registration.');
+    }
+    const operation = 'registerGitCleanTool';
+    const context = requestContextService.createRequestContext({ operation });
+    await ErrorHandler.tryCatch(async () => {
+        // Register the tool using the schema's shape (no refinements here)
+        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitCleanInputSchema.shape, // Use the shape directly
+        // Let TypeScript infer handler argument types.
+        async (validatedArgs, callContext) => {
+            // Cast validatedArgs to the specific input type for use within the handler
+            const toolInput = validatedArgs;
+            const toolOperation = `tool:${TOOL_NAME}`;
+            const requestContext = requestContextService.createRequestContext({ operation: toolOperation, parentContext: callContext });
+            // --- SAFETY CHECK (Redundant but good practice) ---
+            // The core logic already checks this, but adding a check here ensures
+            // the intent is clear even before calling the logic.
+            if (!toolInput.force) {
+                logger.error(`Tool ${TOOL_NAME} called without force=true. Aborting.`, requestContext);
+                // Return a structured error via CallToolResult
+                const errorContent = {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: false,
+                        message: "Operation aborted: 'force' parameter must be explicitly set to true to execute 'git clean'.",
+                        dryRun: toolInput.dryRun // Include dryRun status
+                    }, null, 2),
+                    contentType: 'application/json',
+                };
+                return { content: [errorContent], isError: true }; // Indicate it's an error result
+            }
+            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 which returns a GitCleanResult object
+                const cleanResult = await gitCleanLogic(toolInput, logicContext);
+                // Format the result as JSON within TextContent
+                const resultContent = {
+                    type: 'text',
+                    text: JSON.stringify(cleanResult, null, 2),
+                    contentType: 'application/json',
+                };
+                // Log based on the success flag in the result
+                if (cleanResult.success) {
+                    logger.info(`Tool ${TOOL_NAME} executed successfully (DryRun: ${cleanResult.dryRun})`, logicContext);
+                }
+                else {
+                    // Log specific failure message from the result
+                    logger.warning(`Tool ${TOOL_NAME} failed: ${cleanResult.message}`, { ...logicContext, errorDetails: cleanResult.error });
+                }
+                // Return the result, whether success or structured failure
+                return { content: [resultContent] };
+            }, {
+                operation: toolOperation,
+                context: logicContext,
+                input: validatedArgs, // Log the raw validated args
+                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/gitClearWorkingDir/index.js

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Barrel file for the git_clear_working_dir tool.
+ * Exports the registration function and related components.
+ */
+export { registerGitClearWorkingDirTool, initializeGitClearWorkingDirStateAccessors } from './registration.js';
+// Export types if needed elsewhere, e.g.:
+// export type { GitClearWorkingDirInput, GitClearWorkingDirResult } from './logic.js';

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

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { logger } from '../../../utils/logger.js';
+import { McpError, BaseErrorCode } from '../../../types-global/errors.js';
+// Define the Zod schema for input validation (no arguments needed)
+export const GitClearWorkingDirInputSchema = z.object({});
+/**
+ * Logic for the git_clear_working_dir tool.
+ * Clears the global working directory setting for the current session.
+ *
+ * @param {GitClearWorkingDirInput} input - The validated input arguments (empty object).
+ * @param {RequestContext} context - The request context, containing session ID and the clear function.
+ * @returns {Promise<GitClearWorkingDirResult>} The result of the operation.
+ * @throws {McpError} Throws McpError for operational errors.
+ */
+export async function gitClearWorkingDirLogic(input, context // Assuming context provides session info and clearer
+) {
+    const operation = 'gitClearWorkingDirLogic';
+    logger.info('Executing git_clear_working_dir logic', { ...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 clear the working directory for the current session.
+    try {
+        context.clearWorkingDirectory();
+        logger.info(`Working directory cleared for session ${context.sessionId || 'stdio'}`, { ...context, operation });
+    }
+    catch (error) {
+        logger.error('Failed to clear 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: 'Global working directory setting cleared.',
+    };
+}

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

@@ -0,0 +1,73 @@
+import { ErrorHandler } from '../../../utils/errorHandler.js';
+import { logger } from '../../../utils/logger.js';
+import { requestContextService } from '../../../utils/requestContext.js';
+import { GitClearWorkingDirInputSchema, gitClearWorkingDirLogic } from './logic.js';
+import { BaseErrorCode } from '../../../types-global/errors.js';
+let _clearWorkingDirectory;
+let _getSessionId;
+/**
+ * Initializes the state accessors needed by the tool registration.
+ * This should be called once during server setup.
+ * @param clearFn - Function to clear the working directory for a session.
+ * @param getFn - Function to get the session ID from context.
+ */
+export function initializeGitClearWorkingDirStateAccessors(clearFn, getFn) {
+    _clearWorkingDirectory = clearFn;
+    _getSessionId = getFn; // Can reuse the getter from the set tool
+    logger.info('State accessors initialized for git_clear_working_dir tool registration.');
+}
+const TOOL_NAME = 'git_clear_working_dir';
+const TOOL_DESCRIPTION = "Clears the session-specific working directory previously set by `git_set_working_dir`. Subsequent Git tool calls in this session will require an explicit `path` parameter or will default to the server's current working directory. Returns the result as a JSON object.";
+/**
+ * Registers the git_clear_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 registerGitClearWorkingDirTool(server) {
+    if (!_clearWorkingDirectory || !_getSessionId) {
+        throw new Error('State accessors for git_clear_working_dir must be initialized before registration.');
+    }
+    try {
+        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitClearWorkingDirInputSchema.shape, // Empty shape
+        async (validatedArgs, callContext) => {
+            const operation = 'tool:git_clear_working_dir';
+            const requestContext = requestContextService.createRequestContext({ operation, parentContext: callContext });
+            const sessionId = _getSessionId(requestContext);
+            // Define the session-specific clear function
+            const clearWorkingDirectoryForSession = () => {
+                _clearWorkingDirectory(sessionId);
+            };
+            const logicContext = {
+                ...requestContext,
+                sessionId: sessionId,
+                clearWorkingDirectory: clearWorkingDirectoryForSession,
+            };
+            return await ErrorHandler.tryCatch(async () => {
+                // Call the core logic function
+                const result = await gitClearWorkingDirLogic(validatedArgs, logicContext);
+                // Format the successful result
+                const responseContent = {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                    contentType: 'application/json',
+                };
+                logger.info(`Tool ${TOOL_NAME} executed successfully`, { ...logicContext, result });
+                return { content: [responseContent] };
+            }, {
+                operation,
+                context: logicContext,
+                input: validatedArgs,
+                errorCode: BaseErrorCode.INTERNAL_ERROR,
+            });
+        });
+        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,
+        });
+        throw error;
+    }
+}

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

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Barrel file for the git_clone tool.
+ * Exports the registration function.
+ */
+export { registerGitCloneTool } from './registration.js';
+// Export types if needed elsewhere, e.g.:
+// export type { GitCloneInput, GitCloneResult } from './logic.js';