@cyanheads/git-mcp-server 2.1.0 → 2.1.2

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

@@ -1,19 +1,34 @@
-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 input schema for the git_checkout tool using Zod
 export const GitCheckoutInputSchema = 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."),
-    branchOrPath: z.string().min(1).describe("The branch name (e.g., 'main'), commit hash, tag, or file path(s) (e.g., './src/file.ts') to checkout."),
-    newBranch: z.string().optional().describe("Create a new branch named <new_branch> (e.g., 'feat/new-feature') and start it at <branchOrPath>."),
-    force: z.boolean().optional().default(false).describe("Force checkout even if there are uncommitted changes (use with caution, discards local changes)."),
+    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."),
+    branchOrPath: z
+        .string()
+        .min(1)
+        .describe("The branch name (e.g., 'main'), commit hash, tag, or file path(s) (e.g., './src/file.ts') to checkout."),
+    newBranch: z
+        .string()
+        .optional()
+        .describe("Create a new branch named <new_branch> (e.g., 'feat/new-feature') and start it at <branchOrPath>."),
+    force: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Force checkout even if there are uncommitted changes (use with caution, discards local changes)."),
     // Add other relevant git checkout options as needed (e.g., --track, -b for new branch shorthand)
 });
 /**
@@ -26,12 +41,12 @@ export const GitCheckoutInputSchema = z.object({
  * @throws {McpError} Throws an McpError if path resolution, validation, or the git command fails unexpectedly.
  */
 export async function checkoutGit(input, context) {
-    const operation = 'checkoutGit';
+    const operation = "checkoutGit";
     logger.debug(`Executing ${operation}`, { ...context, input });
     let targetPath;
     try {
         // Resolve and sanitize the target path
-        if (input.path && input.path !== '.') {
+        if (input.path && input.path !== ".") {
             targetPath = input.path;
         }
         else {
@@ -41,170 +56,95 @@ export async function checkoutGit(input, context) {
             }
             targetPath = workingDir;
         }
-        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 });
     }
     // Basic sanitization for branch/path argument
-    const safeBranchOrPath = input.branchOrPath.replace(/[`$&;*()|<>]/g, ''); // Remove potentially dangerous characters
+    const safeBranchOrPath = input.branchOrPath.replace(/[`$&;*()|<>]/g, ""); // Remove potentially dangerous characters
     try {
         // Construct the git checkout command
         let command = `git -C "${targetPath}" checkout`;
         if (input.force) {
-            command += ' --force';
+            command += " --force";
         }
         if (input.newBranch) {
-            const safeNewBranch = input.newBranch.replace(/[^a-zA-Z0-9_.\-/]/g, ''); // Sanitize new branch name
+            const safeNewBranch = input.newBranch.replace(/[^a-zA-Z0-9_.\-/]/g, ""); // Sanitize new branch name
             command += ` -b ${safeNewBranch}`;
         }
         command += ` ${safeBranchOrPath}`; // Add the target branch/path
         logger.debug(`Executing command: ${command}`, { ...context, operation });
         // Execute command. Checkout often uses stderr for status messages.
         const { stdout, stderr } = await execAsync(command);
-        logger.info(`Git checkout stdout: ${stdout}`, { ...context, operation });
-        logger.info(`Git checkout stderr: ${stderr}`, { ...context, operation }); // Log stderr as info
-        // Analyze stderr primarily, fallback to stdout
-        let message = stderr.trim() || stdout.trim();
-        let success = true;
-        let previousBranch = undefined;
-        let currentBranch = undefined;
-        let newBranchCreated = !!input.newBranch;
-        let filesRestored = undefined;
-        let isDetachedHead = false;
-        let isFileCheckout = false;
-        // --- Initial analysis of checkout output ---
-        // Extract previous branch if available
-        const prevBranchMatch = stderr.match(/Switched to.*? from ['"]?(.*?)['"]?/);
-        if (prevBranchMatch) {
-            previousBranch = prevBranchMatch[1];
-        }
-        // Determine primary outcome from stderr/stdout
-        if (stderr.includes('Switched to a new branch')) {
-            const currentBranchMatch = stderr.match(/Switched to a new branch ['"]?(.*?)['"]?/);
-            currentBranch = currentBranchMatch ? currentBranchMatch[1] : input.newBranch; // Use matched or input
-            message = `Switched to new branch '${currentBranch}'.`;
-            newBranchCreated = true;
-        }
-        else if (stderr.includes('Switched to branch')) {
-            const currentBranchMatch = stderr.match(/Switched to branch ['"]?(.*?)['"]?/);
-            currentBranch = currentBranchMatch ? currentBranchMatch[1] : input.branchOrPath; // Use matched or input
-            message = `Switched to branch '${currentBranch}'.`;
-        }
-        else if (stderr.includes('Already on')) {
-            const currentBranchMatch = stderr.match(/Already on ['"]?(.*?)['"]?/);
-            currentBranch = currentBranchMatch ? currentBranchMatch[1] : input.branchOrPath; // Use matched or input
-            message = `Already on '${currentBranch}'.`;
-        }
-        else if (stderr.includes('Updated N path') || stdout.includes('Updated N path') || stderr.includes('Your branch is up to date with')) { // Checking out files or confirming current state
-            // Check if the input looks like file paths rather than a branch/commit
-            // This is heuristic - might need refinement if branch names look like paths
-            if (input.branchOrPath.includes('/') || input.branchOrPath.includes('.')) {
-                isFileCheckout = true;
-                message = `Restored or checked path(s): ${input.branchOrPath}`;
-                filesRestored = input.branchOrPath.split('\n').map(p => p.trim()).filter(p => p.length > 0);
-            }
-            else {
-                // Assume it was just confirming the current branch state
-                message = stderr.trim() || stdout.trim() || `Checked out ${input.branchOrPath}.`;
-            }
-        }
-        else if (stderr.includes('Previous HEAD position was') && stderr.includes('HEAD is now at')) { // Detached HEAD
-            message = `Checked out commit ${input.branchOrPath} (Detached HEAD state).`;
-            currentBranch = 'Detached HEAD';
-            isDetachedHead = true;
-        }
-        else if (stderr.includes('Note: switching to') || stderr.includes('Note: checking out')) { // Other detached HEAD variants
-            message = `Checked out ${input.branchOrPath} (Detached HEAD state).`;
-            currentBranch = 'Detached HEAD';
-            isDetachedHead = true;
-        }
-        else if (message.includes('fatal:')) {
-            success = false;
-            message = `Checkout failed: ${message}`;
-            logger.error(`Git checkout command indicated failure: ${message}`, { ...context, operation, stdout, stderr });
-        }
-        else if (!message && !stdout && !stderr) {
-            message = 'Checkout command executed silently.'; // Assume success, will verify branch below
-            logger.info(message, { ...context, operation });
-        }
-        else {
-            // Some other message, treat as informational for now
-            message = stderr.trim() || stdout.trim();
-            logger.info(`Git checkout produced message: ${message}`, { ...context, operation });
-        }
-        // --- Get definitive current branch IF checkout was successful AND not file checkout/detached HEAD ---
-        if (success && !isFileCheckout && !isDetachedHead) {
-            try {
-                logger.debug('Attempting to get current branch via git branch --show-current', { ...context, operation });
-                const statusResult = await execAsync(`git -C "${targetPath}" branch --show-current`);
-                const definitiveCurrentBranch = statusResult.stdout.trim();
-                if (definitiveCurrentBranch) {
-                    currentBranch = definitiveCurrentBranch;
-                    logger.info(`Confirmed current branch: ${currentBranch}`, { ...context, operation });
-                    // Refine message if it wasn't specific before
-                    if (message.startsWith('Checkout command executed silently') || message.startsWith('Checked out ')) {
-                        message = `Checked out '${currentBranch}'.`;
-                    }
-                    else if (message.startsWith('Already on') && !message.includes(`'${currentBranch}'`)) {
-                        message = `Already on '${currentBranch}'.`; // Update if initial parse was wrong
-                    }
-                    else if (message.startsWith('Switched to branch') && !message.includes(`'${currentBranch}'`)) {
-                        message = `Switched to branch '${currentBranch}'.`; // Update if initial parse was wrong
-                    }
-                }
-                else {
-                    // Command succeeded but returned empty - might be detached HEAD after all?
-                    logger.warning('git branch --show-current returned empty, possibly detached HEAD?', { ...context, operation });
-                    // Keep potentially parsed 'Detached HEAD' or fallback to input if needed
-                    currentBranch = currentBranch || 'Unknown (possibly detached)';
-                    if (!message.includes('Detached HEAD'))
-                        message += ' (Could not confirm branch name).';
-                }
-            }
-            catch (statusError) {
-                logger.warning('Could not determine current branch after checkout', { ...context, operation, error: statusError.message });
-                // Keep potentially parsed 'Detached HEAD' or fallback to input if needed
-                currentBranch = currentBranch || 'Unknown (error checking)';
-                if (!message.includes('Detached HEAD'))
-                    message += ' (Error checking branch name).';
-            }
-        }
-        else if (success && isFileCheckout) {
-            // If it was a file checkout, still try to get the branch name for context
-            try {
-                const statusResult = await execAsync(`git -C "${targetPath}" branch --show-current`);
-                currentBranch = statusResult.stdout.trim() || 'Unknown (possibly detached)';
-            }
-            catch {
-                currentBranch = 'Unknown (error checking)';
-            }
-            logger.info(`Current branch after file checkout: ${currentBranch}`, { ...context, operation });
-        }
-        logger.info(`${operation} completed`, { ...context, operation, path: targetPath, success, message, currentBranch });
-        return { success, message, previousBranch, currentBranch, newBranchCreated, filesRestored };
+        const message = stderr.trim() || stdout.trim();
+        logger.debug(`Git checkout stdout: ${stdout}`, { ...context, operation });
+        if (stderr) {
+            logger.debug(`Git checkout stderr: ${stderr}`, { ...context, operation });
+        }
+        // Get the current branch name after the checkout operation
+        let currentBranch;
+        try {
+            const { stdout: branchStdout } = await execAsync(`git -C "${targetPath}" branch --show-current`);
+            currentBranch = branchStdout.trim();
+        }
+        catch (e) {
+            // This can fail in detached HEAD state, which is not an error for checkout
+            currentBranch = "Detached HEAD";
+        }
+        const result = {
+            success: true,
+            message,
+            currentBranch,
+            newBranchCreated: !!input.newBranch,
+        };
+        logger.info("git checkout executed successfully", {
+            ...context,
+            operation,
+            path: targetPath,
+            result,
+        });
+        return result;
     }
     catch (error) {
-        logger.error(`Failed to execute git checkout command`, { ...context, operation, path: targetPath, error: error.message, stderr: error.stderr, stdout: error.stdout });
-        const errorMessage = error.stderr || error.stdout || error.message || '';
+        logger.error(`Failed to execute git checkout 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')) {
+        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.match(/pathspec '.*?' did not match any file\(s\) known to git/)) {
             throw new McpError(BaseErrorCode.NOT_FOUND, `Branch or pathspec not found: ${input.branchOrPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        if (errorMessage.includes('already exists')) { // e.g., trying -b with existing branch name
+        if (errorMessage.includes("already exists")) {
+            // e.g., trying -b with existing branch name
             throw new McpError(BaseErrorCode.CONFLICT, `Cannot create new branch '${input.newBranch}': it already exists. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        if (errorMessage.includes('Your local changes to the following files would be overwritten by checkout')) {
+        if (errorMessage.includes("Your local changes to the following files would be overwritten by checkout")) {
             throw new McpError(BaseErrorCode.CONFLICT, `Checkout failed due to uncommitted local changes that would be overwritten. Please commit or stash them first, or use --force. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        if (errorMessage.includes('invalid reference')) {
+        if (errorMessage.includes("invalid reference")) {
             throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid branch name or reference: ${input.branchOrPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
         // Generic internal error for other failures

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

@@ -1,11 +1,11 @@
 // 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 (logger from ../utils/internal/logger.js)
-import { logger } from '../../../utils/index.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 { checkoutGit, GitCheckoutInputSchema } from './logic.js';
+import { BaseErrorCode } from "../../../types-global/errors.js"; // Keep direct import for types-global
+import { requestContextService } from "../../../utils/index.js";
+import { checkoutGit, GitCheckoutInputSchema, } from "./logic.js";
 let _getWorkingDirectory;
 let _getSessionId;
 /**
@@ -17,9 +17,9 @@ let _getSessionId;
 export function initializeGitCheckoutStateAccessors(getWdFn, getSidFn) {
     _getWorkingDirectory = getWdFn;
     _getSessionId = getSidFn;
-    logger.info('State accessors initialized for git_checkout tool registration.');
+    logger.info("State accessors initialized for git_checkout tool registration.");
 }
-const TOOL_NAME = 'git_checkout';
+const TOOL_NAME = "git_checkout";
 const TOOL_DESCRIPTION = "Switches branches or restores working tree files. Can checkout branches, commits, tags, or specific file paths. Supports creating new branches and forcing checkout.";
 /**
  * Registers the git_checkout tool with the MCP server.
@@ -29,15 +29,18 @@ const TOOL_DESCRIPTION = "Switches branches or restores working tree files. Can
  */
 export async function registerGitCheckoutTool(server) {
     if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error('State accessors for git_checkout must be initialized before registration.');
+        throw new Error("State accessors for git_checkout must be initialized before registration.");
     }
-    const operation = 'registerGitCheckoutTool';
+    const operation = "registerGitCheckoutTool";
     const context = requestContextService.createRequestContext({ operation });
     await ErrorHandler.tryCatch(async () => {
         server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitCheckoutInputSchema.shape, // Provide the Zod schema shape
         async (validatedArgs, callContext) => {
-            const toolOperation = 'tool:git_checkout';
-            const requestContext = requestContextService.createRequestContext({ operation: toolOperation, parentContext: callContext });
+            const toolOperation = "tool:git_checkout";
+            const requestContext = requestContextService.createRequestContext({
+                operation: toolOperation,
+                parentContext: callContext,
+            });
             const sessionId = _getSessionId(requestContext);
             const getWorkingDirectoryForSession = () => {
                 return _getWorkingDirectory(sessionId);
@@ -53,9 +56,9 @@ export async function registerGitCheckoutTool(server) {
                 const checkoutResult = await checkoutGit(validatedArgs, logicContext);
                 // Format the result as a JSON string within TextContent
                 const resultContent = {
-                    type: 'text',
+                    type: "text",
                     text: JSON.stringify(checkoutResult, null, 2), // Pretty-print JSON
-                    contentType: 'application/json',
+                    contentType: "application/json",
                 };
                 // Log based on the success flag in the result
                 if (checkoutResult.success) {
@@ -78,4 +81,3 @@ export async function registerGitCheckoutTool(server) {
         logger.info(`Tool registered: ${TOOL_NAME}`, context);
     }, { operation, context, critical: true });
 }
-;

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

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

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

@@ -1,21 +1,43 @@
-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 input schema for the git_cherry-pick tool using Zod
 export const GitCherryPickInputSchema = z.object({
-    path: z.string().min(1).optional().default('.').describe("Path to the local Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
-    commitRef: z.string().min(1).describe("The commit reference(s) to cherry-pick (e.g., 'hash1', 'hash1..hash3', 'branchName~3..branchName')."),
-    mainline: z.number().int().min(1).optional().describe("Specify the parent number (starting from 1) when cherry-picking a merge commit."),
-    strategy: z.enum(['recursive', 'resolve', 'ours', 'theirs', 'octopus', 'subtree']).optional().describe("Specifies a merge strategy *option* (passed via -X)."),
-    noCommit: z.boolean().default(false).describe("Apply the changes but do not create a commit."),
-    signoff: z.boolean().default(false).describe("Add a Signed-off-by line to the commit message."),
+    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."),
+    commitRef: z
+        .string()
+        .min(1)
+        .describe("The commit reference(s) to cherry-pick (e.g., 'hash1', 'hash1..hash3', 'branchName~3..branchName')."),
+    mainline: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe("Specify the parent number (starting from 1) when cherry-picking a merge commit."),
+    strategy: z
+        .enum(["recursive", "resolve", "ours", "theirs", "octopus", "subtree"])
+        .optional()
+        .describe("Specifies a merge strategy *option* (passed via -X)."),
+    noCommit: z
+        .boolean()
+        .default(false)
+        .describe("Apply the changes but do not create a commit."),
+    signoff: z
+        .boolean()
+        .default(false)
+        .describe("Add a Signed-off-by line to the commit message."),
     // Add options for conflict handling? (e.g., --continue, --abort, --skip) - Maybe separate tool or mode?
 });
 /**
@@ -27,31 +49,47 @@ export const GitCherryPickInputSchema = z.object({
  * @throws {McpError} Throws an McpError for path resolution/validation failures or unexpected errors.
  */
 export async function gitCherryPickLogic(input, context) {
-    const operation = 'gitCherryPickLogic';
+    const operation = "gitCherryPickLogic";
     logger.debug(`Executing ${operation}`, { ...context, input });
     let targetPath;
     try {
         // Resolve and sanitize the target path
         const workingDir = context.getWorkingDirectory();
-        targetPath = (input.path && input.path !== '.')
-            ? input.path
-            : workingDir ?? '.';
-        if (targetPath === '.' && !workingDir) {
+        targetPath =
+            input.path && input.path !== "." ? input.path : (workingDir ?? ".");
+        if (targetPath === "." && !workingDir) {
             logger.warning("Executing git cherry-pick in server's CWD as no path provided and no session WD set.", { ...context, operation });
             targetPath = process.cwd();
         }
-        else if (targetPath === '.' && workingDir) {
+        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 });
@@ -63,9 +101,9 @@ export async function gitCherryPickLogic(input, context) {
         if (input.strategy)
             command += ` -X${input.strategy}`; // Note: -X for strategy options
         if (input.noCommit)
-            command += ' --no-commit';
+            command += " --no-commit";
         if (input.signoff)
-            command += ' --signoff';
+            command += " --signoff";
         // Add the commit reference(s) - ensure it's treated as a single argument potentially containing special chars like '..'
         command += ` "${input.commitRef.replace(/"/g, '\\"')}"`;
         logger.debug(`Executing command: ${command}`, { ...context, operation });
@@ -77,42 +115,63 @@ export async function gitCherryPickLogic(input, context) {
             const commitCreated = !input.noCommit && !conflicts;
             const message = conflicts
                 ? `Cherry-pick resulted in conflicts for commit(s) '${input.commitRef}'. Manual resolution required.`
-                : `Successfully cherry-picked commit(s) '${input.commitRef}'.` + (commitCreated ? ' New commit created.' : (input.noCommit ? ' Changes staged.' : ''));
-            logger.info(message, { ...context, operation, path: targetPath, conflicts, commitCreated });
+                : `Successfully cherry-picked commit(s) '${input.commitRef}'.` +
+                    (commitCreated
+                        ? " New commit created."
+                        : input.noCommit
+                            ? " Changes staged."
+                            : "");
+            logger.info("git cherry-pick executed successfully", {
+                ...context,
+                operation,
+                path: targetPath,
+                result: { message, conflicts, commitCreated },
+            });
             return { success: true, message, commitCreated, conflicts };
         }
         catch (cherryPickError) {
-            const errorMessage = cherryPickError.stderr || cherryPickError.stdout || cherryPickError.message || '';
+            const errorMessage = cherryPickError.stderr ||
+                cherryPickError.stdout ||
+                cherryPickError.message ||
+                "";
             if (/conflict/i.test(errorMessage)) {
                 logger.warning(`Cherry-pick failed due to conflicts for commit(s) '${input.commitRef}'.`, { ...context, operation, path: targetPath, error: errorMessage });
-                return { success: false, message: `Failed to cherry-pick commit(s) '${input.commitRef}' due to conflicts. Resolve conflicts manually and potentially use 'git cherry-pick --continue' or '--abort'.`, error: errorMessage, conflicts: true };
+                return {
+                    success: false,
+                    message: `Failed to cherry-pick commit(s) '${input.commitRef}' due to conflicts. Resolve conflicts manually and potentially use 'git cherry-pick --continue' or '--abort'.`,
+                    error: errorMessage,
+                    conflicts: true,
+                };
             }
             // Rethrow other errors to be caught by the outer try-catch
             throw cherryPickError;
         }
     }
     catch (error) {
-        const errorMessage = error.stderr || error.stdout || error.message || '';
-        logger.error(`Failed to execute git cherry-pick command`, { ...context, operation, path: targetPath, error: errorMessage, stderr: error.stderr, stdout: error.stdout });
+        const errorMessage = error.stderr || error.stdout || error.message || "";
+        logger.error(`Failed to execute git cherry-pick command`, {
+            ...context,
+            operation,
+            path: targetPath,
+            error: errorMessage,
+            stderr: error.stderr,
+            stdout: error.stdout,
+        });
         // Specific error handling
-        if (errorMessage.toLowerCase().includes('not a git repository')) {
+        if (errorMessage.toLowerCase().includes("not a git repository")) {
             throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`, { context, operation, originalError: error });
         }
         if (/bad revision/i.test(errorMessage)) {
-            return { success: false, message: `Failed to cherry-pick: Invalid commit reference '${input.commitRef}'.`, error: errorMessage };
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Failed to cherry-pick: Invalid commit reference '${input.commitRef}'. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
         if (/after resolving the conflicts/i.test(errorMessage)) {
             // This might indicate a previous conflict state
-            return { success: false, message: `Failed to cherry-pick: Unresolved conflicts from a previous operation exist. Resolve conflicts and use 'git cherry-pick --continue' or '--abort'.`, error: errorMessage, conflicts: true };
+            throw new McpError(BaseErrorCode.CONFLICT, `Failed to cherry-pick: Unresolved conflicts from a previous operation exist. Resolve conflicts and use 'git cherry-pick --continue' or '--abort'. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
         if (/your local changes would be overwritten/i.test(errorMessage)) {
-            return { success: false, message: `Failed to cherry-pick: Your local changes to tracked files would be overwritten. Please commit or stash them.`, error: errorMessage };
+            throw new McpError(BaseErrorCode.CONFLICT, `Failed to cherry-pick: Your local changes to tracked files would be overwritten. Please commit or stash them. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        // Return structured failure for other git errors
-        return {
-            success: false,
-            message: `Git cherry-pick failed for path: ${targetPath}.`,
-            error: errorMessage
-        };
+        // Throw a generic McpError for other failures
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git cherry-pick failed for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
     }
 }