@cyanheads/git-mcp-server 1.2.4 → 2.0.2

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

@@ -0,0 +1,160 @@
+import { z } from 'zod';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+import { logger } from '../../../utils/logger.js';
+import { McpError, BaseErrorCode } from '../../../types-global/errors.js';
+import { sanitization } from '../../../utils/sanitization.js';
+import path from 'path'; // Import path module
+const execAsync = promisify(exec);
+// Define the input schema for the git_merge tool
+export const GitMergeInputSchema = z.object({
+    path: z.string().min(1).optional().default('.').describe("Path to the Git repository. Defaults to the session's working directory if set."),
+    branch: z.string().min(1).describe('The name of the branch to merge into the current branch.'),
+    commitMessage: z.string().optional().describe('Commit message to use for the merge commit (if required, e.g., not fast-forward).'),
+    noFf: z.boolean().default(false).describe('Create a merge commit even when the merge resolves as a fast-forward (`--no-ff`).'),
+    squash: z.boolean().default(false).describe('Combine merged changes into a single commit (`--squash`). Requires manual commit afterwards.'),
+    abort: z.boolean().default(false).describe('Abort the current merge process (resolves conflicts).'),
+    // 'continue' might be too complex for initial implementation due to requiring index manipulation
+});
+/**
+ * Executes the 'git merge' command.
+ *
+ * @param {GitMergeInput} input - The validated input object.
+ * @param {RequestContext} context - The request context.
+ * @returns {Promise<GitMergeResult>} A promise that resolves with the structured merge result.
+ * @throws {McpError} Throws an McpError for path issues, command failures, or unexpected errors.
+ */
+export async function gitMergeLogic(input, context) {
+    const operation = 'gitMergeLogic';
+    logger.debug(`Executing ${operation}`, { ...context, input });
+    let targetPath;
+    try {
+        // Resolve the target path
+        let resolvedPath;
+        if (input.path && input.path !== '.') {
+            // If a specific path is given, resolve it absolutely first
+            // Assuming input.path could be relative *to the server's CWD* if no session WD is set,
+            // but it's safer to require absolute paths or rely on session WD.
+            // For simplicity, let's assume input.path is intended relative to session WD if set, or absolute otherwise.
+            const workingDir = context.getWorkingDirectory();
+            if (workingDir) {
+                resolvedPath = path.resolve(workingDir, input.path); // Resolve relative to session WD
+            }
+            else if (path.isAbsolute(input.path)) {
+                resolvedPath = input.path; // Use absolute path directly
+            }
+            else {
+                // If relative path given without session WD, it's ambiguous. Error out.
+                throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Relative path provided but no working directory set for the session.", { context, operation });
+            }
+            logger.debug(`Resolved provided path: ${resolvedPath}`, { ...context, operation });
+        }
+        else {
+            const workingDir = context.getWorkingDirectory();
+            if (!workingDir) {
+                throw new McpError(BaseErrorCode.VALIDATION_ERROR, "No path provided and no working directory set for the session.", { context, operation });
+            }
+            resolvedPath = workingDir; // Use session working directory
+            logger.debug(`Using session working directory: ${resolvedPath}`, { ...context, operation, sessionId: context.sessionId });
+        }
+        // Sanitize the resolved path
+        // We assume the resolved path should be absolute for git commands.
+        // sanitizePath checks for traversal and normalizes.
+        targetPath = sanitization.sanitizePath(resolvedPath, { allowAbsolute: true });
+        logger.debug(`Sanitized path: ${targetPath}`, { ...context, operation });
+    }
+    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 });
+    }
+    // --- Construct the git merge command ---
+    let command = `git -C "${targetPath}" merge`;
+    if (input.abort) {
+        command += ' --abort';
+    }
+    else {
+        // Standard merge options
+        if (input.noFf)
+            command += ' --no-ff';
+        if (input.squash)
+            command += ' --squash';
+        if (input.commitMessage && !input.squash) { // Commit message only relevant if not squashing (squash requires separate commit)
+            command += ` -m "${input.commitMessage.replace(/"/g, '\\"')}"`;
+        }
+        else if (input.squash && input.commitMessage) {
+            logger.warning("Commit message provided with --squash, but it will be ignored. Squash requires a separate commit.", { ...context, operation });
+        }
+        command += ` "${input.branch.replace(/"/g, '\\"')}"`; // Add branch to merge
+    }
+    logger.debug(`Executing command: ${command}`, { ...context, operation });
+    // --- Execute and Parse ---
+    try {
+        const { stdout, stderr } = await execAsync(command);
+        logger.debug(`Command stdout: ${stdout}`, { ...context, operation });
+        if (stderr)
+            logger.debug(`Command stderr: ${stderr}`, { ...context, operation }); // Log stderr even on success
+        if (input.abort) {
+            return { success: true, message: 'Merge aborted successfully.', aborted: true };
+        }
+        // Check stdout/stderr for specific success messages
+        if (stdout.includes('Fast-forward')) {
+            return { success: true, message: `Merge successful (fast-forward): ${stdout.trim()}`, fastForward: true };
+        }
+        if (stdout.includes('Merge made by') || stdout.includes('merging')) { // Check for recursive strategy message etc.
+            const match = stdout.match(/Merge commit '([a-f0-9]+)'/); // Try to get merge commit hash
+            return {
+                success: true,
+                message: `Merge successful: ${stdout.trim()}`,
+                mergedCommitHash: match ? match[1] : undefined,
+                fastForward: false, // Explicitly not FF
+            };
+        }
+        if (stdout.includes('Squash commit -- not updating HEAD')) {
+            return {
+                success: true,
+                message: `Merge successful (--squash): Changes staged. Manual commit required. ${stdout.trim()}`,
+                needsManualCommit: true,
+            };
+        }
+        if (stdout.includes('Already up to date')) {
+            return { success: true, message: `Already up to date.`, fastForward: true }; // Treat as success/FF
+        }
+        // If none of the above, return generic success based on exit code 0
+        return { success: true, message: `Merge command completed: ${stdout.trim()}` };
+    }
+    catch (error) {
+        const errorMessage = error.stderr || error.stdout || error.message || ''; // Git often puts errors in stdout/stderr
+        logger.error(`Git merge command failed`, { ...context, operation, path: targetPath, error: error.message, output: errorMessage });
+        if (input.abort) {
+            // If abort failed, it's likely there was no merge in progress
+            if (errorMessage.includes('fatal: There is no merge to abort')) {
+                return { success: false, message: 'No merge in progress to abort.', aborted: false };
+            }
+            throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to abort merge: ${errorMessage}`, { context, operation, originalError: error });
+        }
+        // Check for specific failure scenarios
+        if (errorMessage.includes('CONFLICT')) {
+            return { success: false, message: `Merge failed due to conflicts. Please resolve conflicts and commit. Output: ${errorMessage}`, conflict: true };
+        }
+        if (errorMessage.includes('refusing to merge unrelated histories')) {
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Merge failed: Refusing to merge unrelated histories. Consider using '--allow-unrelated-histories'.`, { context, operation, originalError: error });
+        }
+        if (errorMessage.includes('fatal: Not possible to fast-forward, aborting.')) {
+            throw new McpError(BaseErrorCode.CONFLICT, `Merge failed: Not possible to fast-forward. Merge required.`, { context, operation, originalError: error });
+        }
+        if (errorMessage.match(/fatal: '.*?' does not point to a commit/)) {
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Merge failed: Branch '${input.branch}' not found or does not point to a commit.`, { context, operation, originalError: error });
+        }
+        if (errorMessage.includes('fatal: You have not concluded your merge')) {
+            return { success: false, message: `Merge failed: Conflicts still exist from a previous merge. Resolve conflicts or abort. Output: ${errorMessage}`, conflict: true };
+        }
+        if (errorMessage.includes('error: Your local changes to the following files would be overwritten by merge')) {
+            throw new McpError(BaseErrorCode.CONFLICT, `Merge failed: Local changes would be overwritten. Please commit or stash them.`, { context, operation, originalError: error });
+        }
+        // Generic error
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git merge command failed for path ${targetPath}: ${errorMessage}`, { context, operation, originalError: error });
+    }
+}

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

@@ -0,0 +1,77 @@
+import { logger } from '../../../utils/logger.js';
+import { ErrorHandler } from '../../../utils/errorHandler.js';
+import { requestContextService } from '../../../utils/requestContext.js';
+import { gitMergeLogic, GitMergeInputSchema } from './logic.js';
+import { BaseErrorCode } from '../../../types-global/errors.js';
+let _getWorkingDirectory;
+let _getSessionId;
+/**
+ * Initializes the state accessors needed by the gitMerge 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 initializeGitMergeStateAccessors(getWdFn, getSidFn) {
+    _getWorkingDirectory = getWdFn;
+    _getSessionId = getSidFn;
+    logger.info('State accessors initialized for git_merge tool registration.');
+}
+const TOOL_NAME = 'git_merge';
+const TOOL_DESCRIPTION = 'Merges the specified branch into the current branch. Supports options like --no-ff, --squash, and --abort. Returns the merge result as a JSON object.';
+/**
+ * Registers the git_merge tool with the MCP server.
+ *
+ * @param {McpServer} server - The McpServer instance.
+ * @returns {Promise<void>}
+ * @throws {Error} If registration fails or state accessors are not initialized.
+ */
+export const registerGitMergeTool = async (server) => {
+    if (!_getWorkingDirectory || !_getSessionId) {
+        throw new Error('State accessors for git_merge must be initialized before registration.');
+    }
+    const operation = 'registerGitMergeTool';
+    const context = requestContextService.createRequestContext({ operation });
+    await ErrorHandler.tryCatch(async () => {
+        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitMergeInputSchema.shape, // Provide the Zod schema shape
+        async (validatedArgs, callContext) => {
+            const toolOperation = 'tool:git_merge';
+            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 mergeResult = await gitMergeLogic(validatedArgs, logicContext);
+                // Format the result as a JSON string within TextContent
+                const resultContent = {
+                    type: 'text',
+                    text: JSON.stringify(mergeResult, null, 2), // Pretty-print JSON
+                    contentType: 'application/json',
+                };
+                // Log based on the success flag in the result
+                if (mergeResult.success) {
+                    logger.info(`Tool ${TOOL_NAME} executed successfully, returning JSON`, logicContext);
+                }
+                else {
+                    // Log non-fatal conditions (like conflicts) differently from execution errors
+                    logger.info(`Tool ${TOOL_NAME} completed with specific condition (e.g., conflict, no merge to abort), returning JSON`, logicContext);
+                }
+                // Even if success is false (e.g., conflicts), it's not a tool execution *error* in the MCP sense,
+                // the tool ran, but the git operation failed predictably. Return the structured result.
+                return { content: [resultContent] };
+            }, {
+                operation: toolOperation,
+                context: logicContext,
+                input: validatedArgs,
+                errorCode: BaseErrorCode.INTERNAL_ERROR, // Default for unexpected logic errors
+            });
+        });
+        logger.info(`Tool registered: ${TOOL_NAME}`, context);
+    }, { operation, context, critical: true });
+};

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

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Barrel file for the gitPull tool.
+ */
+export { registerGitPullTool, initializeGitPullStateAccessors } from './registration.js';
+// Export types if needed elsewhere, e.g.:
+// export type { GitPullInput, GitPullResult } from './logic.js';

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

@@ -0,0 +1,144 @@
+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_pull tool using Zod
+export const GitPullInputSchema = z.object({
+    path: z.string().min(1).optional().default('.').describe("Path to the Git repository. Defaults to the session's working directory if set."),
+    remote: z.string().optional().describe("The remote repository to pull from (e.g., 'origin'). Defaults to the tracked upstream or 'origin'."),
+    branch: z.string().optional().describe("The remote branch to pull. Defaults to the current branch's upstream."),
+    rebase: z.boolean().optional().default(false).describe("Use 'git pull --rebase' instead of merge."),
+    ffOnly: z.boolean().optional().default(false).describe("Use '--ff-only' to only allow fast-forward merges."),
+    // Add other relevant git pull options as needed (e.g., --prune, --tags, --depth)
+});
+/**
+ * Executes the 'git pull' command and returns structured JSON output.
+ *
+ * @param {GitPullInput} input - The validated input object.
+ * @param {RequestContext} context - The request context for logging and error handling, including session info and working dir getter.
+ * @returns {Promise<GitPullResult>} A promise that resolves with the structured pull result.
+ * @throws {McpError} Throws an McpError if path resolution, validation, or the git command fails unexpectedly.
+ */
+export async function pullGitChanges(input, context) {
+    const operation = 'pullGitChanges';
+    logger.debug(`Executing ${operation}`, { ...context, input });
+    let targetPath;
+    try {
+        // Resolve the target path
+        if (input.path && input.path !== '.') {
+            targetPath = input.path;
+            logger.debug(`Using provided path: ${targetPath}`, { ...context, operation });
+        }
+        else {
+            const workingDir = context.getWorkingDirectory();
+            if (!workingDir) {
+                throw new McpError(BaseErrorCode.VALIDATION_ERROR, "No path provided and no working directory set for the session.", { context, operation });
+            }
+            targetPath = workingDir;
+            logger.debug(`Using session working directory: ${targetPath}`, { ...context, operation, sessionId: context.sessionId });
+        }
+        // Sanitize the resolved path
+        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 git pull command
+        let command = `git -C "${targetPath}" pull`;
+        if (input.rebase) {
+            command += ' --rebase';
+        }
+        if (input.ffOnly) {
+            command += ' --ff-only';
+        }
+        if (input.remote) {
+            // Sanitize remote and branch names - basic alphanumeric + common chars
+            const safeRemote = input.remote.replace(/[^a-zA-Z0-9_.\-/]/g, '');
+            command += ` ${safeRemote}`;
+            if (input.branch) {
+                const safeBranch = input.branch.replace(/[^a-zA-Z0-9_.\-/]/g, '');
+                command += ` ${safeBranch}`;
+            }
+        }
+        else if (input.branch) {
+            // If only branch is specified, assume 'origin' or tracked remote
+            const safeBranch = input.branch.replace(/[^a-zA-Z0-9_.\-/]/g, '');
+            command += ` origin ${safeBranch}`; // Defaulting to origin if remote not specified but branch is
+            logger.warning(`Remote not specified, defaulting to 'origin' for branch pull`, { ...context, operation });
+        }
+        logger.debug(`Executing command: ${command}`, { ...context, operation });
+        const { stdout, stderr } = await execAsync(command);
+        logger.info(`Git pull stdout: ${stdout}`, { ...context, operation });
+        if (stderr) {
+            // Stderr might contain progress or non-error info, log as warning unless it indicates a clear failure handled below
+            logger.warning(`Git pull stderr: ${stderr}`, { ...context, operation });
+        }
+        // Analyze stdout/stderr to determine the outcome
+        let message = stdout.trim() || stderr.trim(); // Use stdout first, fallback to stderr for message
+        let success = true;
+        let conflict = false;
+        let summary = undefined;
+        if (message.includes('Already up to date')) {
+            message = 'Already up to date.';
+        }
+        else if (message.includes('Fast-forward')) {
+            message = 'Pull successful (fast-forward).';
+            // Try to extract summary
+            const summaryMatch = stdout.match(/(\d+ files? changed.*)/);
+            if (summaryMatch)
+                summary = summaryMatch[1];
+        }
+        else if (message.includes('Merge made by the') || message.includes('merging')) { // Covers recursive and octopus
+            message = 'Pull successful (merge).';
+            const summaryMatch = stdout.match(/(\d+ files? changed.*)/);
+            if (summaryMatch)
+                summary = summaryMatch[1];
+        }
+        else if (message.includes('Automatic merge failed; fix conflicts and then commit the result.')) {
+            message = 'Pull resulted in merge conflicts.';
+            success = false; // Indicate failure due to conflicts
+            conflict = true;
+        }
+        else if (message.includes('fatal:')) {
+            // If a fatal error wasn't caught by the execAsync catch block but is in stdout/stderr
+            success = false;
+            message = `Pull failed: ${message}`;
+            logger.error(`Git pull command indicated failure: ${message}`, { ...context, operation, stdout, stderr });
+        }
+        // Add more specific checks based on git pull output variations if needed
+        logger.info(`${operation} completed`, { ...context, operation, path: targetPath, success, message, conflict });
+        return { success, message, summary, conflict };
+    }
+    catch (error) {
+        logger.error(`Failed to execute git pull command`, { ...context, operation, path: targetPath, error: error.message, stderr: error.stderr, stdout: error.stdout });
+        const errorMessage = error.stderr || error.stdout || error.message || ''; // Check stdout too for errors
+        // 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')) {
+            throw new McpError(BaseErrorCode.NETWORK_ERROR, `Failed to connect to remote repository. Error: ${errorMessage}`, { context, operation, originalError: error });
+        }
+        if (errorMessage.includes('merge conflict') || errorMessage.includes('fix conflicts')) {
+            // This might be caught here if execAsync throws due to non-zero exit code during conflict
+            logger.warning('Pull resulted in merge conflicts (caught as error)', { ...context, operation, path: targetPath, errorMessage });
+            return { success: false, message: 'Pull resulted in merge conflicts.', conflict: true };
+        }
+        if (errorMessage.includes('You have unstaged changes') || errorMessage.includes('Your local changes to the following files would be overwritten by merge')) {
+            throw new McpError(BaseErrorCode.CONFLICT, `Pull failed due to uncommitted local changes. Please commit or stash them first. Error: ${errorMessage}`, { context, operation, originalError: error });
+        }
+        if (errorMessage.includes('refusing to merge unrelated histories')) {
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Pull failed: Refusing to merge unrelated histories. Use '--allow-unrelated-histories' if intended.`, { context, operation, originalError: error });
+        }
+        // Generic internal error for other failures
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to pull changes for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+    }
+}

package/dist/mcp-server/tools/gitPull/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 { GitPullInputSchema, pullGitChanges } 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 initializeGitPullStateAccessors(getWdFn, getSidFn) {
+    _getWorkingDirectory = getWdFn;
+    _getSessionId = getSidFn;
+    logger.info('State accessors initialized for git_pull tool registration.');
+}
+const TOOL_NAME = 'git_pull';
+const TOOL_DESCRIPTION = "Fetches from and integrates with another repository or a local branch (e.g., 'git pull origin main'). Supports rebase and fast-forward only options. Returns the pull result as a JSON object.";
+/**
+ * Registers the git_pull tool with the MCP server.
+ *
+ * @param {McpServer} server - The MCP server instance.
+ * @throws {Error} If state accessors are not initialized.
+ */
+export async function registerGitPullTool(server) {
+    if (!_getWorkingDirectory || !_getSessionId) {
+        throw new Error('State accessors for git_pull must be initialized before registration.');
+    }
+    const operation = 'registerGitPullTool';
+    const context = requestContextService.createRequestContext({ operation });
+    await ErrorHandler.tryCatch(async () => {
+        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitPullInputSchema.shape, // Provide the Zod schema shape
+        async (validatedArgs, callContext) => {
+            const toolOperation = 'tool:git_pull';
+            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 pullResult = await pullGitChanges(validatedArgs, logicContext);
+                // Format the result as a JSON string within TextContent
+                const resultContent = {
+                    type: 'text',
+                    text: JSON.stringify(pullResult, null, 2), // Pretty-print JSON
+                    contentType: 'application/json',
+                };
+                // Log based on the success flag in the result
+                if (pullResult.success) {
+                    logger.info(`Tool ${TOOL_NAME} executed successfully, returning JSON`, logicContext);
+                }
+                else {
+                    // Log non-fatal conditions like conflicts or already up-to-date differently
+                    const logMessage = pullResult.conflict
+                        ? `Tool ${TOOL_NAME} completed with merge conflicts, returning JSON`
+                        : `Tool ${TOOL_NAME} completed with status: ${pullResult.message}, returning JSON`;
+                    logger.info(logMessage, logicContext);
+                }
+                // Even if success is false (e.g., conflicts), 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/gitPush/index.js

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Barrel file for the gitPush tool.
+ */
+export { registerGitPushTool, initializeGitPushStateAccessors } from './registration.js';
+// Export types if needed elsewhere, e.g.:
+// export type { GitPushInput, GitPushResult } from './logic.js';