@cyanheads/git-mcp-server 1.2.4 → 2.0.2

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

@@ -0,0 +1,188 @@
+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_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."),
+    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."),
+    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`)."),
+    tags: z.boolean().optional().default(false).describe("Push all tags (`--tags`)."),
+    delete: z.boolean().optional().default(false).describe("Delete the remote branch (`--delete`). Requires `branch` to be specified. Use with caution, as deleting remote branches can affect collaborators."),
+    // Add other relevant git push options as needed (e.g., --prune, --all)
+});
+/**
+ * Executes the 'git push' command and returns structured JSON output.
+ *
+ * @param {GitPushInput} input - The validated input object.
+ * @param {RequestContext} context - The request context for logging and error handling.
+ * @returns {Promise<GitPushResult>} A promise that resolves with the structured push result.
+ * @throws {McpError} Throws an McpError if path resolution, validation, or the git command fails unexpectedly.
+ */
+export async function pushGitChanges(input, context) {
+    const operation = 'pushGitChanges';
+    logger.debug(`Executing ${operation}`, { ...context, input });
+    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 });
+    }
+    // Validate specific input combinations
+    if (input.delete && !input.branch) {
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Cannot use --delete without specifying a branch to delete.", { context, operation });
+    }
+    if (input.force && input.forceWithLease) {
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Cannot use --force and --force-with-lease together.", { context, operation });
+    }
+    if (input.delete && (input.force || input.forceWithLease || input.setUpstream || input.tags)) {
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Cannot combine --delete with --force, --force-with-lease, --set-upstream, or --tags.", { context, operation });
+    }
+    try {
+        // Construct the git push command
+        let command = `git -C "${targetPath}" push`;
+        if (input.force) {
+            command += ' --force';
+        }
+        else if (input.forceWithLease) {
+            command += ' --force-with-lease';
+        }
+        if (input.setUpstream) {
+            command += ' --set-upstream';
+        }
+        if (input.tags) {
+            command += ' --tags';
+        }
+        if (input.delete) {
+            command += ' --delete';
+        }
+        // Add remote and branch specification
+        const remote = input.remote ? input.remote.replace(/[^a-zA-Z0-9_.\-/]/g, '') : 'origin'; // Default to origin
+        command += ` ${remote}`;
+        if (input.branch) {
+            const localBranch = input.branch.replace(/[^a-zA-Z0-9_.\-/]/g, '');
+            command += ` ${localBranch}`;
+            if (input.remoteBranch && !input.delete) { // remoteBranch only makes sense if not deleting
+                const remoteBranch = input.remoteBranch.replace(/[^a-zA-Z0-9_.\-/]/g, '');
+                command += `:${remoteBranch}`;
+            }
+        }
+        else if (!input.tags && !input.delete) {
+            // If no branch, tags, or delete specified, push the current branch by default
+            // Git might handle this automatically, but being explicit can be clearer
+            // command += ' HEAD'; // Or let git figure out the default push behavior
+            logger.debug('No specific branch, tags, or delete specified. Relying on default git push behavior for current branch.', { ...context, operation });
+        }
+        logger.debug(`Executing command: ${command}`, { ...context, operation });
+        // Execute command. Note: Git push often uses stderr for progress and success messages.
+        const { stdout, stderr } = await execAsync(command);
+        logger.info(`Git push stdout: ${stdout}`, { ...context, operation });
+        logger.info(`Git push stderr: ${stderr}`, { ...context, operation }); // Log stderr as info as it's commonly used
+        // Analyze stderr primarily, fallback to stdout
+        let message = stderr.trim() || stdout.trim();
+        let success = true;
+        let rejected = false;
+        let deleted = false;
+        let summary = undefined;
+        // Check for common success/status messages in stderr
+        if (message.includes('Everything up-to-date')) {
+            message = 'Everything up-to-date.';
+        }
+        else if (message.match(/->\s+\[new branch\]/) || message.match(/->\s+\[new tag\]/)) {
+            message = 'Push successful (new branch/tag created).';
+            // Extract summary if possible (e.g., commit range)
+            const summaryMatch = message.match(/([a-f0-9]+\.\.[a-f0-9]+)\s+\S+\s+->\s+\S+/);
+            if (summaryMatch)
+                summary = summaryMatch[1];
+        }
+        else if (message.includes('Done.')) { // Common part of successful push output
+            // Try to find a more specific message
+            if (stderr.includes('updating') || stdout.includes('updating')) {
+                message = 'Push successful.';
+                const summaryMatch = message.match(/([a-f0-9]+\.\.[a-f0-9]+)\s+\S+\s+->\s+\S+/);
+                if (summaryMatch)
+                    summary = summaryMatch[1];
+            }
+            else {
+                message = 'Push completed (check logs for details).'; // Generic success if specific pattern not found
+            }
+        }
+        else if (message.includes('[rejected]')) {
+            message = 'Push rejected.';
+            success = false;
+            rejected = true;
+            // Extract reason if possible
+            const reasonMatch = message.match(/\[rejected\].*->.*?\((.*?)\)/);
+            if (reasonMatch) {
+                message += ` Reason: ${reasonMatch[1]}.`;
+                if (reasonMatch[1].includes('non-fast-forward')) {
+                    message += ' Hint: Try pulling first or use force options if necessary.';
+                }
+            }
+        }
+        else if (message.includes('[deleted]')) {
+            message = 'Remote branch deleted successfully.';
+            deleted = true;
+        }
+        else if (message.includes('fatal:')) {
+            // If a fatal error wasn't caught by execAsync but is in stderr/stdout
+            success = false;
+            message = `Push failed: ${message}`;
+            logger.error(`Git push command indicated failure: ${message}`, { ...context, operation, stdout, stderr });
+        }
+        else if (!message && !stdout && !stderr) {
+            // If command succeeds with no output (can happen in some cases)
+            message = 'Push command executed, but no output received.';
+            logger.warning(message, { ...context, operation });
+        }
+        logger.info(`${operation} completed`, { ...context, operation, path: targetPath, success, message, rejected, deleted });
+        return { success, message, summary, rejected, deleted };
+    }
+    catch (error) {
+        logger.error(`Failed to execute git push 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('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 });
+        }
+        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
+            logger.warning('Push rejected (caught as error)', { ...context, operation, path: targetPath, errorMessage });
+            return { success: false, message: `Push rejected: ${errorMessage}`, rejected: true };
+        }
+        if (errorMessage.includes('Authentication failed') || errorMessage.includes('Permission denied')) {
+            throw new McpError(BaseErrorCode.UNAUTHORIZED, `Authentication failed for remote repository. Error: ${errorMessage}`, { context, operation, originalError: error });
+        }
+        if (errorMessage.includes('src refspec') && errorMessage.includes('does not match any')) {
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Push failed: Source branch/refspec does not exist locally. Error: ${errorMessage}`, { context, operation, originalError: error });
+        }
+        // Generic internal error for other failures
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to push changes for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+    }
+}

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

@@ -0,0 +1,81 @@
+import { ErrorHandler } from '../../../utils/errorHandler.js';
+import { logger } from '../../../utils/logger.js';
+import { requestContextService } from '../../../utils/requestContext.js';
+import { GitPushInputSchema, pushGitChanges } 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 initializeGitPushStateAccessors(getWdFn, getSidFn) {
+    _getWorkingDirectory = getWdFn;
+    _getSessionId = getSidFn;
+    logger.info('State accessors initialized for git_push tool registration.');
+}
+const TOOL_NAME = 'git_push';
+const TOOL_DESCRIPTION = "Updates remote refs using local refs, sending objects necessary to complete the given refs. Supports pushing specific branches, tags, forcing, setting upstream, and deleting remote branches. Returns the push result as a JSON object.";
+/**
+ * Registers the git_push tool with the MCP server.
+ *
+ * @param {McpServer} server - The MCP server instance.
+ * @throws {Error} If state accessors are not initialized.
+ */
+export async function registerGitPushTool(server) {
+    if (!_getWorkingDirectory || !_getSessionId) {
+        throw new Error('State accessors for git_push must be initialized before registration.');
+    }
+    const operation = 'registerGitPushTool';
+    const context = requestContextService.createRequestContext({ operation });
+    await ErrorHandler.tryCatch(async () => {
+        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitPushInputSchema.shape, // Provide the Zod schema shape
+        async (validatedArgs, callContext) => {
+            const toolOperation = 'tool:git_push';
+            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 pushResult = await pushGitChanges(validatedArgs, logicContext);
+                // Format the result as a JSON string within TextContent
+                const resultContent = {
+                    type: 'text',
+                    text: JSON.stringify(pushResult, null, 2), // Pretty-print JSON
+                    contentType: 'application/json',
+                };
+                // Log based on the success flag in the result
+                if (pushResult.success) {
+                    logger.info(`Tool ${TOOL_NAME} executed successfully, returning JSON`, logicContext);
+                }
+                else {
+                    // Log non-fatal conditions like rejections differently
+                    const logMessage = pushResult.rejected
+                        ? `Tool ${TOOL_NAME} completed but push was rejected, returning JSON`
+                        : `Tool ${TOOL_NAME} completed with status: ${pushResult.message}, returning JSON`;
+                    logger.info(logMessage, logicContext);
+                }
+                // Even if success is false (e.g., rejected), it's not necessarily a tool execution *error*
+                // unless the logic threw an McpError. The success flag in the JSON indicates the Git outcome.
+                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/gitRebase/index.js

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

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

@@ -0,0 +1,171 @@
+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 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."),
+    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."),
+    interactive: z.boolean().default(false).describe("Perform an interactive rebase (`-i`). 'upstream' can be omitted to rebase current branch's tracked upstream or use fork-point."),
+    strategy: z.enum(['recursive', 'resolve', 'ours', 'theirs', 'octopus', 'subtree']).optional().describe("Specifies the merge strategy to use during rebase."),
+    strategyOption: z.string().optional().describe("Pass a specific option to the merge strategy (e.g., 'ours', 'theirs' for recursive). Use with -X."),
+    onto: z.string().min(1).optional().describe("Rebase onto a specific commit/branch instead of the upstream's base. Requires 'upstream' to be specified."),
+    // TODO: Add options like --preserve-merges, --autosquash, --autostash?
+});
+// Apply refinements and export the FINAL schema for validation within the handler
+export const GitRebaseInputSchema = GitRebaseBaseSchema.refine(data => !(data.mode === 'start' && !data.interactive && !data.upstream), {
+    message: "An 'upstream' branch/commit is required for 'start' mode unless 'interactive' is true.", path: ["upstream"],
+}).refine(data => !(data.mode !== 'start' && (data.upstream || data.branch || data.interactive || data.strategy || data.onto)), {
+    message: "Parameters like 'upstream', 'branch', 'interactive', 'strategy', 'onto' are only applicable for 'start' mode.", path: ["mode"],
+});
+/**
+ * Executes the 'git rebase' command based on the specified mode.
+ *
+ * @param {GitRebaseInput} input - The validated input object.
+ * @param {RequestContext} context - The request context for logging and error handling.
+ * @returns {Promise<GitRebaseResult>} A promise that resolves with the structured result.
+ * @throws {McpError} Throws an McpError for path resolution/validation failures or unexpected errors.
+ */
+export async function gitRebaseLogic(input, context) {
+    const operation = `gitRebaseLogic:${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 ?? '.';
+        if (targetPath === '.' && !workingDir) {
+            logger.warning("Executing git rebase 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}" rebase`;
+        switch (input.mode) {
+            case 'start':
+                if (input.interactive)
+                    command += ' -i';
+                if (input.strategy)
+                    command += ` --strategy=${input.strategy}`;
+                if (input.strategyOption)
+                    command += ` -X${input.strategyOption}`; // Note: -X for strategy options
+                if (input.onto)
+                    command += ` --onto "${input.onto.replace(/"/g, '\\"')}"`;
+                // Upstream is required by refine unless interactive
+                if (input.upstream)
+                    command += ` "${input.upstream.replace(/"/g, '\\"')}"`;
+                if (input.branch)
+                    command += ` "${input.branch.replace(/"/g, '\\"')}"`;
+                break;
+            case 'continue':
+                command += ' --continue';
+                break;
+            case 'abort':
+                command += ' --abort';
+                break;
+            case 'skip':
+                command += ' --skip';
+                break;
+            default:
+                // Should not happen due to Zod validation
+                throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid mode: ${input.mode}`, { context, operation });
+        }
+        logger.debug(`Executing command: ${command}`, { ...context, operation });
+        try {
+            const { stdout, stderr } = await execAsync(command);
+            const output = stdout + stderr;
+            // Check for common success messages
+            if (/successfully rebased and updated/i.test(output) || (input.mode === 'abort' && !stderr) || (input.mode === 'skip' && !stderr) || (input.mode === 'continue' && /applying/i.test(stdout))) {
+                const message = input.mode === 'start'
+                    ? `Rebase started successfully. Output: ${output.trim()}`
+                    : `Rebase ${input.mode} executed successfully. Output: ${output.trim()}`;
+                logger.info(message, { ...context, operation, path: targetPath });
+                return { success: true, mode: input.mode, message, rebaseCompleted: /successfully rebased/.test(output), needsManualAction: false };
+            }
+            // Check for interactive rebase start
+            if (input.mode === 'start' && input.interactive && /noop/i.test(stderr) && /hint: use 'git rebase --edit-todo'/i.test(stderr)) {
+                const message = `Interactive rebase started. Edit the todo list in your editor. Output: ${output.trim()}`;
+                logger.info(message, { ...context, operation, path: targetPath });
+                return { success: true, mode: input.mode, message, rebaseCompleted: false, needsManualAction: true };
+            }
+            if (input.mode === 'start' && input.interactive && /applying/i.test(stdout)) {
+                const message = `Interactive rebase started and processing commits. Output: ${output.trim()}`;
+                logger.info(message, { ...context, operation, path: targetPath });
+                return { success: true, mode: input.mode, message, rebaseCompleted: false, needsManualAction: false }; // Might complete or hit conflict/edit
+            }
+            // Check for conflicts even if exit code is 0 (can happen with --continue sometimes)
+            if (/conflict/i.test(output)) {
+                const message = `Rebase ${input.mode} resulted in conflicts. Resolve conflicts and use 'git rebase --continue'. Output: ${output.trim()}`;
+                logger.warning(message, { ...context, operation, path: targetPath });
+                return { success: true, mode: input.mode, message, rebaseCompleted: false, needsManualAction: true };
+            }
+            // Default success message if no specific pattern matched but no error thrown
+            const defaultMessage = `Rebase ${input.mode} command finished. Output: ${output.trim()}`;
+            logger.info(defaultMessage, { ...context, operation, path: targetPath });
+            return { success: true, mode: input.mode, message: defaultMessage, rebaseCompleted: !/applying|stopped/i.test(output), needsManualAction: /stopped at|edit/.test(output) };
+        }
+        catch (rebaseError) {
+            const errorMessage = rebaseError.stderr || rebaseError.stdout || rebaseError.message || '';
+            logger.error(`Git rebase ${input.mode} command failed`, { ...context, operation, path: targetPath, error: errorMessage, stderr: rebaseError.stderr, stdout: rebaseError.stdout });
+            // Handle specific error cases
+            if (/conflict/i.test(errorMessage)) {
+                return { success: false, mode: input.mode, message: `Rebase ${input.mode} failed due to conflicts. Resolve conflicts and use 'git rebase --continue'.`, error: errorMessage, conflicts: true };
+            }
+            if (/no rebase in progress/i.test(errorMessage)) {
+                return { success: false, mode: input.mode, message: `Failed to ${input.mode} rebase: No rebase is currently in progress.`, error: errorMessage };
+            }
+            if (/cannot rebase onto multiple branches/i.test(errorMessage)) {
+                return { success: false, mode: 'start', message: `Failed to start rebase: Cannot rebase onto multiple branches. Check your 'upstream' parameter.`, error: errorMessage };
+            }
+            if (/does not point to a valid commit/i.test(errorMessage)) {
+                return { success: false, mode: 'start', message: `Failed to start rebase: Invalid upstream, branch, or onto reference provided.`, error: errorMessage };
+            }
+            if (/your local changes would be overwritten/i.test(errorMessage)) {
+                return { success: false, mode: input.mode, message: `Failed to ${input.mode} rebase: Your local changes to tracked files would be overwritten. Please commit or stash them.`, error: errorMessage };
+            }
+            if (/interactive rebase already started/i.test(errorMessage)) {
+                return { success: false, mode: 'start', message: `Failed to start rebase: An interactive rebase is already in progress. Use 'continue', 'abort', or 'skip'.`, error: errorMessage };
+            }
+            // Throw McpError for critical issues like non-existent repo
+            if (errorMessage.toLowerCase().includes('not a git repository')) {
+                throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`, { context, operation, originalError: rebaseError });
+            }
+            // Return structured failure for other git errors
+            return {
+                success: false,
+                mode: input.mode,
+                message: `Git rebase ${input.mode} failed for path: ${targetPath}.`,
+                error: errorMessage
+            };
+        }
+    }
+    catch (error) {
+        // Catch errors from path resolution or unexpected issues before command execution
+        logger.error(`Unexpected error during git rebase setup or execution`, { ...context, operation, path: targetPath, error: error.message });
+        if (error instanceof McpError)
+            throw error;
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `An unexpected error occurred during git rebase ${input.mode}: ${error.message}`, { context, operation, originalError: error });
+    }
+}

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

@@ -0,0 +1,72 @@
+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';
+let _getWorkingDirectory;
+let _getSessionId;
+/**
+ * Initializes the state accessors needed by the git_rebase 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 initializeGitRebaseStateAccessors(getWdFn, getSidFn) {
+    _getWorkingDirectory = getWdFn;
+    _getSessionId = getSidFn;
+    logger.info('State accessors initialized for git_rebase tool registration.');
+}
+const TOOL_NAME = 'git_rebase';
+const TOOL_DESCRIPTION = 'Reapplies commits on top of another base tip. Supports starting a rebase (standard or interactive), continuing, aborting, or skipping steps in an ongoing rebase. Returns results as a JSON object.';
+/**
+ * Registers the git_rebase 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 registerGitRebaseTool = async (server) => {
+    if (!_getWorkingDirectory || !_getSessionId) {
+        throw new Error('State accessors for git_rebase must be initialized before registration.');
+    }
+    const operation = 'registerGitRebaseTool';
+    const context = requestContextService.createRequestContext({ operation });
+    await ErrorHandler.tryCatch(async () => {
+        // Register using the BASE schema shape
+        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitRebaseBaseSchema.shape, 
+        // SDK validates against the full GitRebaseInputSchema before calling this handler
+        async (validatedArgs, callContext) => {
+            const toolInput = validatedArgs; // Cast for use
+            const toolOperation = `tool:${TOOL_NAME}:${toolInput.mode}`;
+            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} (mode: ${toolInput.mode})`, logicContext);
+            return await ErrorHandler.tryCatch(async () => {
+                const rebaseResult = await gitRebaseLogic(toolInput, logicContext);
+                const resultContent = {
+                    type: 'text',
+                    text: JSON.stringify(rebaseResult, null, 2), // Pretty-print JSON
+                    contentType: 'application/json',
+                };
+                if (rebaseResult.success) {
+                    logger.info(`Tool ${TOOL_NAME} (mode: ${toolInput.mode}) executed successfully (Needs Manual Action: ${!!rebaseResult.needsManualAction}), returning JSON`, logicContext);
+                }
+                else {
+                    logger.warning(`Tool ${TOOL_NAME} (mode: ${toolInput.mode}) failed: ${rebaseResult.message}`, { ...logicContext, errorDetails: rebaseResult.error, conflicts: rebaseResult.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/gitRemote/index.js

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