@cyanheads/git-mcp-server 2.1.8 → 2.2.0

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

@@ -1,144 +1,55 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_show tool.
+ * @module src/mcp-server/tools/gitShow/logic
+ */
 import { execFile } 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 { 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_show tool using Zod
-// No refinements needed here, so we don't need a separate BaseSchema
+// 1. DEFINE the Zod input schema.
 export const GitShowInputSchema = 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."),
-    ref: z
-        .string()
-        .min(1)
-        .describe("The object reference (commit hash, tag name, branch name, HEAD, etc.) to show."),
-    filePath: z
-        .string()
-        .optional()
-        .describe("Optional specific file path within the ref to show (e.g., show a file's content at a specific commit). If provided, use the format '<ref>:<filePath>'."),
-    // format: z.string().optional().describe("Optional format string for the output"), // Consider adding later
+    path: z.string().default(".").describe("Path to the local Git repository."),
+    ref: z.string().min(1).describe("The object reference (commit hash, tag, branch, etc.) to show."),
+    filePath: z.string().optional().describe("Optional specific file path within the ref to show."),
+});
+// 2. DEFINE the Zod response schema.
+export const GitShowOutputSchema = z.object({
+    success: z.boolean().describe("Indicates if the command was successful."),
+    content: z.string().describe("Raw output from the git show command."),
 });
 /**
- * Executes the 'git show' command for a given reference and optional file path.
- *
- * @param {GitShowInput} input - The validated input object.
- * @param {RequestContext} context - The request context for logging and error handling.
- * @returns {Promise<GitShowResult>} A promise that resolves with the structured result.
- * @throws {McpError} Throws an McpError for path resolution/validation failures or unexpected errors.
+ * 4. IMPLEMENT the core logic function.
+ * @throws {McpError} If the logic encounters an unrecoverable issue.
  */
-export async function gitShowLogic(input, context) {
+export async function gitShowLogic(params, context) {
     const operation = "gitShowLogic";
-    logger.debug(`Executing ${operation}`, { ...context, input });
-    let targetPath;
-    try {
-        // Resolve and sanitize the target path
-        const workingDir = context.getWorkingDirectory();
-        targetPath =
-            input.path && input.path !== "." ? input.path : (workingDir ?? ".");
-        if (targetPath === "." && !workingDir) {
-            logger.warning("Executing git show in server's CWD as no path provided and no session WD set.", { ...context, operation });
-            targetPath = process.cwd();
-        }
-        else if (targetPath === "." && workingDir) {
-            targetPath = workingDir;
-            logger.debug(`Using session working directory: ${targetPath}`, {
-                ...context,
-                operation,
-                sessionId: context.sessionId,
-            });
-        }
-        else {
-            logger.debug(`Using provided path: ${targetPath}`, {
-                ...context,
-                operation,
-            });
-        }
-        targetPath = sanitization.sanitizePath(targetPath, {
-            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 ref format (simple validation)
-    if (!/^[a-zA-Z0-9_./~^:-]+$/.test(input.ref)) {
-        // Allow ':' for filePath combination
-        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid reference format: ${input.ref}`, { context, operation });
-    }
-    // Validate filePath format if provided (basic path chars)
-    if (input.filePath && !/^[a-zA-Z0-9_./-]+$/.test(input.filePath)) {
-        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid file path format: ${input.filePath}`, { context, operation });
+    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 refSpec = params.filePath ? `${params.ref}:${params.filePath}` : params.ref;
+    const args = ["-C", targetPath, "show", refSpec];
     try {
-        // Construct the refspec, combining ref and filePath if needed
-        const refSpec = input.filePath
-            ? `${input.ref}:${input.filePath}`
-            : input.ref;
-        // Construct the command
-        const args = ["-C", targetPath, "show", refSpec];
-        logger.debug(`Executing command: git ${args.join(" ")}`, {
-            ...context,
-            operation,
-        });
-        // Execute command. Note: git show might write to stderr for non-error info (like commit details before diff)
-        // We primarily care about stdout for the content. Errors usually have non-zero exit code.
-        const { stdout, stderr } = await execFileAsync("git", args);
-        if (stderr) {
-            // Log stderr as debug info, as it might contain commit details etc.
-            logger.debug(`Git show command produced stderr (may be informational)`, {
-                ...context,
-                operation,
-                stderr,
-            });
-        }
-        logger.info(`git show executed successfully for ref: ${refSpec}`, {
-            ...context,
-            operation,
-            path: targetPath,
-        });
-        return { success: true, content: stdout }; // Return raw stdout content
+        logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+        const { stdout } = await execFileAsync("git", args);
+        return { success: true, content: stdout };
     }
     catch (error) {
         const errorMessage = error.stderr || error.message || "";
-        logger.error(`Failed to execute git show command`, {
-            ...context,
-            operation,
-            path: targetPath,
-            error: errorMessage,
-            stderr: error.stderr,
-            stdout: error.stdout,
-        });
-        // Specific error handling
+        logger.error(`Failed to execute git show command`, { ...context, operation, errorMessage });
         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 });
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`);
         }
         if (/unknown revision or path not in the working tree/i.test(errorMessage)) {
-            const target = input.filePath
-                ? `${input.ref}:${input.filePath}`
-                : input.ref;
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Failed to show: Reference or pathspec '${target}' not found. Error: ${errorMessage}`, { context, operation, originalError: error });
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Reference or pathspec not found: '${refSpec}'.`);
         }
         if (/ambiguous argument/i.test(errorMessage)) {
-            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Failed to show: Reference '${input.ref}' is ambiguous. Provide a more specific reference. Error: ${errorMessage}`, { context, operation, originalError: error });
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Reference '${params.ref}' is ambiguous.`);
         }
-        // Throw a generic McpError for other failures
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git show failed for path: ${targetPath}, ref: ${input.ref}. Error: ${errorMessage}`, { context, operation, originalError: error });
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git show failed: ${errorMessage}`);
     }
 }

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

@@ -1,86 +1,64 @@
-import { BaseErrorCode } from "../../../types-global/errors.js"; // Direct import for types-global
-import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js"; // logger (./utils/internal/logger.js), ErrorHandler (./utils/internal/errorHandler.js), requestContextService (./utils/internal/requestContext.js)
-// Import the schema and types
-import { GitShowInputSchema, gitShowLogic, } from "./logic.js";
-let _getWorkingDirectory;
-let _getSessionId;
 /**
- * Initializes the state accessors needed by the git_show tool registration.
- * @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_show tool.
+ * @module src/mcp-server/tools/gitShow/registration
  */
-export function initializeGitShowStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_show tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
+import { gitShowLogic, GitShowInputSchema, GitShowOutputSchema, } from "./logic.js";
 const TOOL_NAME = "git_show";
 const TOOL_DESCRIPTION = "Shows information about Git objects (commits, tags, blobs, trees) based on a reference. Can optionally show the content of a specific file at that reference. Returns the raw output.";
 /**
- * Registers the git_show tool with the MCP server.
- *
- * @param {McpServer} server - The McpServer instance to register the tool with.
- * @returns {Promise<void>}
- * @throws {Error} If registration fails or state accessors are not initialized.
+ * Registers the git_show 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 const registerGitShowTool = async (server) => {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_show must be initialized before registration.");
-    }
+export const registerGitShowTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitShowTool";
     const context = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(async () => {
-        // Register the tool using the schema's shape (no refinements here)
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitShowInputSchema.shape, // Use the shape directly
-        // Let TypeScript infer handler argument types.
-        async (validatedArgs, callContext) => {
-            // Cast validatedArgs to the specific input type for use within the handler
-            const toolInput = validatedArgs;
-            const toolOperation = `tool:${TOOL_NAME}`;
-            const requestContext = requestContextService.createRequestContext({
-                operation: toolOperation,
-                parentContext: callContext,
+    server.registerTool(TOOL_NAME, {
+        title: "Git Show",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitShowInputSchema.shape,
+        outputSchema: GitShowOutputSchema.shape,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
+        });
+        try {
+            const sessionId = getSessionId(handlerContext);
+            const result = await gitShowLogic(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: result.content, contentType: "text/plain; charset=utf-8" }],
             };
-            logger.info(`Executing tool: ${TOOL_NAME}`, logicContext);
-            return await ErrorHandler.tryCatch(async () => {
-                // Call the core logic function which returns a GitShowResult object
-                const showResult = await gitShowLogic(toolInput, logicContext);
-                // Format the result within TextContent
-                const resultContent = {
-                    type: "text",
-                    // Return raw content on success, or error message on failure
-                    text: showResult.success
-                        ? showResult.content
-                        : `Error: ${showResult.message}${showResult.error ? `\nDetails: ${showResult.error}` : ""}`,
-                    // Use plain text content type, unless we decide to return JSON later
-                    contentType: "text/plain",
-                };
-                // Log based on the success flag in the result
-                if (showResult.success) {
-                    logger.info(`Tool ${TOOL_NAME} executed successfully`, logicContext);
-                }
-                else {
-                    // Log specific failure message from the result
-                    logger.warning(`Tool ${TOOL_NAME} failed: ${showResult.message}`, { ...logicContext, errorDetails: showResult.error });
-                }
-                // Return the result, whether success or structured failure
-                return { content: [resultContent] };
-            }, {
-                operation: toolOperation,
-                context: logicContext,
-                input: validatedArgs, // Log the raw validated args
-                errorCode: BaseErrorCode.INTERNAL_ERROR, // Default if unexpected error occurs in logic/wrapper
+        }
+        catch (error) {
+            logger.error(`Error in ${TOOL_NAME} handler`, { error, ...handlerContext });
+            const handledError = ErrorHandler.handleError(error, {
+                operation: `tool:${TOOL_NAME}`,
+                context: handlerContext,
+                input: params,
             });
-        });
-        logger.info(`Tool registered: ${TOOL_NAME}`, context);
-    }, { operation, context, critical: true }); // Mark registration as critical
+            const mcpError = handledError instanceof McpError
+                ? handledError
+                : new McpError(BaseErrorCode.INTERNAL_ERROR, "An unexpected error occurred.", { originalError: handledError });
+            return {
+                isError: true,
+                content: [{ type: "text", text: mcpError.message }],
+                structuredContent: mcpError.details,
+            };
+        }
+    });
+    logger.info(`Tool '${TOOL_NAME}' registered successfully.`, context);
 };

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

@@ -1,7 +1,5 @@
 /**
- * @fileoverview Barrel file for the git_stash tool.
- * Exports the registration function and state accessor initialization function.
+ * @fileoverview Barrel file for the gitStash tool.
+ * @module src/mcp-server/tools/gitStash/index
  */
-export { registerGitStashTool, initializeGitStashStateAccessors, } from "./registration.js";
-// Export types if needed elsewhere, e.g.:
-// export type { GitStashInput, GitStashResult } from './logic.js';
+export { registerGitStashTool } from "./registration.js";

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

@@ -1,244 +1,100 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_stash tool.
+ * @module src/mcp-server/tools/gitStash/logic
+ */
 import { execFile } 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 { logger, sanitization } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
 const execFileAsync = promisify(execFile);
-// Define the BASE input schema for the git_stash tool using Zod
+// 1. DEFINE the Zod input schema.
 export const GitStashBaseSchema = 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(["list", "apply", "pop", "drop", "save"])
-        .describe("The stash operation to perform: 'list', 'apply', 'pop', 'drop', 'save'."),
-    stashRef: z
-        .string()
-        .optional()
-        .describe("Stash reference (e.g., 'stash@{1}'). Required for 'apply', 'pop', 'drop' modes."),
-    message: z
-        .string()
-        .optional()
-        .describe("Optional descriptive message used only for 'save' mode."),
-    // includeUntracked: z.boolean().default(false).describe("Include untracked files in 'save' mode (-u)"), // Consider adding later
-    // keepIndex: z.boolean().default(false).describe("Keep staged changes in 'save' mode (--keep-index)"), // Consider adding later
+    path: z.string().default(".").describe("Path to the local Git repository."),
+    mode: z.enum(["list", "apply", "pop", "drop", "save"]).describe("The stash operation to perform."),
+    stashRef: z.string().optional().describe("Stash reference (e.g., 'stash@{1}')."),
+    message: z.string().optional().describe("Optional descriptive message for 'save' mode."),
 });
-// Apply refinements and export the FINAL schema for validation within the handler
 export const GitStashInputSchema = GitStashBaseSchema.refine((data) => !(["apply", "pop", "drop"].includes(data.mode) && !data.stashRef), {
-    message: "A 'stashRef' (e.g., 'stash@{0}') is required for 'apply', 'pop', and 'drop' modes.",
-    path: ["stashRef"], // Point error to the stashRef field
+    message: "A 'stashRef' is required for 'apply', 'pop', and 'drop' modes.",
+    path: ["stashRef"],
+});
+// 2. DEFINE the Zod response schema.
+const StashInfoSchema = z.object({
+    ref: z.string(),
+    branch: z.string(),
+    description: z.string(),
+});
+export const GitStashOutputSchema = z.object({
+    success: z.boolean().describe("Indicates if the command was successful."),
+    mode: z.string().describe("The mode of operation that was performed."),
+    message: z.string().optional().describe("A summary message of the result."),
+    stashes: z.array(StashInfoSchema).optional().describe("A list of stashes for the 'list' mode."),
+    conflicts: z.boolean().optional().describe("Indicates if a merge conflict occurred."),
+    stashCreated: z.boolean().optional().describe("Indicates if a stash was created."),
 });
 /**
- * Executes git stash commands based on the specified mode.
- *
- * @param {GitStashInput} input - The validated input object (validated against GitStashInputSchema).
- * @param {RequestContext} context - The request context for logging and error handling.
- * @returns {Promise<GitStashResult>} A promise that resolves with the structured result.
- * @throws {McpError} Throws an McpError for path resolution/validation failures or unexpected errors.
+ * 4. IMPLEMENT the core logic function.
+ * @throws {McpError} If the logic encounters an unrecoverable issue.
  */
-export async function gitStashLogic(input, context) {
-    const operation = `gitStashLogic:${input.mode}`;
-    logger.debug(`Executing ${operation}`, { ...context, input });
-    let targetPath;
-    try {
-        // Resolve and sanitize the target path
-        const workingDir = context.getWorkingDirectory();
-        targetPath =
-            input.path && input.path !== "." ? input.path : (workingDir ?? ".");
-        if (targetPath === "." && !workingDir) {
-            logger.warning("Executing git stash in server's CWD as no path provided and no session WD set.", { ...context, operation });
-            targetPath = process.cwd();
-        }
-        else if (targetPath === "." && workingDir) {
-            targetPath = workingDir;
-            logger.debug(`Using session working directory: ${targetPath}`, {
-                ...context,
-                operation,
-                sessionId: context.sessionId,
-            });
-        }
-        else {
-            logger.debug(`Using provided path: ${targetPath}`, {
-                ...context,
-                operation,
-            });
-        }
-        targetPath = sanitization.sanitizePath(targetPath, {
-            allowAbsolute: true,
-        }).sanitizedPath;
-        logger.debug("Sanitized path", {
-            ...context,
-            operation,
-            sanitizedPath: targetPath,
-        });
+export async function gitStashLogic(params, context) {
+    const operation = `gitStashLogic:${params.mode}`;
+    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("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 stashRef format if provided (simple validation)
-    if (input.stashRef && !/^stash@\{[0-9]+\}$/.test(input.stashRef)) {
-        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid stash reference format: ${input.stashRef}. Expected format: stash@{n}`, { context, operation });
-    }
-    try {
-        let args;
-        let result;
-        switch (input.mode) {
+    const targetPath = sanitization.sanitizePath(params.path === "." ? workingDir : params.path, { allowAbsolute: true }).sanitizedPath;
+    const buildArgs = () => {
+        const baseArgs = ["-C", targetPath, "stash", params.mode];
+        switch (params.mode) {
             case "list":
-                args = ["-C", targetPath, "stash", "list"];
-                logger.debug(`Executing command: git ${args.join(" ")}`, {
-                    ...context,
-                    operation,
-                });
-                const { stdout: listStdout } = await execFileAsync("git", args);
-                const stashes = listStdout
-                    .trim()
-                    .split("\n")
-                    .filter((line) => line)
-                    .map((line) => {
-                    // Improved regex to handle different stash list formats
-                    const match = line.match(/^(stash@\{(\d+)\}):\s*(?:(?:WIP on|On)\s*([^:]+):\s*)?(.*)$/);
-                    return match
-                        ? {
-                            ref: match[1],
-                            branch: match[3] || "unknown",
-                            description: match[4],
-                        }
-                        : { ref: "unknown", branch: "unknown", description: line }; // Fallback parsing
-                });
-                result = { success: true, mode: "list", stashes };
+                // No extra args needed
                 break;
             case "apply":
             case "pop":
-                // stashRef is validated by Zod refine
-                const stashRefApplyPop = input.stashRef;
-                args = ["-C", targetPath, "stash", input.mode, stashRefApplyPop];
-                logger.debug(`Executing command: git ${args.join(" ")}`, {
-                    ...context,
-                    operation,
-                });
-                try {
-                    const { stdout, stderr } = await execFileAsync("git", args);
-                    // Check stdout/stderr for conflict messages, although exit code 0 usually means success
-                    const conflicts = /conflict/i.test(stdout) || /conflict/i.test(stderr);
-                    const message = conflicts
-                        ? `Stash ${input.mode} resulted in conflicts that need manual resolution.`
-                        : `Stash ${stashRefApplyPop} ${input.mode === "apply" ? "applied" : "popped"} successfully.`;
-                    logger.info(message, {
-                        ...context,
-                        operation,
-                        path: targetPath,
-                        conflicts,
-                    });
-                    result = { success: true, mode: input.mode, message, conflicts };
-                }
-                catch (applyError) {
-                    const applyErrorMessage = applyError.stderr || applyError.message || "";
-                    if (/conflict/i.test(applyErrorMessage)) {
-                        logger.warning(`Stash ${input.mode} failed due to conflicts.`, {
-                            ...context,
-                            operation,
-                            path: targetPath,
-                            error: applyErrorMessage,
-                        });
-                        // Return failure but indicate conflicts
-                        return {
-                            success: false,
-                            mode: input.mode,
-                            message: `Failed to ${input.mode} stash ${stashRefApplyPop} due to conflicts. Resolve conflicts manually.`,
-                            error: applyErrorMessage,
-                            conflicts: true,
-                        };
-                    }
-                    // Rethrow other errors
-                    throw applyError;
-                }
-                break;
             case "drop":
-                // stashRef is validated by Zod refine
-                const stashRefDrop = input.stashRef;
-                args = ["-C", targetPath, "stash", "drop", stashRefDrop];
-                logger.debug(`Executing command: git ${args.join(" ")}`, {
-                    ...context,
-                    operation,
-                });
-                await execFileAsync("git", args);
-                result = {
-                    success: true,
-                    mode: "drop",
-                    message: `Dropped ${stashRefDrop} successfully.`,
-                    stashRef: stashRefDrop,
-                };
+                baseArgs.push(params.stashRef);
                 break;
             case "save":
-                args = ["-C", targetPath, "stash", "save"];
-                if (input.message) {
-                    args.push(input.message);
+                if (params.message) {
+                    baseArgs.push(params.message);
                 }
-                logger.debug(`Executing command: git ${args.join(" ")}`, {
-                    ...context,
-                    operation,
-                });
-                const { stdout: saveStdout } = await execFileAsync("git", args);
-                const stashCreated = !/no local changes to save/i.test(saveStdout);
-                const saveMessage = stashCreated
-                    ? `Changes stashed successfully.` +
-                        (input.message ? ` Message: "${input.message}"` : "")
-                    : "No local changes to save.";
-                result = {
-                    success: true,
-                    mode: "save",
-                    message: saveMessage,
-                    stashCreated,
-                };
                 break;
-            default:
-                // Should not happen due to Zod validation
-                throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid mode: ${input.mode}`, { context, operation });
         }
-        logger.info(`git stash ${input.mode} executed successfully`, {
-            ...context,
-            operation,
-            path: targetPath,
-            result,
-        });
-        return result;
+        return baseArgs;
+    };
+    const args = buildArgs();
+    try {
+        logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+        const { stdout, stderr } = await execFileAsync("git", args);
+        if (params.mode === 'list') {
+            const stashes = stdout.trim().split("\n").filter(Boolean).map(line => {
+                const match = line.match(/^(stash@\{(\d+)\}):\s*(?:(?:WIP on|On)\s*([^:]+):\s*)?(.*)$/);
+                return match ? { ref: match[1], branch: match[3] || "unknown", description: match[4] } : { ref: "unknown", branch: "unknown", description: line };
+            });
+            return { success: true, mode: params.mode, stashes };
+        }
+        const output = stdout + stderr;
+        const conflicts = /conflict/i.test(output);
+        if (params.mode === 'save') {
+            const stashCreated = !/no local changes to save/i.test(output);
+            return { success: true, mode: params.mode, message: stashCreated ? "Changes stashed." : "No local changes to save.", stashCreated };
+        }
+        return { success: true, mode: params.mode, message: `${params.mode} operation successful.`, conflicts };
     }
     catch (error) {
         const errorMessage = error.stderr || error.message || "";
-        logger.error(`Failed to execute git stash command`, {
-            ...context,
-            operation,
-            path: targetPath,
-            error: errorMessage,
-            stderr: error.stderr,
-            stdout: error.stdout,
-        });
-        // Specific error handling
+        logger.error(`Failed to execute git stash command`, { ...context, operation, errorMessage });
         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 });
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`);
         }
-        if ((input.mode === "apply" ||
-            input.mode === "pop" ||
-            input.mode === "drop") &&
-            /no such stash/i.test(errorMessage)) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Failed to ${input.mode} stash: Stash '${input.stashRef}' not found. Error: ${errorMessage}`, { context, operation, originalError: error });
+        if (/no such stash/i.test(errorMessage)) {
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Stash '${params.stashRef}' not found.`);
         }
-        if ((input.mode === "apply" || input.mode === "pop") &&
-            /conflict/i.test(errorMessage)) {
-            // This case might be caught above, but double-check here
-            throw new McpError(BaseErrorCode.CONFLICT, `Failed to ${input.mode} stash '${input.stashRef}' due to conflicts. Resolve conflicts manually. Error: ${errorMessage}`, { context, operation, originalError: error });
+        if (/conflict/i.test(errorMessage)) {
+            throw new McpError(BaseErrorCode.CONFLICT, `Stash ${params.mode} failed due to conflicts.`);
         }
-        // Throw a generic McpError for other failures
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git stash ${input.mode} failed for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git stash ${params.mode} failed: ${errorMessage}`);
     }
 }