@cyanheads/git-mcp-server 2.1.8 → 2.2.1

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

@@ -1,104 +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 { requestContextService } from "../../../utils/index.js";
-// Import the schema and types
-import { BaseErrorCode } from "../../../types-global/errors.js"; // Keep direct import for types-global
-import { GitCleanInputSchema, gitCleanLogic, } from "./logic.js";
-let _getWorkingDirectory;
-let _getSessionId;
 /**
- * Initializes the state accessors needed by the git_clean 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_clean tool.
+ * @module src/mcp-server/tools/gitClean/registration
  */
-export function initializeGitCleanStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_clean tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { gitCleanLogic, GitCleanInputSchema, GitCleanOutputSchema, } from "./logic.js";
 const TOOL_NAME = "git_clean";
 const TOOL_DESCRIPTION = "Removes untracked files from the working directory. Supports dry runs, removing directories, and removing ignored files. CRITICAL: Requires explicit `force: true` parameter for safety as this is a destructive operation. Returns results as a JSON object.";
 /**
- * Registers the git_clean 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_clean 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 registerGitCleanTool = async (server) => {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_clean must be initialized before registration.");
-    }
+export const registerGitCleanTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitCleanTool";
     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, GitCleanInputSchema.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 Clean",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitCleanInputSchema.shape,
+        outputSchema: GitCleanOutputSchema.shape,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true, // Running clean again does nothing if already clean
+            openWorldHint: false,
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
+        });
+        try {
+            const sessionId = getSessionId(handlerContext);
+            const result = await gitCleanLogic(params, {
+                ...handlerContext,
+                getWorkingDirectory: () => getWorkingDirectory(sessionId),
             });
-            // --- SAFETY CHECK (Redundant but good practice) ---
-            // The core logic already checks this, but adding a check here ensures
-            // the intent is clear even before calling the logic.
-            if (!toolInput.force) {
-                logger.error(`Tool ${TOOL_NAME} called without force=true. Aborting.`, requestContext);
-                // Return a structured error via CallToolResult
-                const errorContent = {
-                    type: "text",
-                    text: JSON.stringify({
-                        success: false,
-                        message: "Operation aborted: 'force' parameter must be explicitly set to true to execute 'git clean'.",
-                        dryRun: toolInput.dryRun, // Include dryRun status
-                    }, null, 2),
-                    contentType: "application/json",
-                };
-                return { content: [errorContent], isError: true }; // Indicate it's an error result
-            }
-            const sessionId = _getSessionId(requestContext);
-            const getWorkingDirectoryForSession = () => {
-                return _getWorkingDirectory(sessionId);
-            };
-            const logicContext = {
-                ...requestContext,
-                sessionId: sessionId,
-                getWorkingDirectory: getWorkingDirectoryForSession,
+            return {
+                structuredContent: result,
+                content: [{ type: "text", text: `Success: ${JSON.stringify(result, null, 2)}` }],
             };
-            logger.info(`Executing tool: ${TOOL_NAME}`, logicContext);
-            return await ErrorHandler.tryCatch(async () => {
-                // Call the core logic function which returns a GitCleanResult object
-                const cleanResult = await gitCleanLogic(toolInput, logicContext);
-                // Format the result as JSON within TextContent
-                const resultContent = {
-                    type: "text",
-                    text: JSON.stringify(cleanResult, null, 2),
-                    contentType: "application/json",
-                };
-                // Log based on the success flag in the result
-                if (cleanResult.success) {
-                    logger.info(`Tool ${TOOL_NAME} executed successfully (DryRun: ${cleanResult.dryRun})`, logicContext);
-                }
-                else {
-                    // Log specific failure message from the result
-                    logger.warning(`Tool ${TOOL_NAME} failed: ${cleanResult.message}`, { ...logicContext, errorDetails: cleanResult.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 mcpError = 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
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error: ${mcpError.message}` }],
+                structuredContent: {
+                    code: mcpError.code,
+                    message: mcpError.message,
+                    details: mcpError.details,
+                },
+            };
+        }
+    });
+    logger.info(`Tool '${TOOL_NAME}' registered successfully.`, context);
 };

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

@@ -1,7 +1,5 @@
 /**
- * @fileoverview Barrel file for the git_clear_working_dir tool.
- * Exports the registration function and related components.
+ * @fileoverview Barrel file for the gitClearWorkingDir tool.
+ * @module src/mcp-server/tools/gitClearWorkingDir/index
  */
-export { registerGitClearWorkingDirTool, initializeGitClearWorkingDirStateAccessors, } from "./registration.js";
-// Export types if needed elsewhere, e.g.:
-// export type { GitClearWorkingDirInput, GitClearWorkingDirResult } from './logic.js';
+export { registerGitClearWorkingDirTool } from "./registration.js";

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

@@ -1,39 +1,25 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_clear_working_dir tool.
+ * @module src/mcp-server/tools/gitClearWorkingDir/logic
+ */
 import { z } from "zod";
-// Import utils from barrel (logger from ../utils/internal/logger.js)
-import { BaseErrorCode, McpError } from "../../../types-global/errors.js"; // Keep direct import for types-global
 import { logger } from "../../../utils/index.js";
-// Define the Zod schema for input validation (no arguments needed)
+// 1. DEFINE the Zod input schema.
 export const GitClearWorkingDirInputSchema = z.object({});
+// 2. DEFINE the Zod response schema.
+export const GitClearWorkingDirOutputSchema = z.object({
+    success: z.boolean().describe("Indicates if the command was successful."),
+    message: z.string().describe("A summary message of the result."),
+});
 /**
- * Logic for the git_clear_working_dir tool.
- * Clears the global working directory setting for the current session.
- *
- * @param {GitClearWorkingDirInput} input - The validated input arguments (empty object).
- * @param {RequestContext} context - The request context, containing session ID and the clear function.
- * @returns {Promise<GitClearWorkingDirResult>} The result of the operation.
- * @throws {McpError} Throws McpError for operational errors.
+ * 4. IMPLEMENT the core logic function.
+ * @throws {McpError} If the logic encounters an unrecoverable issue.
  */
-export async function gitClearWorkingDirLogic(input, context) {
+export async function gitClearWorkingDirLogic(params, context) {
     const operation = "gitClearWorkingDirLogic";
-    logger.debug(`Executing ${operation}`, { ...context, input });
-    // --- Update Session State ---
-    // This part needs access to the session state mechanism defined in server.ts
-    // We assume the context provides a way to clear the working directory for the current session.
-    try {
-        context.clearWorkingDirectory();
-        const message = `Working directory cleared for session ${context.sessionId || "stdio"}`;
-        logger.info(message, { ...context, operation });
-    }
-    catch (error) {
-        logger.error("Failed to clear working directory in session state", error, {
-            ...context,
-            operation,
-        });
-        // This indicates an internal logic error in how state is passed/managed.
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, "Failed to update session state.", { context, operation });
-    }
-    return {
-        success: true,
-        message: "Global working directory setting cleared.",
-    };
+    logger.debug(`Executing ${operation}`, { ...context, params });
+    context.clearWorkingDirectory();
+    const message = "Session working directory cleared successfully.";
+    logger.info(message, { ...context, operation });
+    return { success: true, message };
 }

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

@@ -1,82 +1,64 @@
-// Import utils from barrel (ErrorHandler from ../utils/internal/errorHandler.js)
-import { ErrorHandler } from "../../../utils/index.js";
-// Import utils from barrel (logger from ../utils/internal/logger.js)
-import { logger } from "../../../utils/index.js";
-// Import utils from barrel (requestContextService, RequestContext from ../utils/internal/requestContext.js)
-import { BaseErrorCode } from "../../../types-global/errors.js"; // Keep direct import for types-global
-import { requestContextService } from "../../../utils/index.js";
-import { GitClearWorkingDirInputSchema, gitClearWorkingDirLogic, } from "./logic.js";
-let _clearWorkingDirectory;
-let _getSessionId;
 /**
- * Initializes the state accessors needed by the tool registration.
- * This should be called once during server setup.
- * @param clearFn - Function to clear the working directory for a session.
- * @param getFn - Function to get the session ID from context.
+ * @fileoverview Handles registration and error handling for the git_clear_working_dir tool.
+ * @module src/mcp-server/tools/gitClearWorkingDir/registration
  */
-export function initializeGitClearWorkingDirStateAccessors(clearFn, getFn) {
-    _clearWorkingDirectory = clearFn;
-    _getSessionId = getFn; // Can reuse the getter from the set tool
-    logger.info("State accessors initialized for git_clear_working_dir tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { gitClearWorkingDirLogic, GitClearWorkingDirInputSchema, GitClearWorkingDirOutputSchema, } from "./logic.js";
 const TOOL_NAME = "git_clear_working_dir";
 const TOOL_DESCRIPTION = "Clears the session-specific working directory previously set by `git_set_working_dir`. Subsequent Git tool calls in this session will require an explicit `path` parameter or will default to the server's current working directory. Returns the result as a JSON object.";
 /**
- * Registers the git_clear_working_dir tool with the MCP server.
- *
- * @param {McpServer} server - The MCP server instance.
- * @throws {Error} If state accessors are not initialized.
+ * Registers the git_clear_working_dir tool with the MCP server instance.
+ * @param server The MCP server instance.
+ * @param clearWorkingDirectory Function to clear the session's working directory.
+ * @param getSessionId Function to get the session ID from context.
  */
-export async function registerGitClearWorkingDirTool(server) {
-    if (!_clearWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_clear_working_dir must be initialized before registration.");
-    }
-    try {
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitClearWorkingDirInputSchema.shape, // Empty shape
-        async (validatedArgs, callContext) => {
-            const operation = "tool:git_clear_working_dir";
-            const requestContext = requestContextService.createRequestContext({
-                operation,
-                parentContext: callContext,
+export const registerGitClearWorkingDirTool = async (server, clearWorkingDirectory, getSessionId) => {
+    const operation = "registerGitClearWorkingDirTool";
+    const context = requestContextService.createRequestContext({ operation });
+    server.registerTool(TOOL_NAME, {
+        title: "Git Clear Working Directory",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitClearWorkingDirInputSchema.shape,
+        outputSchema: GitClearWorkingDirOutputSchema.shape,
+        annotations: {
+            readOnlyHint: true, // Modifies session state, but not external files
+            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 gitClearWorkingDirLogic(params, {
+                ...handlerContext,
+                clearWorkingDirectory: () => clearWorkingDirectory(sessionId),
             });
-            const sessionId = _getSessionId(requestContext);
-            // Define the session-specific clear function
-            const clearWorkingDirectoryForSession = () => {
-                _clearWorkingDirectory(sessionId);
-            };
-            const logicContext = {
-                ...requestContext,
-                sessionId: sessionId,
-                clearWorkingDirectory: clearWorkingDirectoryForSession,
+            return {
+                structuredContent: result,
+                content: [{ type: "text", text: `Success: ${JSON.stringify(result, null, 2)}` }],
             };
-            return await ErrorHandler.tryCatch(async () => {
-                // Call the core logic function
-                const result = await gitClearWorkingDirLogic(validatedArgs, logicContext);
-                // Format the successful result
-                const responseContent = {
-                    type: "text",
-                    text: JSON.stringify(result, null, 2),
-                    contentType: "application/json",
-                };
-                logger.info(`Tool ${TOOL_NAME} executed successfully`, {
-                    ...logicContext,
-                    result,
-                });
-                return { content: [responseContent] };
-            }, {
-                operation,
-                context: logicContext,
-                input: validatedArgs,
-                errorCode: BaseErrorCode.INTERNAL_ERROR,
+        }
+        catch (error) {
+            logger.error(`Error in ${TOOL_NAME} handler`, { error, ...handlerContext });
+            const mcpError = ErrorHandler.handleError(error, {
+                operation: `tool:${TOOL_NAME}`,
+                context: handlerContext,
+                input: params,
             });
-        });
-        logger.info(`Tool registered: ${TOOL_NAME}`);
-    }
-    catch (error) {
-        logger.error(`Failed to register tool: ${TOOL_NAME}`, {
-            error: error instanceof Error ? error.message : String(error),
-            stack: error instanceof Error ? error.stack : undefined,
-        });
-        throw error;
-    }
-}
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error: ${mcpError.message}` }],
+                structuredContent: {
+                    code: mcpError.code,
+                    message: mcpError.message,
+                    details: mcpError.details,
+                },
+            };
+        }
+    });
+    logger.info(`Tool '${TOOL_NAME}' registered successfully.`, context);
+};

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

@@ -1,7 +1,5 @@
 /**
- * @fileoverview Barrel file for the git_clone tool.
- * Exports the registration function.
+ * @fileoverview Barrel file for the gitClone tool.
+ * @module src/mcp-server/tools/gitClone/index
  */
 export { registerGitCloneTool } from "./registration.js";
-// Export types if needed elsewhere, e.g.:
-// export type { GitCloneInput, GitCloneResult } from './logic.js';

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

@@ -1,202 +1,62 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_clone tool.
+ * @module src/mcp-server/tools/gitClone/logic
+ */
 import { execFile } from "child_process";
 import fs from "fs/promises";
 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_clone tool using Zod
+// 1. DEFINE the Zod input schema.
 export const GitCloneInputSchema = z.object({
-    repositoryUrl: z
-        .string()
-        .url("Invalid repository URL format.")
-        .describe("The URL of the repository to clone (e.g., https://github.com/cyanheads/git-mcp-server, git@github.com:cyanheads/git-mcp-server.git)."),
-    targetPath: z
-        .string()
-        .min(1)
-        .describe("The absolute path to the directory where the repository should be cloned."),
-    branch: z
-        .string()
-        .optional()
-        .describe("Specify a specific branch to checkout after cloning."),
-    depth: z
-        .number()
-        .int()
-        .positive()
-        .optional()
-        .describe("Create a shallow clone with a history truncated to the specified number of commits."),
-    // recursive: z.boolean().default(false).describe("After the clone is created, initialize all submodules within, using their default settings."), // Consider adding later
-    quiet: z
-        .boolean()
-        .default(false)
-        .describe("Operate quietly. Progress is not reported to the standard error stream."),
+    repositoryUrl: z.string().url("Invalid repository URL format.").describe("The URL of the repository to clone."),
+    targetPath: z.string().min(1).describe("The absolute path where the repository should be cloned."),
+    branch: z.string().optional().describe("The specific branch to checkout after cloning."),
+    depth: z.number().int().positive().optional().describe("Create a shallow clone with a truncated history."),
+    quiet: z.boolean().default(false).describe("Operate quietly, suppressing progress output."),
+});
+// 2. DEFINE the Zod response schema.
+export const GitCloneOutputSchema = z.object({
+    success: z.boolean().describe("Indicates if the command was successful."),
+    message: z.string().describe("A summary message of the result."),
+    path: z.string().describe("The path where the repository was cloned."),
 });
 /**
- * Executes the 'git clone' command to clone a repository.
- *
- * @param {GitCloneInput} input - The validated input object.
- * @param {RequestContext} context - The request context for logging and error handling.
- * @returns {Promise<GitCloneResult>} A promise that resolves with the structured clone result.
- * @throws {McpError} Throws an McpError if path/URL validation fails or the git command fails unexpectedly.
+ * 4. IMPLEMENT the core logic function.
+ * @throws {McpError} If the logic encounters an unrecoverable issue.
  */
-export async function gitCloneLogic(input, context) {
+export async function gitCloneLogic(params, context) {
     const operation = "gitCloneLogic";
-    logger.debug(`Executing ${operation}`, { ...context, input });
-    let sanitizedTargetPath;
-    let sanitizedRepoUrl;
-    try {
-        // Sanitize the target path (must be absolute)
-        sanitizedTargetPath = sanitization.sanitizePath(input.targetPath, {
-            allowAbsolute: true,
-        }).sanitizedPath;
-        logger.debug("Sanitized target path", {
-            ...context,
-            operation,
-            sanitizedTargetPath,
-        });
-        // Basic sanitization/validation for URL (Zod already checks format)
-        // Further sanitization might be needed depending on how it's used in the shell command
-        // For now, rely on Zod's URL validation and careful command construction.
-        sanitizedRepoUrl = input.repositoryUrl; // Assume Zod validation is sufficient for now
-        logger.debug("Validated repository URL", {
-            ...context,
-            operation,
-            sanitizedRepoUrl,
-        });
-        // Check if target directory already exists and is not empty
-        try {
-            const stats = await fs.stat(sanitizedTargetPath);
-            if (stats.isDirectory()) {
-                const files = await fs.readdir(sanitizedTargetPath);
-                if (files.length > 0) {
-                    throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Target directory already exists and is not empty: ${sanitizedTargetPath}`, { context, operation });
-                }
-            }
-            else {
-                throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Target path exists but is not a directory: ${sanitizedTargetPath}`, { context, operation });
-            }
-        }
-        catch (error) {
-            if (error instanceof McpError)
-                throw error; // Re-throw our specific validation errors
-            if (error.code !== "ENOENT") {
-                // If error is not "does not exist", it's unexpected
-                logger.error(`Error checking target directory ${sanitizedTargetPath}`, {
-                    ...context,
-                    operation,
-                    error: error.message,
-                });
-                throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to check target directory: ${error.message}`, { context, operation });
+    logger.debug(`Executing ${operation}`, { ...context, params });
+    const sanitizedTargetPath = sanitization.sanitizePath(params.targetPath, { allowAbsolute: true }).sanitizedPath;
+    const stats = await fs.stat(sanitizedTargetPath).catch(err => {
+        if (err.code === 'ENOENT')
+            return null;
+        throw err;
+    });
+    if (stats) {
+        if (stats.isDirectory()) {
+            const files = await fs.readdir(sanitizedTargetPath);
+            if (files.length > 0) {
+                throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Target directory already exists and is not empty: ${sanitizedTargetPath}`);
             }
-            // ENOENT is expected - directory doesn't exist, which is fine for clone
-            logger.debug(`Target directory ${sanitizedTargetPath} does not exist, proceeding with clone.`, { ...context, operation });
-        }
-    }
-    catch (error) {
-        logger.error("Path/URL validation or sanitization failed", {
-            ...context,
-            operation,
-            error,
-        });
-        if (error instanceof McpError)
-            throw error;
-        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid input: ${error instanceof Error ? error.message : String(error)}`, { context, operation, originalError: error });
-    }
-    try {
-        // Construct the git clone command
-        const args = ["clone"];
-        if (input.quiet) {
-            args.push("--quiet");
-        }
-        if (input.branch) {
-            args.push("--branch", input.branch);
-        }
-        if (input.depth) {
-            args.push("--depth", String(input.depth));
-        }
-        // Add repo URL and target path
-        args.push(sanitizedRepoUrl, sanitizedTargetPath);
-        logger.debug(`Executing command: git ${args.join(" ")}`, {
-            ...context,
-            operation,
-        });
-        // Increase timeout for clone operations as they can take time
-        const { stdout, stderr } = await execFileAsync("git", args, {
-            timeout: 300000,
-        }); // 5 minutes timeout
-        if (stderr && !input.quiet) {
-            // Stderr often contains progress info, log as info if quiet is false
-            logger.info(`Git clone command produced stderr (progress/info)`, {
-                ...context,
-                operation,
-                stderr,
-            });
-        }
-        if (stdout && !input.quiet) {
-            logger.info(`Git clone command produced stdout`, {
-                ...context,
-                operation,
-                stdout,
-            });
-        }
-        // Verify the target directory exists after clone
-        let repoDirExists = false;
-        try {
-            await fs.access(sanitizedTargetPath);
-            repoDirExists = true;
-        }
-        catch (e) {
-            logger.error(`Could not verify existence of target directory ${sanitizedTargetPath} after git clone`, { ...context, operation });
-            // This indicates a potential failure despite exec not throwing
-            throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Clone command finished but target directory ${sanitizedTargetPath} not found.`, { context, operation });
-        }
-        const successMessage = `Repository cloned successfully into ${sanitizedTargetPath}`;
-        logger.info(successMessage, {
-            ...context,
-            operation,
-            path: sanitizedTargetPath,
-        });
-        return {
-            success: true,
-            message: successMessage,
-            path: sanitizedTargetPath,
-            repoDirExists: repoDirExists,
-        };
-    }
-    catch (error) {
-        const errorMessage = error.stderr || error.message || "";
-        logger.error(`Failed to execute git clone command`, {
-            ...context,
-            operation,
-            path: sanitizedTargetPath,
-            error: errorMessage,
-            stderr: error.stderr,
-            stdout: error.stdout,
-        });
-        // Handle specific error cases
-        if (errorMessage.toLowerCase().includes("repository not found") ||
-            errorMessage
-                .toLowerCase()
-                .includes("could not read from remote repository")) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Repository not found or access denied: ${sanitizedRepoUrl}. Error: ${errorMessage}`, { context, operation, originalError: error });
-        }
-        if (errorMessage
-            .toLowerCase()
-            .includes("already exists and is not an empty directory")) {
-            // This should have been caught by our pre-check, but handle defensively
-            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Target directory already exists and is not empty: ${sanitizedTargetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
-        }
-        if (errorMessage.toLowerCase().includes("permission denied")) {
-            throw new McpError(BaseErrorCode.FORBIDDEN, `Permission denied during clone operation for path: ${sanitizedTargetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        if (errorMessage.toLowerCase().includes("timeout")) {
-            throw new McpError(BaseErrorCode.TIMEOUT, `Git clone operation timed out for repository: ${sanitizedRepoUrl}. Error: ${errorMessage}`, { context, operation, originalError: error });
+        else {
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Target path exists but is not a directory: ${sanitizedTargetPath}`);
         }
-        // Generic internal error for other failures
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to clone repository ${sanitizedRepoUrl} to ${sanitizedTargetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
     }
+    const args = ["clone"];
+    if (params.quiet)
+        args.push("--quiet");
+    if (params.branch)
+        args.push("--branch", params.branch);
+    if (params.depth)
+        args.push("--depth", String(params.depth));
+    args.push(params.repositoryUrl, sanitizedTargetPath);
+    logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+    await execFileAsync("git", args, { timeout: 300000 }); // 5 minutes timeout
+    const successMessage = `Repository cloned successfully into ${sanitizedTargetPath}`;
+    return { success: true, message: successMessage, path: sanitizedTargetPath };
 }