@cyanheads/git-mcp-server 2.1.8 → 2.2.0

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

@@ -1,213 +1,105 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_remote tool.
+ * @module src/mcp-server/tools/gitRemote/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_remote tool using Zod
-export const GitRemoteInputSchema = z.object({
-    path: z
-        .string()
-        .min(1)
-        .optional()
-        .default(".")
-        .describe("Path to the Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
-    mode: z
-        .enum(["list", "add", "remove", "show"])
-        .describe("Operation mode: 'list', 'add', 'remove', 'show'"),
-    name: z
-        .string()
-        .min(1)
-        .optional()
-        .describe("Remote name (required for 'add', 'remove', 'show')"),
-    url: z.string().optional().describe("Remote URL (required for 'add')"), // Removed .url() validation
+// 1. DEFINE the Zod input schema.
+export const GitRemoteBaseSchema = z.object({
+    path: z.string().default(".").describe("Path to the Git repository."),
+    mode: z.enum(["list", "add", "remove", "show"]).describe("Operation mode."),
+    name: z.string().optional().describe("Remote name (required for 'add', 'remove', 'show')."),
+    url: z.string().optional().describe("Remote URL (required for 'add')."),
+});
+export const GitRemoteInputSchema = GitRemoteBaseSchema.refine(data => !(data.mode === 'add' && (!data.name || !data.url)), {
+    message: "Remote 'name' and 'url' are required for 'add' mode.",
+    path: ["name", "url"],
+}).refine(data => !((data.mode === 'remove' || data.mode === 'show') && !data.name), {
+    message: "Remote 'name' is required for 'remove' or 'show' mode.",
+    path: ["name"],
+});
+// 2. DEFINE the Zod response schema.
+const RemoteInfoSchema = z.object({
+    name: z.string(),
+    fetchUrl: z.string(),
+    pushUrl: z.string(),
+});
+export const GitRemoteOutputSchema = 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."),
+    remotes: z.array(RemoteInfoSchema).optional().describe("A list of remotes for the 'list' mode."),
+    details: z.string().optional().describe("Details for the 'show' mode."),
 });
 /**
- * Executes git remote commands based on the specified mode.
- *
- * @param {GitRemoteInput} input - The validated input object.
- * @param {RequestContext} context - The request context for logging and error handling.
- * @returns {Promise<GitRemoteResult>} 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 gitRemoteLogic(input, context) {
-    const operation = `gitRemoteLogic:${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 ?? "."); // Default to '.' if no working dir set and no path provided
-        if (targetPath === "." && !workingDir) {
-            logger.warning("Executing git remote in server's CWD as no path provided and no session WD set.", { ...context, operation });
-            // Allow execution in CWD but log it clearly. Consider if an error is more appropriate.
-            // For now, let's proceed but be aware.
-            targetPath = process.cwd(); // Use actual CWD if '.' was the default
-        }
-        else if (targetPath === "." && workingDir) {
-            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; // Sanitize the final resolved path
-        logger.debug("Sanitized path", {
-            ...context,
-            operation,
-            sanitizedPath: targetPath,
-        });
+export async function gitRemoteLogic(params, context) {
+    const operation = `gitRemoteLogic:${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 });
+    const targetPath = sanitization.sanitizePath(params.path === "." ? workingDir : params.path, { allowAbsolute: true }).sanitizedPath;
+    const args = ["-C", targetPath, "remote"];
+    switch (params.mode) {
+        case "list":
+            args.push("-v");
+            break;
+        case "add":
+            args.push("add", params.name, params.url);
+            break;
+        case "remove":
+            args.push("remove", params.name);
+            break;
+        case "show":
+            args.push("show", params.name);
+            break;
     }
     try {
-        let args;
-        let result;
-        switch (input.mode) {
-            case "list":
-                args = ["-C", targetPath, "remote", "-v"];
-                logger.debug(`Executing command: git ${args.join(" ")}`, {
-                    ...context,
-                    operation,
-                });
-                const { stdout: listStdout } = await execFileAsync("git", args);
-                const remotes = [];
-                const lines = listStdout.trim().split("\n");
-                const remoteMap = new Map();
-                lines.forEach((line) => {
-                    const parts = line.split(/\s+/);
-                    if (parts.length >= 3) {
-                        const name = parts[0];
-                        const url = parts[1];
-                        const type = parts[2].replace(/[()]/g, ""); // Remove parentheses around (fetch) or (push)
-                        if (!remoteMap.has(name)) {
-                            remoteMap.set(name, {});
-                        }
-                        if (type === "fetch") {
-                            remoteMap.get(name).fetchUrl = url;
-                        }
-                        else if (type === "push") {
-                            remoteMap.get(name).pushUrl = url;
-                        }
-                    }
-                });
-                remoteMap.forEach((urls, name) => {
-                    // Ensure both URLs are present, defaulting to fetch URL if push is missing (common case)
-                    remotes.push({
-                        name,
-                        fetchUrl: urls.fetchUrl || "N/A",
-                        pushUrl: urls.pushUrl || urls.fetchUrl || "N/A",
-                    });
-                });
-                result = { success: true, mode: "list", remotes };
-                break;
-            case "add":
-                if (!input.name || !input.url) {
-                    throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Remote 'name' and 'url' are required for 'add' mode.", { context, operation });
-                }
-                // Basic validation for remote name (avoiding shell injection characters)
-                if (!/^[a-zA-Z0-9_.-]+$/.test(input.name)) {
-                    throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid remote name: ${input.name}`, { context, operation });
-                }
-                args = ["-C", targetPath, "remote", "add", input.name, input.url];
-                logger.debug(`Executing command: git ${args.join(" ")}`, {
-                    ...context,
-                    operation,
-                });
-                await execFileAsync("git", args);
-                result = {
-                    success: true,
-                    mode: "add",
-                    message: `Remote '${input.name}' added successfully.`,
-                };
-                break;
-            case "remove":
-                if (!input.name) {
-                    throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Remote 'name' is required for 'remove' mode.", { context, operation });
-                }
-                if (!/^[a-zA-Z0-9_.-]+$/.test(input.name)) {
-                    throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid remote name: ${input.name}`, { context, operation });
-                }
-                args = ["-C", targetPath, "remote", "remove", input.name];
-                logger.debug(`Executing command: git ${args.join(" ")}`, {
-                    ...context,
-                    operation,
-                });
-                await execFileAsync("git", args);
-                result = {
-                    success: true,
-                    mode: "remove",
-                    message: `Remote '${input.name}' removed successfully.`,
-                };
-                break;
-            case "show":
-                if (!input.name) {
-                    throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Remote 'name' is required for 'show' mode.", { context, operation });
-                }
-                if (!/^[a-zA-Z0-9_.-]+$/.test(input.name)) {
-                    throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid remote name: ${input.name}`, { context, operation });
-                }
-                args = ["-C", targetPath, "remote", "show", input.name];
-                logger.debug(`Executing command: git ${args.join(" ")}`, {
-                    ...context,
-                    operation,
-                });
-                const { stdout: showStdout } = await execFileAsync("git", args);
-                result = { success: true, mode: "show", details: showStdout.trim() };
-                break;
-            default:
-                // Should not happen due to Zod validation, but good practice
-                throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid mode: ${input.mode}`, { context, operation });
+        logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+        const { stdout } = await execFileAsync("git", args);
+        if (params.mode === 'list') {
+            const remoteMap = new Map();
+            stdout.trim().split("\n").forEach(line => {
+                const parts = line.split(/\s+/);
+                if (parts.length < 3)
+                    return;
+                const [name, url, type] = parts;
+                const cleanType = type.replace(/[()]/g, "");
+                if (!remoteMap.has(name))
+                    remoteMap.set(name, {});
+                if (cleanType === 'fetch')
+                    remoteMap.get(name).fetchUrl = url;
+                if (cleanType === 'push')
+                    remoteMap.get(name).pushUrl = url;
+            });
+            const remotes = Array.from(remoteMap.entries()).map(([name, urls]) => ({ name, fetchUrl: urls.fetchUrl || 'N/A', pushUrl: urls.pushUrl || urls.fetchUrl || 'N/A' }));
+            return { success: true, mode: params.mode, remotes };
+        }
+        if (params.mode === 'show') {
+            return { success: true, mode: params.mode, details: stdout.trim() };
         }
-        logger.info(`git remote ${input.mode} executed successfully`, {
-            ...context,
-            operation,
-            path: targetPath,
-            result,
-        });
-        return result;
+        return { success: true, mode: params.mode, message: `Remote '${params.name}' ${params.mode === 'add' ? 'added' : 'removed'} successfully.` };
     }
     catch (error) {
         const errorMessage = error.stderr || error.message || "";
-        logger.error(`Failed to execute git remote command`, {
-            ...context,
-            operation,
-            path: targetPath,
-            error: errorMessage,
-            stderr: error.stderr,
-            stdout: error.stdout,
-        });
-        // Specific error handling
+        logger.error(`Failed to execute git remote 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 === "add" &&
-            errorMessage.toLowerCase().includes("already exists")) {
-            throw new McpError(BaseErrorCode.CONFLICT, `Failed to add remote: Remote '${input.name}' already exists. Error: ${errorMessage}`, { context, operation, originalError: error });
+        if (params.mode === "add" && errorMessage.toLowerCase().includes("already exists")) {
+            throw new McpError(BaseErrorCode.CONFLICT, `Remote '${params.name}' already exists.`);
         }
-        if ((input.mode === "remove" || input.mode === "show") &&
-            errorMessage.toLowerCase().includes("no such remote")) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Failed to ${input.mode} remote: Remote '${input.name}' does not exist. Error: ${errorMessage}`, { context, operation, originalError: error });
+        if ((params.mode === "remove" || params.mode === "show") && errorMessage.toLowerCase().includes("no such remote")) {
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Remote '${params.name}' does not exist.`);
         }
-        // Throw a generic McpError for other failures
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git remote ${input.mode} failed for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git remote ${params.mode} failed: ${errorMessage}`);
     }
 }

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

@@ -1,77 +1,64 @@
-import { BaseErrorCode } from "../../../types-global/errors.js"; // Direct import for types-global
-import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js"; // ErrorHandler (./utils/internal/errorHandler.js), logger (./utils/internal/logger.js), requestContextService (./utils/internal/requestContext.js)
-import { GitRemoteInputSchema, gitRemoteLogic, } from "./logic.js";
-let _getWorkingDirectory;
-let _getSessionId;
 /**
- * Initializes the state accessors needed by the git_remote 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_remote tool.
+ * @module src/mcp-server/tools/gitRemote/registration
  */
-export function initializeGitRemoteStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_remote tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
+import { gitRemoteLogic, GitRemoteOutputSchema, GitRemoteBaseSchema, } from "./logic.js";
 const TOOL_NAME = "git_remote";
 const TOOL_DESCRIPTION = "Manages remote repositories (list, add, remove, show).";
 /**
- * Registers the git_remote 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_remote 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 registerGitRemoteTool = async (server) => {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_remote must be initialized before registration.");
-    }
+export const registerGitRemoteTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitRemoteTool";
     const context = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(async () => {
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitRemoteInputSchema.shape, // Provide the Zod schema shape
-        async (validatedArgs, callContext) => {
-            const toolOperation = `tool:${TOOL_NAME}:${validatedArgs.mode}`; // Include mode in operation
-            const requestContext = requestContextService.createRequestContext({
-                operation: toolOperation,
-                parentContext: callContext,
+    server.registerTool(TOOL_NAME, {
+        title: "Git Remote",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitRemoteBaseSchema.shape,
+        outputSchema: GitRemoteOutputSchema.shape,
+        annotations: {
+            readOnlyHint: false, // Can add/remove remotes
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
+        });
+        try {
+            const sessionId = getSessionId(handlerContext);
+            const result = await gitRemoteLogic(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: `Success: ${JSON.stringify(result, null, 2)}` }],
             };
-            logger.info(`Executing tool: ${TOOL_NAME} (mode: ${validatedArgs.mode})`, logicContext);
-            return await ErrorHandler.tryCatch(async () => {
-                // Call the core logic function which returns a GitRemoteResult object
-                const remoteResult = await gitRemoteLogic(validatedArgs, logicContext);
-                // Format the result as a JSON string within TextContent
-                const resultContent = {
-                    type: "text",
-                    text: JSON.stringify(remoteResult, null, 2), // Pretty-print JSON
-                    contentType: "application/json",
-                };
-                // Log based on the success flag in the result
-                if (remoteResult.success) {
-                    logger.info(`Tool ${TOOL_NAME} (mode: ${validatedArgs.mode}) executed successfully, returning JSON`, logicContext);
-                }
-                else {
-                    // Log specific failure message from the result
-                    logger.warning(`Tool ${TOOL_NAME} (mode: ${validatedArgs.mode}) failed: ${remoteResult.message}`, { ...logicContext, errorDetails: remoteResult.error });
-                }
-                // Return the result, whether success or structured failure
-                return { content: [resultContent] };
-            }, {
-                operation: toolOperation,
-                context: logicContext,
-                input: validatedArgs,
-                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/gitReset/index.js

@@ -1,6 +1,5 @@
 /**
  * @fileoverview Barrel file for the gitReset tool.
+ * @module src/mcp-server/tools/gitReset/index
  */
-export { registerGitResetTool, initializeGitResetStateAccessors, } from "./registration.js";
-// Export types if needed elsewhere, e.g.:
-// export type { GitResetInput, GitResetResult } from './logic.js';
+export { registerGitResetTool } from "./registration.js";

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

@@ -1,144 +1,60 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_reset tool.
+ * @module src/mcp-server/tools/gitReset/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 reset modes
-const ResetModeEnum = z.enum(["soft", "mixed", "hard", "merge", "keep"]);
-// Define the input schema for the git_reset tool using Zod
+// 1. DEFINE the Zod input schema.
 export const GitResetInputSchema = z.object({
-    path: z
-        .string()
-        .min(1)
-        .optional()
-        .default(".")
-        .describe("Path to the Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
-    mode: ResetModeEnum.optional()
-        .default("mixed")
-        .describe("Reset mode: 'soft' (reset HEAD only), 'mixed' (reset HEAD and index, default), 'hard' (reset HEAD, index, and working tree - USE WITH CAUTION), 'merge', 'keep'."),
-    commit: z
-        .string()
-        .optional()
-        .describe("Commit, branch, or ref to reset to. Defaults to HEAD (useful for unstaging with 'mixed' mode)."),
-    // file: z.string().optional().describe("If specified, reset only this file in the index (unstaging). Mode must be 'mixed' or omitted."), // Git reset [<mode>] [<tree-ish>] [--] <paths>… is complex, handle separately if needed
+    path: z.string().default(".").describe("Path to the Git repository."),
+    mode: z.enum(["soft", "mixed", "hard", "merge", "keep"]).default("mixed").describe("Reset mode."),
+    commit: z.string().optional().describe("Commit, branch, or ref to reset to. Defaults to HEAD."),
+});
+// 2. DEFINE the Zod response schema.
+export const GitResetOutputSchema = z.object({
+    success: z.boolean().describe("Indicates if the command was successful."),
+    message: z.string().describe("A summary message of the result."),
+    changesSummary: z.string().optional().describe("Summary of changes, if any."),
 });
 /**
- * Executes the 'git reset' command and returns structured JSON output.
- *
- * @param {GitResetInput} input - The validated input object.
- * @param {RequestContext} context - The request context for logging and error handling.
- * @returns {Promise<GitResetResult>} A promise that resolves with the structured reset result.
- * @throws {McpError} Throws an McpError if path resolution, validation, or the git command fails unexpectedly.
+ * 4. IMPLEMENT the core logic function.
+ * @throws {McpError} If the logic encounters an unrecoverable issue.
  */
-export async function resetGitState(input, context) {
+export async function resetGitState(params, context) {
     const operation = "resetGitState";
-    logger.debug(`Executing ${operation}`, { ...context, input });
-    // Validate input combinations (e.g., file path usage) if refinement wasn't used
-    // if (input.file && input.mode && input.mode !== 'mixed') {
-    //   throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Resetting specific files is only supported with 'mixed' mode (or default).", { context, operation });
-    // }
-    // if (input.file && input.commit) {
-    //    throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Cannot specify both a commit and file paths for reset.", { context, operation });
-    // }
-    let targetPath;
-    try {
-        // Resolve and sanitize the target path
-        if (input.path && input.path !== ".") {
-            targetPath = input.path;
-        }
-        else {
-            const workingDir = context.getWorkingDirectory();
-            if (!workingDir) {
-                throw new McpError(BaseErrorCode.VALIDATION_ERROR, "No path provided and no working directory set for the session.", { context, operation });
-            }
-            targetPath = workingDir;
-        }
-        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, "reset"];
+    args.push(`--${params.mode}`);
+    if (params.commit)
+        args.push(params.commit);
     try {
-        // Construct the git reset command
-        const args = ["-C", targetPath, "reset"];
-        if (input.mode) {
-            args.push(`--${input.mode}`);
-        }
-        if (input.commit) {
-            args.push(input.commit);
-        }
-        // Handling file paths requires careful command construction, often without a commit ref.
-        // Example: `git reset HEAD -- path/to/file` or `git reset -- path/to/file` (unstages)
-        // For simplicity, this initial version focuses on resetting the whole HEAD/index/tree.
-        // Add file path logic here if needed, adjusting command structure.
-        logger.debug(`Executing command: git ${args.join(" ")}`, {
-            ...context,
-            operation,
-        });
-        // Execute command. Reset output is often minimal on success, but stderr might indicate issues.
+        logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
         const { stdout, stderr } = await execFileAsync("git", args);
-        logger.debug(`Git reset stdout: ${stdout}`, { ...context, operation });
-        if (stderr) {
-            // Log stderr as info, as it often contains the primary status message
-            logger.debug(`Git reset stderr: ${stderr}`, { ...context, operation });
-        }
-        // Analyze output (primarily stderr for reset)
-        const message = stderr.trim() ||
-            stdout.trim() ||
-            `Reset successful (mode: ${input.mode || "mixed"}).`; // Default success message
-        const changesSummary = stderr.includes("Unstaged changes after reset")
-            ? stderr
-            : undefined;
-        logger.info("git reset executed successfully", {
-            ...context,
-            operation,
-            path: targetPath,
-            message,
-            changesSummary,
-        });
+        const message = stderr.trim() || stdout.trim() || `Reset successful (mode: ${params.mode}).`;
+        const changesSummary = stderr.includes("Unstaged changes after reset") ? stderr : undefined;
         return { success: true, message, changesSummary };
     }
     catch (error) {
-        logger.error(`Failed to execute git reset command`, {
-            ...context,
-            operation,
-            path: targetPath,
-            error: error.message,
-            stderr: error.stderr,
-            stdout: error.stdout,
-        });
         const errorMessage = error.stderr || error.stdout || error.message || "";
-        // Handle specific error cases
+        logger.error(`Failed to execute git reset 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 });
-        }
-        if (errorMessage.includes("fatal: bad revision") ||
-            errorMessage.includes("unknown revision")) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Invalid commit reference specified: '${input.commit}'. Error: ${errorMessage}`, { context, operation, originalError: error });
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`);
         }
-        if (errorMessage.includes("Cannot reset paths") &&
-            errorMessage.includes("mode")) {
-            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid mode ('${input.mode}') used with file paths. Error: ${errorMessage}`, { context, operation, originalError: error });
+        if (errorMessage.includes("bad revision")) {
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Invalid commit reference specified: '${params.commit}'.`);
         }
         if (errorMessage.includes("unmerged paths")) {
-            throw new McpError(BaseErrorCode.CONFLICT, `Cannot reset due to unmerged files. Please resolve conflicts first. Error: ${errorMessage}`, { context, operation, originalError: error });
+            throw new McpError(BaseErrorCode.CONFLICT, "Cannot reset due to unmerged files. Please resolve conflicts first.");
         }
-        // Generic internal error for other failures
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to git reset for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git reset failed: ${errorMessage}`);
     }
 }