@cyanheads/git-mcp-server 2.1.0 → 2.1.2

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

@@ -1,15 +1,26 @@
-import { exec } 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 { exec } 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)
 const execAsync = promisify(exec);
 // Define the input schema for the git_show tool using Zod
 // No refinements needed here, so we don't need a separate BaseSchema
 export const GitShowInputSchema = z.object({
-    path: z.string().min(1).optional().default('.').describe("Path to the local Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
-    ref: z.string().min(1).describe("The object reference (commit hash, tag name, branch name, HEAD, etc.) to show."),
-    filePath: z.string().optional().describe("Optional specific file path within the ref to show (e.g., show a file's content at a specific commit). If provided, use the format '<ref>:<filePath>'."),
+    path: z
+        .string()
+        .min(1)
+        .optional()
+        .default(".")
+        .describe("Path to the local Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
+    ref: z
+        .string()
+        .min(1)
+        .describe("The object reference (commit hash, tag name, branch name, HEAD, etc.) to show."),
+    filePath: z
+        .string()
+        .optional()
+        .describe("Optional specific file path within the ref to show (e.g., show a file's content at a specific commit). If provided, use the format '<ref>:<filePath>'."),
     // format: z.string().optional().describe("Optional format string for the output"), // Consider adding later
 });
 /**
@@ -21,37 +32,54 @@ export const GitShowInputSchema = z.object({
  * @throws {McpError} Throws an McpError for path resolution/validation failures or unexpected errors.
  */
 export async function gitShowLogic(input, context) {
-    const operation = 'gitShowLogic';
+    const operation = "gitShowLogic";
     logger.debug(`Executing ${operation}`, { ...context, input });
     let targetPath;
     try {
         // Resolve and sanitize the target path
         const workingDir = context.getWorkingDirectory();
-        targetPath = (input.path && input.path !== '.')
-            ? input.path
-            : workingDir ?? '.';
-        if (targetPath === '.' && !workingDir) {
+        targetPath =
+            input.path && input.path !== "." ? input.path : (workingDir ?? ".");
+        if (targetPath === "." && !workingDir) {
             logger.warning("Executing git show in server's CWD as no path provided and no session WD set.", { ...context, operation });
             targetPath = process.cwd();
         }
-        else if (targetPath === '.' && workingDir) {
+        else if (targetPath === "." && workingDir) {
             targetPath = workingDir;
-            logger.debug(`Using session working directory: ${targetPath}`, { ...context, operation, sessionId: context.sessionId });
+            logger.debug(`Using session working directory: ${targetPath}`, {
+                ...context,
+                operation,
+                sessionId: context.sessionId,
+            });
         }
         else {
-            logger.debug(`Using provided path: ${targetPath}`, { ...context, operation });
+            logger.debug(`Using provided path: ${targetPath}`, {
+                ...context,
+                operation,
+            });
         }
-        targetPath = sanitization.sanitizePath(targetPath, { allowAbsolute: true }).sanitizedPath;
-        logger.debug('Sanitized path', { ...context, operation, sanitizedPath: targetPath });
+        targetPath = sanitization.sanitizePath(targetPath, {
+            allowAbsolute: true,
+        }).sanitizedPath;
+        logger.debug("Sanitized path", {
+            ...context,
+            operation,
+            sanitizedPath: targetPath,
+        });
     }
     catch (error) {
-        logger.error('Path resolution or sanitization failed', { ...context, operation, error });
+        logger.error("Path resolution or sanitization failed", {
+            ...context,
+            operation,
+            error,
+        });
         if (error instanceof McpError)
             throw error;
         throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path: ${error instanceof Error ? error.message : String(error)}`, { context, operation, originalError: error });
     }
     // Validate ref format (simple validation)
-    if (!/^[a-zA-Z0-9_./~^:-]+$/.test(input.ref)) { // Allow ':' for filePath combination
+    if (!/^[a-zA-Z0-9_./~^:-]+$/.test(input.ref)) {
+        // Allow ':' for filePath combination
         throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid reference format: ${input.ref}`, { context, operation });
     }
     // Validate filePath format if provided (basic path chars)
@@ -60,7 +88,9 @@ export async function gitShowLogic(input, context) {
     }
     try {
         // Construct the refspec, combining ref and filePath if needed
-        const refSpec = input.filePath ? `${input.ref}:"${input.filePath}"` : `"${input.ref}"`;
+        const refSpec = input.filePath
+            ? `${input.ref}:"${input.filePath}"`
+            : `"${input.ref}"`;
         // Construct the command
         const command = `git -C "${targetPath}" show ${refSpec}`;
         logger.debug(`Executing command: ${command}`, { ...context, operation });
@@ -69,30 +99,43 @@ export async function gitShowLogic(input, context) {
         const { stdout, stderr } = await execAsync(command);
         if (stderr) {
             // Log stderr as debug info, as it might contain commit details etc.
-            logger.debug(`Git show command produced stderr (may be informational)`, { ...context, operation, stderr });
+            logger.debug(`Git show command produced stderr (may be informational)`, {
+                ...context,
+                operation,
+                stderr,
+            });
         }
-        logger.info(`${operation} executed successfully`, { ...context, operation, path: targetPath, refSpec });
+        logger.info(`git show executed successfully for ref: ${refSpec}`, {
+            ...context,
+            operation,
+            path: targetPath,
+        });
         return { success: true, content: stdout }; // Return raw stdout content
     }
     catch (error) {
-        const errorMessage = error.stderr || error.message || '';
-        logger.error(`Failed to execute git show command`, { ...context, operation, path: targetPath, error: errorMessage, stderr: error.stderr, stdout: error.stdout });
+        const errorMessage = error.stderr || error.message || "";
+        logger.error(`Failed to execute git show command`, {
+            ...context,
+            operation,
+            path: targetPath,
+            error: errorMessage,
+            stderr: error.stderr,
+            stdout: error.stdout,
+        });
         // Specific error handling
-        if (errorMessage.toLowerCase().includes('not a git repository')) {
+        if (errorMessage.toLowerCase().includes("not a git repository")) {
             throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`, { context, operation, originalError: error });
         }
         if (/unknown revision or path not in the working tree/i.test(errorMessage)) {
-            const target = input.filePath ? `${input.ref}:${input.filePath}` : input.ref;
-            return { success: false, message: `Failed to show: Reference or pathspec '${target}' not found.`, error: errorMessage };
+            const target = input.filePath
+                ? `${input.ref}:${input.filePath}`
+                : input.ref;
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Failed to show: Reference or pathspec '${target}' not found. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
         if (/ambiguous argument/i.test(errorMessage)) {
-            return { success: false, message: `Failed to show: Reference '${input.ref}' is ambiguous. Provide a more specific reference.`, error: errorMessage };
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Failed to show: Reference '${input.ref}' is ambiguous. Provide a more specific reference. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        // Return structured failure for other git errors
-        return {
-            success: false,
-            message: `Git show failed for path: ${targetPath}, ref: ${input.ref}.`,
-            error: errorMessage
-        };
+        // Throw a generic McpError for other failures
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git show failed for path: ${targetPath}, ref: ${input.ref}. Error: ${errorMessage}`, { context, operation, originalError: error });
     }
 }

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

@@ -1,7 +1,7 @@
-import { BaseErrorCode } from '../../../types-global/errors.js'; // Direct import for types-global
-import { ErrorHandler, logger, requestContextService } from '../../../utils/index.js'; // logger (./utils/internal/logger.js), ErrorHandler (./utils/internal/errorHandler.js), requestContextService (./utils/internal/requestContext.js)
+import { BaseErrorCode } from "../../../types-global/errors.js"; // Direct import for types-global
+import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js"; // logger (./utils/internal/logger.js), ErrorHandler (./utils/internal/errorHandler.js), requestContextService (./utils/internal/requestContext.js)
 // Import the schema and types
-import { GitShowInputSchema, gitShowLogic } from './logic.js';
+import { GitShowInputSchema, gitShowLogic, } from "./logic.js";
 let _getWorkingDirectory;
 let _getSessionId;
 /**
@@ -12,10 +12,10 @@ let _getSessionId;
 export function initializeGitShowStateAccessors(getWdFn, getSidFn) {
     _getWorkingDirectory = getWdFn;
     _getSessionId = getSidFn;
-    logger.info('State accessors initialized for git_show tool registration.');
+    logger.info("State accessors initialized for git_show tool registration.");
 }
-const TOOL_NAME = 'git_show';
-const TOOL_DESCRIPTION = 'Shows information about Git objects (commits, tags, blobs, trees) based on a reference. Can optionally show the content of a specific file at that reference. Returns the raw output.';
+const TOOL_NAME = "git_show";
+const TOOL_DESCRIPTION = "Shows information about Git objects (commits, tags, blobs, trees) based on a reference. Can optionally show the content of a specific file at that reference. Returns the raw output.";
 /**
  * Registers the git_show tool with the MCP server.
  *
@@ -25,9 +25,9 @@ const TOOL_DESCRIPTION = 'Shows information about Git objects (commits, tags, bl
  */
 export const registerGitShowTool = async (server) => {
     if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error('State accessors for git_show must be initialized before registration.');
+        throw new Error("State accessors for git_show must be initialized before registration.");
     }
-    const operation = 'registerGitShowTool';
+    const operation = "registerGitShowTool";
     const context = requestContextService.createRequestContext({ operation });
     await ErrorHandler.tryCatch(async () => {
         // Register the tool using the schema's shape (no refinements here)
@@ -37,7 +37,10 @@ export const registerGitShowTool = async (server) => {
             // 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 });
+            const requestContext = requestContextService.createRequestContext({
+                operation: toolOperation,
+                parentContext: callContext,
+            });
             const sessionId = _getSessionId(requestContext);
             const getWorkingDirectoryForSession = () => {
                 return _getWorkingDirectory(sessionId);
@@ -53,11 +56,13 @@ export const registerGitShowTool = async (server) => {
                 const showResult = await gitShowLogic(toolInput, logicContext);
                 // Format the result within TextContent
                 const resultContent = {
-                    type: 'text',
+                    type: "text",
                     // Return raw content on success, or error message on failure
-                    text: showResult.success ? showResult.content : `Error: ${showResult.message}${showResult.error ? `\nDetails: ${showResult.error}` : ''}`,
+                    text: showResult.success
+                        ? showResult.content
+                        : `Error: ${showResult.message}${showResult.error ? `\nDetails: ${showResult.error}` : ""}`,
                     // Use plain text content type, unless we decide to return JSON later
-                    contentType: 'text/plain',
+                    contentType: "text/plain",
                 };
                 // Log based on the success flag in the result
                 if (showResult.success) {

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

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

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

@@ -1,20 +1,33 @@
-import { exec } 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 { exec } 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)
 const execAsync = promisify(exec);
 // Define the BASE input schema for the git_stash tool using Zod
 export const GitStashBaseSchema = z.object({
-    path: z.string().min(1).optional().default('.').describe("Path to the local Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
-    mode: z.enum(['list', 'apply', 'pop', 'drop', 'save']).describe("The stash operation to perform: 'list', 'apply', 'pop', 'drop', 'save'."),
-    stashRef: z.string().optional().describe("Stash reference (e.g., 'stash@{1}'). Required for 'apply', 'pop', 'drop' modes."),
-    message: z.string().optional().describe("Optional descriptive message used only for 'save' mode."),
+    path: z
+        .string()
+        .min(1)
+        .optional()
+        .default(".")
+        .describe("Path to the local Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
+    mode: z
+        .enum(["list", "apply", "pop", "drop", "save"])
+        .describe("The stash operation to perform: 'list', 'apply', 'pop', 'drop', 'save'."),
+    stashRef: z
+        .string()
+        .optional()
+        .describe("Stash reference (e.g., 'stash@{1}'). Required for 'apply', 'pop', 'drop' modes."),
+    message: z
+        .string()
+        .optional()
+        .describe("Optional descriptive message used only for 'save' mode."),
     // includeUntracked: z.boolean().default(false).describe("Include untracked files in 'save' mode (-u)"), // Consider adding later
     // keepIndex: z.boolean().default(false).describe("Keep staged changes in 'save' mode (--keep-index)"), // Consider adding later
 });
 // Apply refinements and export the FINAL schema for validation within the handler
-export const GitStashInputSchema = GitStashBaseSchema.refine(data => !(['apply', 'pop', 'drop'].includes(data.mode) && !data.stashRef), {
+export const GitStashInputSchema = GitStashBaseSchema.refine((data) => !(["apply", "pop", "drop"].includes(data.mode) && !data.stashRef), {
     message: "A 'stashRef' (e.g., 'stash@{0}') is required for 'apply', 'pop', and 'drop' modes.",
     path: ["stashRef"], // Point error to the stashRef field
 });
@@ -33,25 +46,41 @@ export async function gitStashLogic(input, context) {
     try {
         // Resolve and sanitize the target path
         const workingDir = context.getWorkingDirectory();
-        targetPath = (input.path && input.path !== '.')
-            ? input.path
-            : workingDir ?? '.';
-        if (targetPath === '.' && !workingDir) {
+        targetPath =
+            input.path && input.path !== "." ? input.path : (workingDir ?? ".");
+        if (targetPath === "." && !workingDir) {
             logger.warning("Executing git stash in server's CWD as no path provided and no session WD set.", { ...context, operation });
             targetPath = process.cwd();
         }
-        else if (targetPath === '.' && workingDir) {
+        else if (targetPath === "." && workingDir) {
             targetPath = workingDir;
-            logger.debug(`Using session working directory: ${targetPath}`, { ...context, operation, sessionId: context.sessionId });
+            logger.debug(`Using session working directory: ${targetPath}`, {
+                ...context,
+                operation,
+                sessionId: context.sessionId,
+            });
         }
         else {
-            logger.debug(`Using provided path: ${targetPath}`, { ...context, operation });
+            logger.debug(`Using provided path: ${targetPath}`, {
+                ...context,
+                operation,
+            });
         }
-        targetPath = sanitization.sanitizePath(targetPath, { allowAbsolute: true }).sanitizedPath;
-        logger.debug('Sanitized path', { ...context, operation, sanitizedPath: targetPath });
+        targetPath = sanitization.sanitizePath(targetPath, {
+            allowAbsolute: true,
+        }).sanitizedPath;
+        logger.debug("Sanitized path", {
+            ...context,
+            operation,
+            sanitizedPath: targetPath,
+        });
     }
     catch (error) {
-        logger.error('Path resolution or sanitization failed', { ...context, operation, error });
+        logger.error("Path resolution or sanitization failed", {
+            ...context,
+            operation,
+            error,
+        });
         if (error instanceof McpError)
             throw error;
         throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path: ${error instanceof Error ? error.message : String(error)}`, { context, operation, originalError: error });
@@ -64,97 +93,153 @@ export async function gitStashLogic(input, context) {
         let command;
         let result;
         switch (input.mode) {
-            case 'list':
+            case "list":
                 command = `git -C "${targetPath}" stash list`;
-                logger.debug(`Executing command: ${command}`, { ...context, operation });
+                logger.debug(`Executing command: ${command}`, {
+                    ...context,
+                    operation,
+                });
                 const { stdout: listStdout } = await execAsync(command);
-                const stashes = listStdout.trim().split('\n')
-                    .filter(line => line)
-                    .map(line => {
+                const stashes = listStdout
+                    .trim()
+                    .split("\n")
+                    .filter((line) => line)
+                    .map((line) => {
                     // Improved regex to handle different stash list formats
                     const match = line.match(/^(stash@\{(\d+)\}):\s*(?:(?:WIP on|On)\s*([^:]+):\s*)?(.*)$/);
                     return match
-                        ? { ref: match[1], branch: match[3] || 'unknown', description: match[4] }
-                        : { ref: 'unknown', branch: 'unknown', description: line }; // Fallback parsing
+                        ? {
+                            ref: match[1],
+                            branch: match[3] || "unknown",
+                            description: match[4],
+                        }
+                        : { ref: "unknown", branch: "unknown", description: line }; // Fallback parsing
                 });
-                result = { success: true, mode: 'list', stashes };
+                result = { success: true, mode: "list", stashes };
                 break;
-            case 'apply':
-            case 'pop':
+            case "apply":
+            case "pop":
                 // stashRef is validated by Zod refine
                 const stashRefApplyPop = input.stashRef;
                 command = `git -C "${targetPath}" stash ${input.mode} ${stashRefApplyPop}`;
-                logger.debug(`Executing command: ${command}`, { ...context, operation });
+                logger.debug(`Executing command: ${command}`, {
+                    ...context,
+                    operation,
+                });
                 try {
                     const { stdout, stderr } = await execAsync(command);
                     // Check stdout/stderr for conflict messages, although exit code 0 usually means success
                     const conflicts = /conflict/i.test(stdout) || /conflict/i.test(stderr);
                     const message = conflicts
                         ? `Stash ${input.mode} resulted in conflicts that need manual resolution.`
-                        : `Stash ${stashRefApplyPop} ${input.mode === 'apply' ? 'applied' : 'popped'} successfully.`;
-                    logger.info(message, { ...context, operation, path: targetPath, conflicts });
+                        : `Stash ${stashRefApplyPop} ${input.mode === "apply" ? "applied" : "popped"} successfully.`;
+                    logger.info(message, {
+                        ...context,
+                        operation,
+                        path: targetPath,
+                        conflicts,
+                    });
                     result = { success: true, mode: input.mode, message, conflicts };
                 }
                 catch (applyError) {
-                    const applyErrorMessage = applyError.stderr || applyError.message || '';
+                    const applyErrorMessage = applyError.stderr || applyError.message || "";
                     if (/conflict/i.test(applyErrorMessage)) {
-                        logger.warning(`Stash ${input.mode} failed due to conflicts.`, { ...context, operation, path: targetPath, error: applyErrorMessage });
+                        logger.warning(`Stash ${input.mode} failed due to conflicts.`, {
+                            ...context,
+                            operation,
+                            path: targetPath,
+                            error: applyErrorMessage,
+                        });
                         // Return failure but indicate conflicts
-                        return { success: false, mode: input.mode, message: `Failed to ${input.mode} stash ${stashRefApplyPop} due to conflicts. Resolve conflicts manually.`, error: applyErrorMessage, conflicts: true };
+                        return {
+                            success: false,
+                            mode: input.mode,
+                            message: `Failed to ${input.mode} stash ${stashRefApplyPop} due to conflicts. Resolve conflicts manually.`,
+                            error: applyErrorMessage,
+                            conflicts: true,
+                        };
                     }
                     // Rethrow other errors
                     throw applyError;
                 }
                 break;
-            case 'drop':
+            case "drop":
                 // stashRef is validated by Zod refine
                 const stashRefDrop = input.stashRef;
                 command = `git -C "${targetPath}" stash drop ${stashRefDrop}`;
-                logger.debug(`Executing command: ${command}`, { ...context, operation });
+                logger.debug(`Executing command: ${command}`, {
+                    ...context,
+                    operation,
+                });
                 await execAsync(command);
-                result = { success: true, mode: 'drop', message: `Dropped ${stashRefDrop} successfully.`, stashRef: stashRefDrop };
+                result = {
+                    success: true,
+                    mode: "drop",
+                    message: `Dropped ${stashRefDrop} successfully.`,
+                    stashRef: stashRefDrop,
+                };
                 break;
-            case 'save':
+            case "save":
                 command = `git -C "${targetPath}" stash save`;
                 if (input.message) {
                     // Ensure message is properly quoted for the shell
                     command += ` "${input.message.replace(/"/g, '\\"')}"`;
                 }
-                logger.debug(`Executing command: ${command}`, { ...context, operation });
+                logger.debug(`Executing command: ${command}`, {
+                    ...context,
+                    operation,
+                });
                 const { stdout: saveStdout } = await execAsync(command);
                 const stashCreated = !/no local changes to save/i.test(saveStdout);
                 const saveMessage = stashCreated
-                    ? `Changes stashed successfully.` + (input.message ? ` Message: "${input.message}"` : '')
+                    ? `Changes stashed successfully.` +
+                        (input.message ? ` Message: "${input.message}"` : "")
                     : "No local changes to save.";
-                result = { success: true, mode: 'save', message: saveMessage, stashCreated };
+                result = {
+                    success: true,
+                    mode: "save",
+                    message: saveMessage,
+                    stashCreated,
+                };
                 break;
             default:
                 // Should not happen due to Zod validation
                 throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid mode: ${input.mode}`, { context, operation });
         }
-        logger.info(`${operation} executed successfully`, { ...context, operation, path: targetPath });
+        logger.info(`git stash ${input.mode} executed successfully`, {
+            ...context,
+            operation,
+            path: targetPath,
+            result,
+        });
         return result;
     }
     catch (error) {
-        const errorMessage = error.stderr || error.message || '';
-        logger.error(`Failed to execute git stash command`, { ...context, operation, path: targetPath, error: errorMessage, stderr: error.stderr, stdout: error.stdout });
+        const errorMessage = error.stderr || error.message || "";
+        logger.error(`Failed to execute git stash command`, {
+            ...context,
+            operation,
+            path: targetPath,
+            error: errorMessage,
+            stderr: error.stderr,
+            stdout: error.stdout,
+        });
         // Specific error handling
-        if (errorMessage.toLowerCase().includes('not a git repository')) {
+        if (errorMessage.toLowerCase().includes("not a git repository")) {
             throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`, { context, operation, originalError: error });
         }
-        if ((input.mode === 'apply' || input.mode === 'pop' || input.mode === 'drop') && /no such stash/i.test(errorMessage)) {
-            return { success: false, mode: input.mode, message: `Failed to ${input.mode} stash: Stash '${input.stashRef}' not found.`, error: errorMessage };
+        if ((input.mode === "apply" ||
+            input.mode === "pop" ||
+            input.mode === "drop") &&
+            /no such stash/i.test(errorMessage)) {
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Failed to ${input.mode} stash: Stash '${input.stashRef}' not found. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        if ((input.mode === 'apply' || input.mode === 'pop') && /conflict/i.test(errorMessage)) {
+        if ((input.mode === "apply" || input.mode === "pop") &&
+            /conflict/i.test(errorMessage)) {
             // This case might be caught above, but double-check here
-            return { success: false, mode: input.mode, message: `Failed to ${input.mode} stash '${input.stashRef}' due to conflicts. Resolve conflicts manually.`, error: errorMessage, conflicts: true };
+            throw new McpError(BaseErrorCode.CONFLICT, `Failed to ${input.mode} stash '${input.stashRef}' due to conflicts. Resolve conflicts manually. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        // Return structured failure for other git errors
-        return {
-            success: false,
-            mode: input.mode,
-            message: `Git stash ${input.mode} failed for path: ${targetPath}.`,
-            error: errorMessage
-        };
+        // Throw a generic McpError for other failures
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git stash ${input.mode} failed for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
     }
 }

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

@@ -1,8 +1,8 @@
-import { BaseErrorCode } from '../../../types-global/errors.js'; // Direct import for types-global
-import { ErrorHandler, logger, requestContextService } from '../../../utils/index.js'; // logger (./utils/internal/logger.js), ErrorHandler (./utils/internal/errorHandler.js), requestContextService (./utils/internal/requestContext.js)
+import { BaseErrorCode } from "../../../types-global/errors.js"; // Direct import for types-global
+import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js"; // logger (./utils/internal/logger.js), ErrorHandler (./utils/internal/errorHandler.js), requestContextService (./utils/internal/requestContext.js)
 // Import the final schema and types for handler logic
 // Import the BASE schema separately for registration shape
-import { GitStashBaseSchema, gitStashLogic } from './logic.js';
+import { GitStashBaseSchema, gitStashLogic, } from "./logic.js";
 let _getWorkingDirectory;
 let _getSessionId;
 /**
@@ -13,10 +13,10 @@ let _getSessionId;
 export function initializeGitStashStateAccessors(getWdFn, getSidFn) {
     _getWorkingDirectory = getWdFn;
     _getSessionId = getSidFn;
-    logger.info('State accessors initialized for git_stash tool registration.');
+    logger.info("State accessors initialized for git_stash tool registration.");
 }
-const TOOL_NAME = 'git_stash';
-const TOOL_DESCRIPTION = 'Manages stashed changes in the working directory. Supports listing stashes, applying/popping specific stashes (with conflict detection), dropping stashes, and saving current changes to a new stash with an optional message. Returns results as a JSON object.';
+const TOOL_NAME = "git_stash";
+const TOOL_DESCRIPTION = "Manages stashed changes in the working directory. Supports listing stashes, applying/popping specific stashes (with conflict detection), dropping stashes, and saving current changes to a new stash with an optional message. Returns results as a JSON object.";
 /**
  * Registers the git_stash tool with the MCP server.
  *
@@ -26,9 +26,9 @@ const TOOL_DESCRIPTION = 'Manages stashed changes in the working directory. Supp
  */
 export const registerGitStashTool = async (server) => {
     if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error('State accessors for git_stash must be initialized before registration.');
+        throw new Error("State accessors for git_stash must be initialized before registration.");
     }
-    const operation = 'registerGitStashTool';
+    const operation = "registerGitStashTool";
     const context = requestContextService.createRequestContext({ operation });
     await ErrorHandler.tryCatch(async () => {
         // Register the tool using the *base* schema's shape for definition
@@ -40,7 +40,10 @@ export const registerGitStashTool = async (server) => {
             // Cast validatedArgs to the specific input type for use within the handler
             const toolInput = validatedArgs;
             const toolOperation = `tool:${TOOL_NAME}:${toolInput.mode}`; // Include mode in operation
-            const requestContext = requestContextService.createRequestContext({ operation: toolOperation, parentContext: callContext });
+            const requestContext = requestContextService.createRequestContext({
+                operation: toolOperation,
+                parentContext: callContext,
+            });
             const sessionId = _getSessionId(requestContext);
             const getWorkingDirectoryForSession = () => {
                 return _getWorkingDirectory(sessionId);
@@ -56,9 +59,9 @@ export const registerGitStashTool = async (server) => {
                 const stashResult = await gitStashLogic(toolInput, logicContext);
                 // Format the result as a JSON string within TextContent
                 const resultContent = {
-                    type: 'text',
+                    type: "text",
                     text: JSON.stringify(stashResult, null, 2), // Pretty-print JSON
-                    contentType: 'application/json',
+                    contentType: "application/json",
                 };
                 // Log based on the success flag in the result
                 if (stashResult.success) {
@@ -66,7 +69,11 @@ export const registerGitStashTool = async (server) => {
                 }
                 else {
                     // Log specific failure message from the result
-                    logger.warning(`Tool ${TOOL_NAME} (mode: ${toolInput.mode}) failed: ${stashResult.message}`, { ...logicContext, errorDetails: stashResult.error, conflicts: stashResult.conflicts });
+                    logger.warning(`Tool ${TOOL_NAME} (mode: ${toolInput.mode}) failed: ${stashResult.message}`, {
+                        ...logicContext,
+                        errorDetails: stashResult.error,
+                        conflicts: stashResult.conflicts,
+                    });
                 }
                 // Return the result, whether success or structured failure
                 return { content: [resultContent] };

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

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