@cyanheads/git-mcp-server 2.1.7 → 2.2.0

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

@@ -1,184 +1,77 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_cherry-pick tool.
+ * @module src/mcp-server/tools/gitCherryPick/logic
+ */
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { z } from "zod";
-// Import utils from barrel (logger from ../utils/internal/logger.js)
-import { logger } from "../../../utils/index.js";
-// Import utils from barrel (RequestContext from ../utils/internal/requestContext.js)
-import { BaseErrorCode, McpError } from "../../../types-global/errors.js"; // Keep direct import for types-global
-// Import utils from barrel (sanitization from ../utils/security/sanitization.js)
-import { sanitization } from "../../../utils/index.js";
+import { logger, sanitization } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
 const execFileAsync = promisify(execFile);
-// Define the input schema for the git_cherry-pick tool using Zod
+// 1. DEFINE the Zod input schema.
 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."),
-    // Add options for conflict handling? (e.g., --continue, --abort, --skip) - Maybe separate tool or mode?
+    path: z.string().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."),
+    commitRef: z.string().min(1).describe("The commit reference(s) to cherry-pick."),
+    mainline: z.number().int().min(1).optional().describe("The parent number (1-based) for a merge commit."),
+    strategy: z.enum(["recursive", "resolve", "ours", "theirs", "octopus", "subtree"]).optional().describe("The merge strategy to use."),
+    noCommit: z.boolean().default(false).describe("Apply changes but do not create a commit."),
+    signoff: z.boolean().default(false).describe("Add a 'Signed-off-by' line to the commit message."),
+});
+// 2. DEFINE the Zod response schema.
+export const GitCherryPickOutputSchema = z.object({
+    success: z.boolean().describe("Indicates if the command was successful."),
+    message: z.string().describe("A summary message of the result."),
+    commitCreated: z.boolean().describe("Indicates if a new commit was created."),
+    conflicts: z.boolean().describe("Indicates if conflicts occurred."),
 });
 /**
- * Executes the 'git cherry-pick' command.
- *
- * @param {GitCherryPickInput} input - The validated input object.
- * @param {RequestContext} context - The request context for logging and error handling.
- * @returns {Promise<GitCherryPickResult>} 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 gitCherryPickLogic(input, context) {
+export async function gitCherryPickLogic(params, context) {
     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) {
-            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) {
-            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 });
+    logger.debug(`Executing ${operation}`, { ...context, params });
+    const workingDir = context.getWorkingDirectory();
+    if (params.path === "." && !workingDir) {
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, "No session working directory set. Please specify a 'path' or use 'git_set_working_dir' first.");
     }
+    const targetPath = sanitization.sanitizePath(params.path === "." ? workingDir : params.path, { allowAbsolute: true }).sanitizedPath;
+    const args = ["-C", targetPath, "cherry-pick"];
+    if (params.mainline)
+        args.push("-m", String(params.mainline));
+    if (params.strategy)
+        args.push(`-X${params.strategy}`);
+    if (params.noCommit)
+        args.push("--no-commit");
+    if (params.signoff)
+        args.push("--signoff");
+    args.push(params.commitRef);
     try {
-        const args = ["-C", targetPath, "cherry-pick"];
-        if (input.mainline) {
-            args.push("-m", String(input.mainline));
-        }
-        if (input.strategy) {
-            args.push(`-X${input.strategy}`);
-        } // Note: -X for strategy options
-        if (input.noCommit) {
-            args.push("--no-commit");
-        }
-        if (input.signoff) {
-            args.push("--signoff");
-        }
-        // Add the commit reference(s)
-        args.push(input.commitRef);
-        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 output = stdout + stderr;
-            const conflicts = /conflict/i.test(output);
-            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("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 ||
-                "";
-            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,
-                };
-            }
-            // Rethrow other errors to be caught by the outer try-catch
-            throw cherryPickError;
-        }
+        logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+        const { stdout, stderr } = await execFileAsync("git", args);
+        const output = stdout + stderr;
+        const conflicts = /conflict/i.test(output);
+        const commitCreated = !params.noCommit && !conflicts;
+        const message = conflicts
+            ? `Cherry-pick resulted in conflicts for commit(s) '${params.commitRef}'. Manual resolution required.`
+            : `Successfully cherry-picked commit(s) '${params.commitRef}'.`;
+        return { success: true, message, commitCreated, conflicts };
     }
     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,
-        });
-        // Specific error handling
+        logger.error(`Failed to execute git cherry-pick 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 (/bad revision/i.test(errorMessage)) {
-            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Failed to cherry-pick: Invalid commit reference '${input.commitRef}'. Error: ${errorMessage}`, { context, operation, originalError: error });
+        if (/conflict/i.test(errorMessage)) {
+            throw new McpError(BaseErrorCode.CONFLICT, `Failed to cherry-pick due to conflicts. Resolve conflicts and use 'git cherry-pick --continue' or '--abort'.`);
         }
-        if (/after resolving the conflicts/i.test(errorMessage)) {
-            // This might indicate a previous conflict state
-            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 (/bad revision/i.test(errorMessage)) {
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid commit reference '${params.commitRef}'.`);
         }
         if (/your local changes would be overwritten/i.test(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 });
+            throw new McpError(BaseErrorCode.CONFLICT, "Your local changes would be overwritten. Please commit or stash them first.");
         }
-        // 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 });
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git cherry-pick failed: ${errorMessage}`);
     }
 }

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

@@ -1,79 +1,64 @@
-// Import utils from barrel (logger from ../utils/internal/logger.js)
-import { logger } from "../../../utils/index.js";
-// Import utils from barrel (ErrorHandler from ../utils/internal/errorHandler.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 { GitCherryPickInputSchema, gitCherryPickLogic, } from "./logic.js";
-let _getWorkingDirectory;
-let _getSessionId;
 /**
- * Initializes the state accessors needed by the git_cherry_pick 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_cherry-pick tool.
+ * @module src/mcp-server/tools/gitCherryPick/registration
  */
-export function initializeGitCherryPickStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_cherry_pick tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
+import { gitCherryPickLogic, GitCherryPickInputSchema, GitCherryPickOutputSchema, } from "./logic.js";
 const TOOL_NAME = "git_cherry_pick";
 const TOOL_DESCRIPTION = "Applies the changes introduced by existing commits. Supports picking single commits or ranges, handling merge commits, and options like --no-commit and --signoff. Returns results as a JSON object, indicating success, failure, or conflicts.";
 /**
- * Registers the git_cherry_pick 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_cherry_pick 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 registerGitCherryPickTool = async (server) => {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_cherry_pick must be initialized before registration.");
-    }
+export const registerGitCherryPickTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitCherryPickTool";
     const context = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(async () => {
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitCherryPickInputSchema.shape, async (validatedArgs, callContext) => {
-            const toolInput = validatedArgs;
-            const toolOperation = `tool:${TOOL_NAME}`;
-            const requestContext = requestContextService.createRequestContext({
-                operation: toolOperation,
-                parentContext: callContext,
+    server.registerTool(TOOL_NAME, {
+        title: "Git Cherry-Pick",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitCherryPickInputSchema.shape,
+        outputSchema: GitCherryPickOutputSchema.shape,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false, // Not typically destructive, but can cause conflicts
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
+        });
+        try {
+            const sessionId = getSessionId(handlerContext);
+            const result = await gitCherryPickLogic(params, {
+                ...handlerContext,
+                getWorkingDirectory: () => getWorkingDirectory(sessionId),
             });
-            const sessionId = _getSessionId(requestContext);
-            const getWorkingDirectoryForSession = () => _getWorkingDirectory(sessionId);
-            const logicContext = {
-                ...requestContext,
-                sessionId: sessionId,
-                getWorkingDirectory: getWorkingDirectoryForSession,
+            return {
+                structuredContent: result,
+                content: [{ type: "text", text: `Success: ${JSON.stringify(result, null, 2)}` }],
             };
-            logger.info(`Executing tool: ${TOOL_NAME}`, logicContext);
-            return await ErrorHandler.tryCatch(async () => {
-                const cherryPickResult = await gitCherryPickLogic(toolInput, logicContext);
-                const resultContent = {
-                    type: "text",
-                    text: JSON.stringify(cherryPickResult, null, 2), // Pretty-print JSON
-                    contentType: "application/json",
-                };
-                if (cherryPickResult.success) {
-                    logger.info(`Tool ${TOOL_NAME} executed successfully (Conflicts: ${!!cherryPickResult.conflicts}), returning JSON`, logicContext);
-                }
-                else {
-                    logger.warning(`Tool ${TOOL_NAME} failed: ${cherryPickResult.message}`, {
-                        ...logicContext,
-                        errorDetails: cherryPickResult.error,
-                        conflicts: cherryPickResult.conflicts,
-                    });
-                }
-                return { content: [resultContent] };
-            }, {
-                operation: toolOperation,
-                context: logicContext,
-                input: validatedArgs,
-                errorCode: BaseErrorCode.INTERNAL_ERROR,
+        }
+        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 });
+            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/gitClean/index.js

@@ -1,7 +1,5 @@
 /**
- * @fileoverview Barrel file for the git_clean tool.
- * Exports the registration function and state accessor initialization function.
+ * @fileoverview Barrel file for the gitClean tool.
+ * @module src/mcp-server/tools/gitClean/index
  */
-export { registerGitCleanTool, initializeGitCleanStateAccessors, } from "./registration.js";
-// Export types if needed elsewhere, e.g.:
-// export type { GitCleanInput, GitCleanResult } from './logic.js';
+export { registerGitCleanTool } from "./registration.js";

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

@@ -1,168 +1,69 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_clean tool.
+ * @module src/mcp-server/tools/gitClean/logic
+ */
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { z } from "zod";
-// Import utils from barrel (logger from ../utils/internal/logger.js)
-import { logger } from "../../../utils/index.js";
-// Import utils from barrel (RequestContext from ../utils/internal/requestContext.js)
-import { BaseErrorCode, McpError } from "../../../types-global/errors.js"; // Keep direct import for types-global
-// Import utils from barrel (sanitization from ../utils/security/sanitization.js)
-import { sanitization } from "../../../utils/index.js";
+import { logger, sanitization } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
 const execFileAsync = promisify(execFile);
-// Define the input schema for the git_clean tool using Zod
-// No refinements needed here, but the 'force' check is critical in the logic
+// 1. DEFINE the Zod input schema.
 export const GitCleanInputSchema = 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."),
-    force: z
-        .boolean()
-        .describe("REQUIRED confirmation to run the command. Must be explicitly set to true to perform the clean operation. If false or omitted, the command will not run."),
-    dryRun: z
-        .boolean()
-        .default(false)
-        .describe("Show what would be deleted without actually deleting (-n flag)."),
-    directories: z
-        .boolean()
-        .default(false)
-        .describe("Remove untracked directories in addition to files (-d flag)."),
-    ignored: z
-        .boolean()
-        .default(false)
-        .describe("Remove ignored files as well (-x flag). Use with extreme caution."),
-    // exclude: z.string().optional().describe("Exclude files matching pattern (-e <pattern>)"), // Consider adding later
+    path: z.string().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."),
+    force: z.boolean().describe("REQUIRED confirmation. Must be true to run the destructive clean operation."),
+    dryRun: z.boolean().default(false).describe("Show what would be deleted without actually deleting."),
+    directories: z.boolean().default(false).describe("Remove untracked directories in addition to files."),
+    ignored: z.boolean().default(false).describe("Remove ignored files as well. Use with extreme caution."),
+});
+// 2. DEFINE the Zod response schema.
+export const GitCleanOutputSchema = z.object({
+    success: z.boolean().describe("Indicates if the command was successful."),
+    message: z.string().describe("A summary message of the result."),
+    filesAffected: z.array(z.string()).describe("A list of files that were or would be affected."),
+    dryRun: z.boolean().describe("Indicates if the operation was a dry run."),
 });
 /**
- * Executes the 'git clean' command to remove untracked files.
- * CRITICAL: Requires the 'force' parameter to be explicitly true.
- *
- * @param {GitCleanInput} input - The validated input object.
- * @param {RequestContext} context - The request context for logging and error handling.
- * @returns {Promise<GitCleanResult>} A promise that resolves with the structured result.
- * @throws {McpError} Throws an McpError for path/validation failures, if force=false, or unexpected errors.
+ * 4. IMPLEMENT the core logic function.
+ * @throws {McpError} If the logic encounters an unrecoverable issue.
  */
-export async function gitCleanLogic(input, context) {
+export async function gitCleanLogic(params, context) {
     const operation = "gitCleanLogic";
-    logger.debug(`Executing ${operation}`, { ...context, input });
-    // --- CRITICAL SAFETY CHECK ---
-    if (!input.force) {
-        logger.error("Attempted to run git clean without force=true.", {
-            ...context,
-            operation,
-        });
-        throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Operation aborted: 'force' parameter must be explicitly set to true to execute 'git clean'. This is a destructive command.", { context, operation });
+    logger.debug(`Executing ${operation}`, { ...context, params });
+    if (!params.force) {
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Operation aborted: 'force' must be true to execute 'git clean'.");
     }
-    // Log that the force check passed
     logger.warning("Executing 'git clean' with force=true. This is a destructive operation.", { ...context, operation });
-    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 clean 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 });
+    const workingDir = context.getWorkingDirectory();
+    if (params.path === "." && !workingDir) {
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, "No session working directory set. Please specify a 'path' or use 'git_set_working_dir' first.");
     }
+    const targetPath = sanitization.sanitizePath(params.path === "." ? workingDir : params.path, { allowAbsolute: true }).sanitizedPath;
+    const args = ["-C", targetPath, "clean", "-f"];
+    if (params.dryRun)
+        args.push("-n");
+    if (params.directories)
+        args.push("-d");
+    if (params.ignored)
+        args.push("-x");
     try {
-        // Construct the command
-        // Force (-f) is always added because the logic checks input.force
-        const args = ["-C", targetPath, "clean", "-f"];
-        if (input.dryRun) {
-            args.push("-n");
-        }
-        if (input.directories) {
-            args.push("-d");
-        }
-        if (input.ignored) {
-            args.push("-x");
-        }
-        logger.debug(`Executing command: git ${args.join(" ")}`, {
-            ...context,
-            operation,
-        });
+        logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
         const { stdout, stderr } = await execFileAsync("git", args);
         if (stderr) {
-            // Log stderr as warning, as git clean might report non-fatal issues here
-            logger.warning(`Git clean command produced stderr`, {
-                ...context,
-                operation,
-                stderr,
-            });
+            logger.warning(`Git clean command produced stderr`, { ...context, operation, stderr });
         }
-        // Parse stdout to list affected files
-        const filesAffected = stdout
-            .trim()
-            .split("\n")
-            .map((line) => line
-            .replace(/^Would remove /i, "")
-            .replace(/^Removing /i, "")
-            .trim()) // Clean up prefixes
-            .filter((file) => file); // Remove empty lines
-        const message = input.dryRun
+        const filesAffected = stdout.trim().split("\n").map(line => line.replace(/^Would remove |^Removing /i, "").trim()).filter(Boolean);
+        const message = params.dryRun
             ? `Dry run complete. Files that would be removed: ${filesAffected.length}`
             : `Clean operation complete. Files removed: ${filesAffected.length}`;
-        logger.info(message, {
-            ...context,
-            operation,
-            path: targetPath,
-            dryRun: input.dryRun,
-            filesAffectedCount: filesAffected.length,
-        });
-        return { success: true, message, filesAffected, dryRun: input.dryRun };
+        return { success: true, message, filesAffected, dryRun: params.dryRun };
     }
     catch (error) {
         const errorMessage = error.stderr || error.message || "";
-        logger.error(`Failed to execute git clean command`, {
-            ...context,
-            operation,
-            path: targetPath,
-            error: errorMessage,
-            stderr: error.stderr,
-            stdout: error.stdout,
-        });
-        // Specific error handling
+        logger.error(`Failed to execute git clean 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}`);
         }
-        // Git clean usually doesn't fail with specific messages like others,
-        // but returns non-zero exit code on general failure.
-        // Throw a generic McpError for other failures
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git clean failed for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git clean failed: ${errorMessage}`);
     }
 }