@cyanheads/git-mcp-server 2.1.0 → 2.1.2

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

@@ -1,30 +1,66 @@
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { z } from 'zod';
+import { exec } 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 { 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 { 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 { sanitization } from "../../../utils/index.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. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not 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."),
+    path: z
+        .string()
+        .min(1)
+        .optional()
+        .default(".")
+        .describe("Path to the local Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not 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"],
+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.
@@ -41,25 +77,41 @@ export async function gitRebaseLogic(input, context) {
     try {
         // Resolve and sanitize the target path
         const workingDir = context.getWorkingDirectory();
-        targetPath = (input.path && input.path !== '.')
-            ? input.path
-            : workingDir ?? '.';
-        if (targetPath === '.' && !workingDir) {
+        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) {
+        else if (targetPath === "." && workingDir) {
             targetPath = workingDir;
-            logger.debug(`Using session working directory: ${targetPath}`, { ...context, operation, sessionId: context.sessionId });
+            logger.debug(`Using session working directory: ${targetPath}`, {
+                ...context,
+                operation,
+                sessionId: context.sessionId,
+            });
         }
         else {
-            logger.debug(`Using provided path: ${targetPath}`, { ...context, operation });
+            logger.debug(`Using provided path: ${targetPath}`, {
+                ...context,
+                operation,
+            });
         }
-        targetPath = sanitization.sanitizePath(targetPath, { allowAbsolute: true }).sanitizedPath;
-        logger.debug('Sanitized path', { ...context, operation, sanitizedPath: targetPath });
+        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 });
+        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 });
@@ -67,9 +119,9 @@ export async function gitRebaseLogic(input, context) {
     try {
         let command = `git -C "${targetPath}" rebase`;
         switch (input.mode) {
-            case 'start':
+            case "start":
                 if (input.interactive)
-                    command += ' -i';
+                    command += " -i";
                 if (input.strategy)
                     command += ` --strategy=${input.strategy}`;
                 if (input.strategyOption)
@@ -82,14 +134,14 @@ export async function gitRebaseLogic(input, context) {
                 if (input.branch)
                     command += ` "${input.branch.replace(/"/g, '\\"')}"`;
                 break;
-            case 'continue':
-                command += ' --continue';
+            case "continue":
+                command += " --continue";
                 break;
-            case 'abort':
-                command += ' --abort';
+            case "abort":
+                command += " --abort";
                 break;
-            case 'skip':
-                command += ' --skip';
+            case "skip":
+                command += " --skip";
                 break;
             default:
                 // Should not happen due to Zod validation
@@ -99,74 +151,61 @@ export async function gitRebaseLogic(input, context) {
         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) };
+            const message = `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: /conflict|stopped at|edit/i.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 });
+            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 };
+                throw new McpError(BaseErrorCode.CONFLICT, `Rebase ${input.mode} failed due to conflicts. Resolve conflicts and use 'git rebase --continue'. Error: ${errorMessage}`, { context, operation, originalError: rebaseError });
             }
             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 };
+                throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Failed to ${input.mode} rebase: No rebase is currently in progress. Error: ${errorMessage}`, { context, operation, originalError: rebaseError });
             }
             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 };
+                throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Failed to start rebase: Cannot rebase onto multiple branches. Check your 'upstream' parameter. Error: ${errorMessage}`, { context, operation, originalError: rebaseError });
             }
             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 };
+                throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Failed to start rebase: Invalid upstream, branch, or onto reference provided. Error: ${errorMessage}`, { context, operation, originalError: rebaseError });
             }
             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 };
+                throw new McpError(BaseErrorCode.CONFLICT, `Failed to ${input.mode} rebase: Your local changes to tracked files would be overwritten. Please commit or stash them. Error: ${errorMessage}`, { context, operation, originalError: rebaseError });
             }
             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 new McpError(BaseErrorCode.CONFLICT, `Failed to start rebase: An interactive rebase is already in progress. Use 'continue', 'abort', or 'skip'. Error: ${errorMessage}`, { context, operation, originalError: rebaseError });
             }
             // Throw McpError for critical issues like non-existent repo
-            if (errorMessage.toLowerCase().includes('not a git repository')) {
+            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
-            };
+            // Throw a generic McpError for other failures
+            throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git rebase ${input.mode} failed for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: rebaseError });
         }
     }
     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 });
+        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

@@ -1,11 +1,11 @@
 // Import utils from barrel (logger from ../utils/internal/logger.js)
-import { logger } from '../../../utils/index.js';
+import { logger } from "../../../utils/index.js";
 // Import utils from barrel (ErrorHandler from ../utils/internal/errorHandler.js)
-import { ErrorHandler } from '../../../utils/index.js';
+import { ErrorHandler } from "../../../utils/index.js";
 // Import utils from barrel (requestContextService 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 { GitRebaseBaseSchema, gitRebaseLogic } from './logic.js';
+import { BaseErrorCode } from "../../../types-global/errors.js"; // Keep direct import for types-global
+import { requestContextService } from "../../../utils/index.js";
+import { GitRebaseBaseSchema, gitRebaseLogic, } from "./logic.js";
 let _getWorkingDirectory;
 let _getSessionId;
 /**
@@ -16,10 +16,10 @@ let _getSessionId;
 export function initializeGitRebaseStateAccessors(getWdFn, getSidFn) {
     _getWorkingDirectory = getWdFn;
     _getSessionId = getSidFn;
-    logger.info('State accessors initialized for git_rebase tool registration.');
+    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.';
+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.
  *
@@ -29,9 +29,9 @@ const TOOL_DESCRIPTION = 'Reapplies commits on top of another base tip. Supports
  */
 export const registerGitRebaseTool = async (server) => {
     if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error('State accessors for git_rebase must be initialized before registration.');
+        throw new Error("State accessors for git_rebase must be initialized before registration.");
     }
-    const operation = 'registerGitRebaseTool';
+    const operation = "registerGitRebaseTool";
     const context = requestContextService.createRequestContext({ operation });
     await ErrorHandler.tryCatch(async () => {
         // Register using the BASE schema shape
@@ -40,7 +40,10 @@ export const registerGitRebaseTool = async (server) => {
         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 requestContext = requestContextService.createRequestContext({
+                operation: toolOperation,
+                parentContext: callContext,
+            });
             const sessionId = _getSessionId(requestContext);
             const getWorkingDirectoryForSession = () => _getWorkingDirectory(sessionId);
             const logicContext = {
@@ -52,15 +55,19 @@ export const registerGitRebaseTool = async (server) => {
             return await ErrorHandler.tryCatch(async () => {
                 const rebaseResult = await gitRebaseLogic(toolInput, logicContext);
                 const resultContent = {
-                    type: 'text',
+                    type: "text",
                     text: JSON.stringify(rebaseResult, null, 2), // Pretty-print JSON
-                    contentType: 'application/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 });
+                    logger.warning(`Tool ${TOOL_NAME} (mode: ${toolInput.mode}) failed: ${rebaseResult.message}`, {
+                        ...logicContext,
+                        errorDetails: rebaseResult.error,
+                        conflicts: rebaseResult.conflicts,
+                    });
                 }
                 return { content: [resultContent] };
             }, {

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

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

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

@@ -1,14 +1,25 @@
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { z } from 'zod';
-import { BaseErrorCode, McpError } from '../../../types-global/errors.js'; // Direct import for types-global
-import { logger, sanitization } from '../../../utils/index.js'; // Logger (./utils/internal/logger.js) & RequestContext (./utils/internal/requestContext.js) & sanitization (./utils/security/sanitization.js)
+import { exec } from "child_process";
+import { promisify } from "util";
+import { z } from "zod";
+import { BaseErrorCode, McpError } from "../../../types-global/errors.js"; // Direct import for types-global
+import { logger, sanitization } from "../../../utils/index.js"; // Logger (./utils/internal/logger.js) & RequestContext (./utils/internal/requestContext.js) & sanitization (./utils/security/sanitization.js)
 const execAsync = promisify(exec);
 // Define the input schema for the git_remote tool using Zod
 export const GitRemoteInputSchema = z.object({
-    path: z.string().min(1).optional().default('.').describe("Path to the Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
-    mode: z.enum(['list', 'add', 'remove', 'show']).describe("Operation mode: 'list', 'add', 'remove', 'show'"),
-    name: z.string().min(1).optional().describe("Remote name (required for 'add', 'remove', 'show')"),
+    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."),
+    mode: z
+        .enum(["list", "add", "remove", "show"])
+        .describe("Operation mode: 'list', 'add', 'remove', 'show'"),
+    name: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Remote name (required for 'add', 'remove', 'show')"),
     url: z.string().optional().describe("Remote URL (required for 'add')"), // Removed .url() validation
 });
 /**
@@ -26,27 +37,43 @@ export async function gitRemoteLogic(input, context) {
     try {
         // Resolve and sanitize the target path
         const workingDir = context.getWorkingDirectory();
-        targetPath = (input.path && input.path !== '.')
-            ? input.path
-            : workingDir ?? '.'; // Default to '.' if no working dir set and no path provided
-        if (targetPath === '.' && !workingDir) {
+        targetPath =
+            input.path && input.path !== "." ? input.path : (workingDir ?? "."); // Default to '.' if no working dir set and no path provided
+        if (targetPath === "." && !workingDir) {
             logger.warning("Executing git remote in server's CWD as no path provided and no session WD set.", { ...context, operation });
             // Allow execution in CWD but log it clearly. Consider if an error is more appropriate.
             // For now, let's proceed but be aware.
             targetPath = process.cwd(); // Use actual CWD if '.' was the default
         }
-        else if (targetPath === '.' && workingDir) {
+        else if (targetPath === "." && workingDir) {
             targetPath = workingDir;
-            logger.debug(`Using session working directory: ${targetPath}`, { ...context, operation, sessionId: context.sessionId });
+            logger.debug(`Using session working directory: ${targetPath}`, {
+                ...context,
+                operation,
+                sessionId: context.sessionId,
+            });
         }
         else {
-            logger.debug(`Using provided path: ${targetPath}`, { ...context, operation });
+            logger.debug(`Using provided path: ${targetPath}`, {
+                ...context,
+                operation,
+            });
         }
-        targetPath = sanitization.sanitizePath(targetPath, { allowAbsolute: true }).sanitizedPath; // Sanitize the final resolved path
-        logger.debug('Sanitized path', { ...context, operation, sanitizedPath: targetPath });
+        targetPath = sanitization.sanitizePath(targetPath, {
+            allowAbsolute: true,
+        }).sanitizedPath; // Sanitize the final resolved path
+        logger.debug("Sanitized path", {
+            ...context,
+            operation,
+            sanitizedPath: targetPath,
+        });
     }
     catch (error) {
-        logger.error('Path resolution or sanitization failed', { ...context, operation, error });
+        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 });
@@ -55,26 +82,29 @@ export async function gitRemoteLogic(input, context) {
         let command;
         let result;
         switch (input.mode) {
-            case 'list':
+            case "list":
                 command = `git -C "${targetPath}" remote -v`;
-                logger.debug(`Executing command: ${command}`, { ...context, operation });
+                logger.debug(`Executing command: ${command}`, {
+                    ...context,
+                    operation,
+                });
                 const { stdout: listStdout } = await execAsync(command);
                 const remotes = [];
-                const lines = listStdout.trim().split('\n');
+                const lines = listStdout.trim().split("\n");
                 const remoteMap = new Map();
-                lines.forEach(line => {
+                lines.forEach((line) => {
                     const parts = line.split(/\s+/);
                     if (parts.length >= 3) {
                         const name = parts[0];
                         const url = parts[1];
-                        const type = parts[2].replace(/[()]/g, ''); // Remove parentheses around (fetch) or (push)
+                        const type = parts[2].replace(/[()]/g, ""); // Remove parentheses around (fetch) or (push)
                         if (!remoteMap.has(name)) {
                             remoteMap.set(name, {});
                         }
-                        if (type === 'fetch') {
+                        if (type === "fetch") {
                             remoteMap.get(name).fetchUrl = url;
                         }
-                        else if (type === 'push') {
+                        else if (type === "push") {
                             remoteMap.get(name).pushUrl = url;
                         }
                     }
@@ -83,13 +113,13 @@ export async function gitRemoteLogic(input, context) {
                     // Ensure both URLs are present, defaulting to fetch URL if push is missing (common case)
                     remotes.push({
                         name,
-                        fetchUrl: urls.fetchUrl || 'N/A',
-                        pushUrl: urls.pushUrl || urls.fetchUrl || 'N/A',
+                        fetchUrl: urls.fetchUrl || "N/A",
+                        pushUrl: urls.pushUrl || urls.fetchUrl || "N/A",
                     });
                 });
-                result = { success: true, mode: 'list', remotes };
+                result = { success: true, mode: "list", remotes };
                 break;
-            case 'add':
+            case "add":
                 if (!input.name || !input.url) {
                     throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Remote 'name' and 'url' are required for 'add' mode.", { context, operation });
                 }
@@ -98,11 +128,18 @@ export async function gitRemoteLogic(input, context) {
                     throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid remote name: ${input.name}`, { context, operation });
                 }
                 command = `git -C "${targetPath}" remote add "${input.name}" "${input.url}"`;
-                logger.debug(`Executing command: ${command}`, { ...context, operation });
+                logger.debug(`Executing command: ${command}`, {
+                    ...context,
+                    operation,
+                });
                 await execAsync(command);
-                result = { success: true, mode: 'add', message: `Remote '${input.name}' added successfully.` };
+                result = {
+                    success: true,
+                    mode: "add",
+                    message: `Remote '${input.name}' added successfully.`,
+                };
                 break;
-            case 'remove':
+            case "remove":
                 if (!input.name) {
                     throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Remote 'name' is required for 'remove' mode.", { context, operation });
                 }
@@ -110,11 +147,18 @@ export async function gitRemoteLogic(input, context) {
                     throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid remote name: ${input.name}`, { context, operation });
                 }
                 command = `git -C "${targetPath}" remote remove "${input.name}"`;
-                logger.debug(`Executing command: ${command}`, { ...context, operation });
+                logger.debug(`Executing command: ${command}`, {
+                    ...context,
+                    operation,
+                });
                 await execAsync(command);
-                result = { success: true, mode: 'remove', message: `Remote '${input.name}' removed successfully.` };
+                result = {
+                    success: true,
+                    mode: "remove",
+                    message: `Remote '${input.name}' removed successfully.`,
+                };
                 break;
-            case 'show':
+            case "show":
                 if (!input.name) {
                     throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Remote 'name' is required for 'show' mode.", { context, operation });
                 }
@@ -122,36 +166,48 @@ export async function gitRemoteLogic(input, context) {
                     throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid remote name: ${input.name}`, { context, operation });
                 }
                 command = `git -C "${targetPath}" remote show "${input.name}"`;
-                logger.debug(`Executing command: ${command}`, { ...context, operation });
+                logger.debug(`Executing command: ${command}`, {
+                    ...context,
+                    operation,
+                });
                 const { stdout: showStdout } = await execAsync(command);
-                result = { success: true, mode: 'show', details: showStdout.trim() };
+                result = { success: true, mode: "show", details: showStdout.trim() };
                 break;
             default:
                 // Should not happen due to Zod validation, but good practice
                 throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid mode: ${input.mode}`, { context, operation });
         }
-        logger.info(`${operation} executed successfully`, { ...context, operation, path: targetPath });
+        logger.info(`git remote ${input.mode} executed successfully`, {
+            ...context,
+            operation,
+            path: targetPath,
+            result,
+        });
         return result;
     }
     catch (error) {
-        const errorMessage = error.stderr || error.message || '';
-        logger.error(`Failed to execute git remote command`, { ...context, operation, path: targetPath, error: errorMessage, stderr: error.stderr, stdout: error.stdout });
+        const errorMessage = error.stderr || error.message || "";
+        logger.error(`Failed to execute git remote command`, {
+            ...context,
+            operation,
+            path: targetPath,
+            error: errorMessage,
+            stderr: error.stderr,
+            stdout: error.stdout,
+        });
         // Specific error handling
-        if (errorMessage.toLowerCase().includes('not a git repository')) {
+        if (errorMessage.toLowerCase().includes("not a git repository")) {
             throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`, { context, operation, originalError: error });
         }
-        if (input.mode === 'add' && errorMessage.toLowerCase().includes('already exists')) {
-            return { success: false, mode: 'add', message: `Failed to add remote: Remote '${input.name}' already exists.`, error: errorMessage };
+        if (input.mode === "add" &&
+            errorMessage.toLowerCase().includes("already exists")) {
+            throw new McpError(BaseErrorCode.CONFLICT, `Failed to add remote: Remote '${input.name}' already exists. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        if ((input.mode === 'remove' || input.mode === 'show') && errorMessage.toLowerCase().includes('no such remote')) {
-            return { success: false, mode: input.mode, message: `Failed to ${input.mode} remote: Remote '${input.name}' does not exist.`, error: errorMessage };
+        if ((input.mode === "remove" || input.mode === "show") &&
+            errorMessage.toLowerCase().includes("no such remote")) {
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Failed to ${input.mode} remote: Remote '${input.name}' does not exist. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        // Return structured failure for other git errors
-        return {
-            success: false,
-            mode: input.mode,
-            message: `Git remote ${input.mode} failed for path: ${targetPath}.`,
-            error: errorMessage
-        };
+        // Throw a generic McpError for other failures
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git remote ${input.mode} failed for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
     }
 }