@cyanheads/git-mcp-server 2.1.8 → 2.2.1

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

@@ -1,167 +1,50 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_pull tool.
+ * @module src/mcp-server/tools/gitPull/logic
+ */
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { z } from "zod";
-// Import utils from barrel (logger from ../utils/internal/logger.js)
-import { logger } from "../../../utils/index.js";
-// Import utils from barrel (RequestContext from ../utils/internal/requestContext.js)
-import { BaseErrorCode, McpError } from "../../../types-global/errors.js"; // Keep direct import for types-global
-// Import utils from barrel (sanitization from ../utils/security/sanitization.js)
-import { sanitization } from "../../../utils/index.js";
+import { logger, sanitization } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
 const execFileAsync = promisify(execFile);
-// Define the input schema for the git_pull tool using Zod
+// 1. DEFINE the Zod input schema.
 export const GitPullInputSchema = z.object({
-    path: z
-        .string()
-        .min(1)
-        .optional()
-        .default(".")
-        .describe("Path to the Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
-    remote: z
-        .string()
-        .optional()
-        .describe("The remote repository to pull from (e.g., 'origin'). Defaults to the tracked upstream or 'origin'."),
-    branch: z
-        .string()
-        .optional()
-        .describe("The remote branch to pull (e.g., 'main'). Defaults to the current branch's upstream."),
-    rebase: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("Use 'git pull --rebase' instead of merge."),
-    ffOnly: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("Use '--ff-only' to only allow fast-forward merges."),
-    // Add other relevant git pull options as needed (e.g., --prune, --tags, --depth)
+    path: z.string().default(".").describe("Path to the Git repository."),
+    remote: z.string().optional().describe("The remote repository to pull from (e.g., 'origin')."),
+    branch: z.string().optional().describe("The remote branch to pull."),
+    rebase: z.boolean().default(false).describe("Use 'git pull --rebase' instead of merge."),
+    ffOnly: z.boolean().default(false).describe("Only allow fast-forward merges."),
+});
+// 2. DEFINE the Zod response schema.
+export const GitPullOutputSchema = z.object({
+    success: z.boolean().describe("Indicates if the command was successful."),
+    message: z.string().describe("A summary message of the result."),
+    conflict: z.boolean().optional().describe("True if a merge conflict occurred."),
 });
 /**
- * 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.
+ * 4. IMPLEMENT the core logic function.
+ * @throws {McpError} If the logic encounters an unrecoverable issue.
  */
-export async function pullGitChanges(input, context) {
+export async function pullGitChanges(params, 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, {
-            allowAbsolute: true,
-        }).sanitizedPath;
-        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
-        const args = ["-C", targetPath, "pull"];
-        if (input.rebase) {
-            args.push("--rebase");
-        }
-        if (input.ffOnly) {
-            args.push("--ff-only");
-        }
-        if (input.remote) {
-            args.push(input.remote);
-            if (input.branch) {
-                args.push(input.branch);
-            }
-        }
-        else if (input.branch) {
-            // If only branch is specified, assume 'origin' or tracked remote
-            args.push("origin", input.branch); // 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: git ${args.join(" ")}`, {
-            ...context,
-            operation,
-        });
-        const { stdout, stderr } = await execFileAsync("git", args);
-        logger.debug(`Git pull stdout: ${stdout}`, { ...context, operation });
-        if (stderr) {
-            logger.debug(`Git pull stderr: ${stderr}`, { ...context, operation });
-        }
-        // Analyze stdout/stderr to determine the outcome
-        const message = stdout.trim() || stderr.trim() || "Pull command executed.";
-        const summary = message;
-        const conflict = message.includes("CONFLICT");
-        logger.info("git pull executed successfully", {
-            ...context,
-            operation,
-            path: targetPath,
-            summary,
-            conflict,
-        });
-        return { success: true, 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.SERVICE_UNAVAILABLE, `Failed to connect to remote repository. Error: ${errorMessage}`, { context, operation, originalError: error });
-        }
-        if (errorMessage.includes("merge conflict") ||
-            errorMessage.includes("fix conflicts")) {
-            // This might be caught here if execAsync throws due to non-zero exit code during conflict
-            throw new McpError(BaseErrorCode.CONFLICT, `Pull resulted in merge conflicts. Error: ${errorMessage}`, { context, operation, originalError: error });
-        }
-        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 });
+    logger.debug(`Executing ${operation}`, { ...context, params });
+    const workingDir = context.getWorkingDirectory();
+    if (params.path === "." && !workingDir) {
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, "No session working directory set. Please specify a 'path' or use 'git_set_working_dir' first.");
     }
+    const targetPath = sanitization.sanitizePath(params.path === "." ? workingDir : params.path, { allowAbsolute: true }).sanitizedPath;
+    const args = ["-C", targetPath, "pull"];
+    if (params.rebase)
+        args.push("--rebase");
+    if (params.ffOnly)
+        args.push("--ff-only");
+    if (params.remote)
+        args.push(params.remote);
+    if (params.branch)
+        args.push(params.branch);
+    logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+    const { stdout, stderr } = await execFileAsync("git", args);
+    const message = stdout.trim() || stderr.trim() || "Pull command executed successfully.";
+    return { success: true, message, conflict: message.includes("CONFLICT") };
 }

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

@@ -1,86 +1,64 @@
-// Import utils from barrel (ErrorHandler from ../utils/internal/errorHandler.js)
-import { ErrorHandler } from "../../../utils/index.js";
-// Import utils from barrel (logger from ../utils/internal/logger.js)
-import { logger } from "../../../utils/index.js";
-// Import utils from barrel (requestContextService, RequestContext from ../utils/internal/requestContext.js)
-import { BaseErrorCode } from "../../../types-global/errors.js"; // Keep direct import for types-global
-import { requestContextService } from "../../../utils/index.js";
-import { GitPullInputSchema, pullGitChanges, } from "./logic.js";
-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.
+ * @fileoverview Handles registration and error handling for the git_pull tool.
+ * @module src/mcp-server/tools/gitPull/registration
  */
-export function initializeGitPullStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_pull tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { pullGitChanges, GitPullInputSchema, GitPullOutputSchema, } from "./logic.js";
 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.
+ * Registers the git_pull tool with the MCP server instance.
+ * @param server The MCP server instance.
+ * @param getWorkingDirectory Function to get the session's working directory.
+ * @param getSessionId Function to get the session ID from context.
  */
-export async function registerGitPullTool(server) {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_pull must be initialized before registration.");
-    }
+export const registerGitPullTool = async (server, getWorkingDirectory, getSessionId) => {
     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,
+    server.registerTool(TOOL_NAME, {
+        title: "Git Pull",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitPullInputSchema.shape,
+        outputSchema: GitPullOutputSchema.shape,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true, // Can change local files and history
+            idempotentHint: false,
+            openWorldHint: true, // Interacts with remote repositories
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
+        });
+        try {
+            const sessionId = getSessionId(handlerContext);
+            const result = await pullGitChanges(params, {
+                ...handlerContext,
+                getWorkingDirectory: () => getWorkingDirectory(sessionId),
             });
-            const sessionId = _getSessionId(requestContext);
-            const getWorkingDirectoryForSession = () => {
-                return _getWorkingDirectory(sessionId);
-            };
-            const logicContext = {
-                ...requestContext,
-                sessionId: sessionId,
-                getWorkingDirectory: getWorkingDirectoryForSession,
+            return {
+                structuredContent: result,
+                content: [{ type: "text", text: `Success: ${JSON.stringify(result, null, 2)}` }],
             };
-            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
+        }
+        catch (error) {
+            logger.error(`Error in ${TOOL_NAME} handler`, { error, ...handlerContext });
+            const mcpError = ErrorHandler.handleError(error, {
+                operation: `tool:${TOOL_NAME}`,
+                context: handlerContext,
+                input: params,
             });
-        });
-        logger.info(`Tool registered: ${TOOL_NAME}`, context);
-    }, { operation, context, critical: true });
-}
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error: ${mcpError.message}` }],
+                structuredContent: {
+                    code: mcpError.code,
+                    message: mcpError.message,
+                    details: mcpError.details,
+                },
+            };
+        }
+    });
+    logger.info(`Tool '${TOOL_NAME}' registered successfully.`, context);
+};

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

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

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

@@ -1,205 +1,78 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_push tool.
+ * @module src/mcp-server/tools/gitPush/logic
+ */
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { z } from "zod";
-// Import utils from barrel (logger from ../utils/internal/logger.js)
-import { logger } from "../../../utils/index.js";
-// Import utils from barrel (RequestContext from ../utils/internal/requestContext.js)
-import { BaseErrorCode, McpError } from "../../../types-global/errors.js"; // Keep direct import for types-global
-// Import utils from barrel (sanitization from ../utils/security/sanitization.js)
-import { sanitization } from "../../../utils/index.js";
+import { logger, sanitization } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
 const execFileAsync = promisify(execFile);
-// 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 directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
-    remote: z
-        .string()
-        .optional()
-        .describe("The remote repository to push to (e.g., 'origin'). Defaults to the tracked upstream or 'origin'."),
-    branch: z
-        .string()
-        .optional()
-        .describe("The local branch to push (e.g., 'main', 'feat/new-login'). Defaults to the current branch."),
-    remoteBranch: z
-        .string()
-        .optional()
-        .describe("The remote branch to push to (e.g., 'main', 'develop'). Defaults to the same name as the local branch."),
-    force: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("Force the push (use with caution: `--force-with-lease` is generally safer)."),
-    forceWithLease: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("Force the push only if the remote ref is the expected value (`--force-with-lease`). Safer than --force."),
-    setUpstream: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("Set the upstream tracking configuration (`-u` or `--set-upstream`)."),
-    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)
+// 1. DEFINE the Zod input schema.
+export const GitPushBaseSchema = z.object({
+    path: z.string().default(".").describe("Path to the Git repository."),
+    remote: z.string().optional().describe("The remote repository to push to (e.g., 'origin')."),
+    branch: z.string().optional().describe("The local branch to push."),
+    remoteBranch: z.string().optional().describe("The remote branch to push to."),
+    force: z.boolean().default(false).describe("Force the push (use with caution)."),
+    forceWithLease: z.boolean().default(false).describe("Force the push only if the remote ref is as expected."),
+    setUpstream: z.boolean().default(false).describe("Set the upstream tracking configuration."),
+    tags: z.boolean().default(false).describe("Push all tags."),
+    delete: z.boolean().default(false).describe("Delete the remote branch."),
+});
+export const GitPushInputSchema = GitPushBaseSchema.refine(data => !(data.delete && !data.branch), {
+    message: "Cannot use --delete without specifying a branch to delete.",
+    path: ["delete", "branch"],
+}).refine(data => !(data.force && data.forceWithLease), {
+    message: "Cannot use --force and --force-with-lease together.",
+    path: ["force", "forceWithLease"],
+});
+// 2. DEFINE the Zod response schema.
+export const GitPushOutputSchema = z.object({
+    success: z.boolean().describe("Indicates if the command was successful."),
+    message: z.string().describe("A summary message of the result."),
+    rejected: z.boolean().optional().describe("True if the push was rejected."),
+    deleted: z.boolean().optional().describe("True if a remote branch was deleted."),
 });
 /**
- * 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.
+ * 4. IMPLEMENT the core logic function.
+ * @throws {McpError} If the logic encounters an unrecoverable issue.
  */
-export async function pushGitChanges(input, context) {
+export async function pushGitChanges(params, 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, {
-            allowAbsolute: true,
-        }).sanitizedPath;
-        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
-        const args = ["-C", targetPath, "push"];
-        if (input.force) {
-            args.push("--force");
-        }
-        else if (input.forceWithLease) {
-            args.push("--force-with-lease");
-        }
-        if (input.setUpstream) {
-            args.push("--set-upstream");
-        }
-        if (input.tags) {
-            args.push("--tags");
-        }
-        if (input.delete) {
-            args.push("--delete");
-        }
-        // Add remote and branch specification
-        const remote = input.remote || "origin"; // Default to origin
-        args.push(remote);
-        if (input.branch) {
-            if (input.remoteBranch && !input.delete) {
-                args.push(`${input.branch}:${input.remoteBranch}`);
-            }
-            else {
-                args.push(input.branch);
-            }
-        }
-        else if (!input.tags && !input.delete) {
-            // If no branch, tags, or delete specified, push the current branch by default
-            logger.debug("No specific branch, tags, or delete specified. Relying on default git push behavior for current branch.", { ...context, operation });
-        }
-        logger.debug(`Executing command: git ${args.join(" ")}`, {
-            ...context,
-            operation,
-        });
-        // Execute command. Note: Git push often uses stderr for progress and success messages.
-        const { stdout, stderr } = await execFileAsync("git", args);
-        logger.debug(`Git push stdout: ${stdout}`, { ...context, operation });
-        if (stderr) {
-            logger.debug(`Git push stderr: ${stderr}`, { ...context, operation });
-        }
-        // Analyze stderr primarily, fallback to stdout
-        const message = stderr.trim() || stdout.trim() || "Push command executed.";
-        const summary = message;
-        const rejected = message.includes("[rejected]");
-        const deleted = message.includes("[deleted]");
-        logger.info("git push executed successfully", {
-            ...context,
-            operation,
-            path: targetPath,
-            summary,
-            rejected,
-            deleted,
-        });
-        return { success: true, message, summary, rejected, deleted };
+    logger.debug(`Executing ${operation}`, { ...context, params });
+    const workingDir = context.getWorkingDirectory();
+    if (params.path === "." && !workingDir) {
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, "No session working directory set. Please specify a 'path' or use 'git_set_working_dir' first.");
     }
-    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.SERVICE_UNAVAILABLE, `Failed to connect to remote repository. Error: ${errorMessage}`, { context, operation, originalError: error });
+    const targetPath = sanitization.sanitizePath(params.path === "." ? workingDir : params.path, { allowAbsolute: true }).sanitizedPath;
+    const args = ["-C", targetPath, "push"];
+    if (params.force)
+        args.push("--force");
+    else if (params.forceWithLease)
+        args.push("--force-with-lease");
+    if (params.setUpstream)
+        args.push("--set-upstream");
+    if (params.tags)
+        args.push("--tags");
+    if (params.delete)
+        args.push("--delete");
+    args.push(params.remote || "origin");
+    if (params.branch) {
+        if (params.remoteBranch && !params.delete) {
+            args.push(`${params.branch}:${params.remoteBranch}`);
         }
-        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
-            throw new McpError(BaseErrorCode.CONFLICT, `Push rejected: ${errorMessage}`, { context, operation, originalError: error });
-        }
-        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 });
+        else {
+            args.push(params.branch);
         }
-        // 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 });
     }
+    logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+    const { stdout, stderr } = await execFileAsync("git", args);
+    const message = stderr.trim() || stdout.trim() || "Push command executed successfully.";
+    return {
+        success: true,
+        message,
+        rejected: message.includes("[rejected]"),
+        deleted: message.includes("[deleted]"),
+    };
 }