@cyanheads/git-mcp-server 2.2.0 → 2.2.2

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

@@ -3,7 +3,6 @@
  * @module src/mcp-server/tools/gitClone/registration
  */
 import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
-import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
 import { gitCloneLogic, GitCloneInputSchema, GitCloneOutputSchema, } from "./logic.js";
 const TOOL_NAME = "git_clone";
 const TOOL_DESCRIPTION = "Clones a Git repository from a given URL into a specified absolute directory path. Supports cloning specific branches and setting clone depth.";
@@ -40,18 +39,19 @@ export const registerGitCloneTool = async (server, getSessionId) => {
         }
         catch (error) {
             logger.error(`Error in ${TOOL_NAME} handler`, { error, ...handlerContext });
-            const handledError = ErrorHandler.handleError(error, {
+            const mcpError = ErrorHandler.handleError(error, {
                 operation: `tool:${TOOL_NAME}`,
                 context: handlerContext,
                 input: params,
             });
-            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,
+                content: [{ type: "text", text: `Error: ${mcpError.message}` }],
+                structuredContent: {
+                    code: mcpError.code,
+                    message: mcpError.message,
+                    details: mcpError.details,
+                },
             };
         }
     });

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

@@ -30,23 +30,12 @@ export const GitCommitOutputSchema = z.object({
 async function stageFiles(targetPath, files, context) {
     const operation = "stageFilesForCommit";
     logger.debug(`Staging files: ${files.join(", ")}`, { ...context, operation });
-    try {
-        const sanitizedFiles = files.map(file => sanitization.sanitizePath(file, { rootDir: targetPath }).sanitizedPath);
-        await execFileAsync("git", ["-C", targetPath, "add", "--", ...sanitizedFiles]);
-    }
-    catch (error) {
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to stage files: ${error.stderr || error.message}`);
-    }
+    const sanitizedFiles = files.map(file => sanitization.sanitizePath(file, { rootDir: targetPath }).sanitizedPath);
+    await execFileAsync("git", ["-C", targetPath, "add", "--", ...sanitizedFiles]);
 }
 async function getCommittedFiles(targetPath, commitHash, context) {
-    try {
-        const { stdout } = await execFileAsync("git", ["-C", targetPath, "show", "--pretty=", "--name-only", commitHash]);
-        return stdout.trim().split("\n").filter(Boolean);
-    }
-    catch (error) {
-        logger.warning("Failed to retrieve committed files list", { ...context, commitHash, error: error.message });
-        return [];
-    }
+    const { stdout } = await execFileAsync("git", ["-C", targetPath, "show", "--pretty=", "--name-only", commitHash]);
+    return stdout.trim().split("\n").filter(Boolean);
 }
 /**
  * 4. IMPLEMENT the core logic function.
@@ -78,47 +67,28 @@ export async function commitGitChanges(params, context) {
         logger.debug(`Executing command: git ${finalArgs.join(" ")}`, { ...context, operation });
         return await execFileAsync("git", finalArgs);
     };
+    let result;
+    const shouldSign = config.gitSignCommits;
     try {
-        let result;
-        const shouldSign = config.gitSignCommits;
-        try {
-            result = await attemptCommit(shouldSign);
-        }
-        catch (error) {
-            const isSigningError = (error.stderr || "").includes("gpg failed to sign");
-            if (shouldSign && isSigningError && params.forceUnsignedOnFailure) {
-                logger.warning("Commit with signing failed. Retrying without signature.", { ...context, operation });
-                result = await attemptCommit(false);
-            }
-            else {
-                throw error;
-            }
-        }
-        const commitHashMatch = result.stdout.match(/([a-f0-9]{7,40})/);
-        const commitHash = commitHashMatch ? commitHashMatch[1] : undefined;
-        const committedFiles = commitHash ? await getCommittedFiles(targetPath, commitHash, context) : [];
-        return {
-            success: true,
-            message: `Commit successful: ${commitHash}`,
-            commitHash,
-            committedFiles,
-        };
+        result = await attemptCommit(shouldSign);
     }
     catch (error) {
-        const errorMessage = error.stderr || error.message || "";
-        logger.error(`Failed to execute git commit 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}`);
+        const isSigningError = (error.stderr || "").includes("gpg failed to sign");
+        if (shouldSign && isSigningError && params.forceUnsignedOnFailure) {
+            logger.warning("Commit with signing failed. Retrying without signature.", { ...context, operation });
+            result = await attemptCommit(false);
         }
-        if (errorMessage.includes("nothing to commit")) {
-            return { success: true, message: "Nothing to commit, working tree clean.", nothingToCommit: true };
+        else {
+            throw error;
         }
-        if (errorMessage.includes("conflicts")) {
-            throw new McpError(BaseErrorCode.CONFLICT, `Commit failed due to unresolved conflicts.`);
-        }
-        if (errorMessage.includes("pre-commit hook")) {
-            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Commit failed due to pre-commit hook failure.`);
-        }
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git commit failed: ${errorMessage}`);
     }
+    const commitHashMatch = result.stdout.match(/([a-f0-9]{7,40})/);
+    const commitHash = commitHashMatch ? commitHashMatch[1] : undefined;
+    const committedFiles = commitHash ? await getCommittedFiles(targetPath, commitHash, context) : [];
+    return {
+        success: true,
+        message: `Commit successful: ${commitHash}`,
+        commitHash,
+        committedFiles,
+    };
 }

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

@@ -3,7 +3,6 @@
  * @module src/mcp-server/tools/gitCommit/registration
  */
 import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
-import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
 import { commitGitChanges, GitCommitInputSchema, GitCommitOutputSchema, } from "./logic.js";
 const TOOL_NAME = "git_commit";
 const TOOL_DESCRIPTION = `Commits staged changes to the Git repository index with a descriptive message. Supports author override, amending, and empty commits. Returns a JSON result.
@@ -67,18 +66,19 @@ export const registerGitCommitTool = async (server, getWorkingDirectory, getSess
         }
         catch (error) {
             logger.error(`Error in ${TOOL_NAME} handler`, { error, ...handlerContext });
-            const handledError = ErrorHandler.handleError(error, {
+            const mcpError = ErrorHandler.handleError(error, {
                 operation: `tool:${TOOL_NAME}`,
                 context: handlerContext,
                 input: params,
             });
-            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,
+                content: [{ type: "text", text: `Error: ${mcpError.message}` }],
+                structuredContent: {
+                    code: mcpError.code,
+                    message: mcpError.message,
+                    details: mcpError.details,
+                },
             };
         }
     });

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

@@ -34,16 +34,13 @@ async function getUntrackedFilesDiff(targetPath, context) {
         return "";
     let diffs = "";
     for (const file of untrackedFiles) {
-        try {
-            const { stdout: diffOut } = await execFileAsync("git", ["-C", targetPath, "diff", "--no-index", "/dev/null", file]);
-            diffs += diffOut;
-        }
-        catch (error) {
-            if (error.stdout)
-                diffs += error.stdout;
-            else
-                logger.warning(`Failed to diff untracked file: ${file}`, { ...context, error: error.message });
-        }
+        const { stdout: diffOut } = await execFileAsync("git", ["-C", targetPath, "diff", "--no-index", "/dev/null", file]).catch(err => {
+            if (err.stdout)
+                return { stdout: err.stdout };
+            logger.warning(`Failed to diff untracked file: ${file}`, { ...context, error: err.message });
+            return { stdout: "" };
+        });
+        diffs += diffOut;
     }
     return diffs;
 }
@@ -71,33 +68,20 @@ export async function diffGitChanges(params, context) {
     }
     if (params.file)
         args.push("--", params.file);
-    try {
-        logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
-        const { stdout } = await execFileAsync("git", args, { maxBuffer: 1024 * 1024 * 20 });
-        let combinedDiff = stdout;
-        if (params.includeUntracked) {
-            const untrackedDiff = await getUntrackedFilesDiff(targetPath, context);
-            if (untrackedDiff) {
-                combinedDiff += (combinedDiff ? "\n" : "") + untrackedDiff;
-            }
-        }
-        const noChanges = combinedDiff.trim() === "";
-        const message = noChanges ? "No changes found." : `Diff generated successfully.${params.includeUntracked ? " Untracked files included." : ""}`;
-        return {
-            success: true,
-            diff: noChanges ? "No changes found." : combinedDiff,
-            message,
-        };
-    }
-    catch (error) {
-        const errorMessage = error.stderr || error.message || "";
-        logger.error(`Failed to execute git diff 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}`);
-        }
-        if (errorMessage.includes("bad object") || errorMessage.includes("unknown revision")) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Invalid commit reference or file path specified.`);
+    logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+    const { stdout } = await execFileAsync("git", args, { maxBuffer: 1024 * 1024 * 20 });
+    let combinedDiff = stdout;
+    if (params.includeUntracked) {
+        const untrackedDiff = await getUntrackedFilesDiff(targetPath, context);
+        if (untrackedDiff) {
+            combinedDiff += (combinedDiff ? "\n" : "") + untrackedDiff;
         }
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git diff failed: ${errorMessage}`);
     }
+    const noChanges = combinedDiff.trim() === "";
+    const message = noChanges ? "No changes found." : `Diff generated successfully.${params.includeUntracked ? " Untracked files included." : ""}`;
+    return {
+        success: true,
+        diff: noChanges ? "No changes found." : combinedDiff,
+        message,
+    };
 }

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

@@ -3,7 +3,6 @@
  * @module src/mcp-server/tools/gitDiff/registration
  */
 import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
-import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
 import { diffGitChanges, GitDiffOutputSchema, GitDiffBaseSchema, } from "./logic.js";
 const TOOL_NAME = "git_diff";
 const TOOL_DESCRIPTION = "Shows changes between commits, commit and working tree, etc. Can show staged changes or diff specific files. An optional 'includeUntracked' parameter (boolean) can be used to also show the content of untracked files. Returns the diff output as plain text.";
@@ -45,18 +44,19 @@ export const registerGitDiffTool = async (server, getWorkingDirectory, getSessio
         }
         catch (error) {
             logger.error(`Error in ${TOOL_NAME} handler`, { error, ...handlerContext });
-            const handledError = ErrorHandler.handleError(error, {
+            const mcpError = ErrorHandler.handleError(error, {
                 operation: `tool:${TOOL_NAME}`,
                 context: handlerContext,
                 input: params,
             });
-            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,
+                content: [{ type: "text", text: `Error: ${mcpError.message}` }],
+                structuredContent: {
+                    code: mcpError.code,
+                    message: mcpError.message,
+                    details: mcpError.details,
+                },
             };
         }
     });

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

@@ -44,24 +44,8 @@ export async function fetchGitRemote(params, context) {
     else if (params.remote) {
         args.push(params.remote);
     }
-    try {
-        logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
-        const { stderr } = await execFileAsync("git", args);
-        const message = stderr.trim() || "Fetch successful.";
-        return { success: true, message };
-    }
-    catch (error) {
-        const errorMessage = error.stderr || error.message || "";
-        logger.error(`Failed to execute git fetch 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}`);
-        }
-        if (errorMessage.includes("Could not read from remote repository")) {
-            throw new McpError(BaseErrorCode.SERVICE_UNAVAILABLE, `Failed to connect to remote repository '${params.remote || "default"}'.`);
-        }
-        if (errorMessage.includes("Authentication failed")) {
-            throw new McpError(BaseErrorCode.UNAUTHORIZED, `Authentication failed for remote repository '${params.remote || "default"}'.`);
-        }
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git fetch failed: ${errorMessage}`);
-    }
+    logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+    const { stderr } = await execFileAsync("git", args);
+    const message = stderr.trim() || "Fetch successful.";
+    return { success: true, message };
 }

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

@@ -3,7 +3,6 @@
  * @module src/mcp-server/tools/gitFetch/registration
  */
 import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
-import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
 import { fetchGitRemote, GitFetchInputSchema, GitFetchOutputSchema, } from "./logic.js";
 const TOOL_NAME = "git_fetch";
 const TOOL_DESCRIPTION = "Downloads objects and refs from one or more repositories. Can fetch specific remotes or all, prune stale branches, and fetch tags.";
@@ -45,18 +44,19 @@ export const registerGitFetchTool = async (server, getWorkingDirectory, getSessi
         }
         catch (error) {
             logger.error(`Error in ${TOOL_NAME} handler`, { error, ...handlerContext });
-            const handledError = ErrorHandler.handleError(error, {
+            const mcpError = ErrorHandler.handleError(error, {
                 operation: `tool:${TOOL_NAME}`,
                 context: handlerContext,
                 input: params,
             });
-            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,
+                content: [{ type: "text", text: `Error: ${mcpError.message}` }],
+                structuredContent: {
+                    code: mcpError.code,
+                    message: mcpError.message,
+                    details: mcpError.details,
+                },
             };
         }
     });

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

@@ -8,7 +8,6 @@ import path from "path";
 import { promisify } from "util";
 import { z } from "zod";
 import { logger, sanitization } from "../../../utils/index.js";
-import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
 const execFileAsync = promisify(execFile);
 // 1. DEFINE the Zod input schema.
 export const GitInitInputSchema = z.object({
@@ -33,12 +32,7 @@ export async function gitInitLogic(params, context) {
     logger.debug(`Executing ${operation}`, { ...context, params });
     const targetPath = sanitization.sanitizePath(params.path, { allowAbsolute: true }).sanitizedPath;
     const parentDir = path.dirname(targetPath);
-    try {
-        await fs.access(parentDir, fs.constants.W_OK);
-    }
-    catch (error) {
-        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Cannot access parent directory: ${parentDir}`);
-    }
+    await fs.access(parentDir, fs.constants.W_OK);
     const args = ["init"];
     if (params.quiet)
         args.push("--quiet");
@@ -46,24 +40,14 @@ export async function gitInitLogic(params, context) {
         args.push("--bare");
     args.push(`--initial-branch=${params.initialBranch || 'main'}`);
     args.push(targetPath);
-    try {
-        logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
-        const { stdout } = await execFileAsync("git", args);
-        const gitDirPath = params.bare ? targetPath : path.join(targetPath, ".git");
-        const gitDirExists = await fs.access(gitDirPath).then(() => true).catch(() => false);
-        const successMessage = stdout.trim() || `Successfully initialized Git repository in ${targetPath}`;
-        return { success: true, message: successMessage, path: targetPath, gitDirExists };
-    }
-    catch (error) {
-        const errorMessage = error.stderr || error.message || "";
-        logger.error(`Failed to execute git init command`, { ...context, operation, errorMessage });
-        if (errorMessage.toLowerCase().includes("permission denied")) {
-            throw new McpError(BaseErrorCode.FORBIDDEN, `Permission denied to initialize repository at: ${targetPath}`);
-        }
-        // Re-initializing is not an error, so we check for it and return a success response.
-        if (errorMessage.toLowerCase().includes("reinitialized existing git repository")) {
-            return { success: true, message: `Reinitialized existing Git repository in ${targetPath}`, path: targetPath, gitDirExists: true };
-        }
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to initialize repository: ${errorMessage}`);
+    logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+    const { stdout, stderr } = await execFileAsync("git", args);
+    // Re-initializing is not an error, so we check for it and return a success response.
+    if ((stderr || stdout).toLowerCase().includes("reinitialized existing git repository")) {
+        return { success: true, message: `Reinitialized existing Git repository in ${targetPath}`, path: targetPath, gitDirExists: true };
     }
+    const gitDirPath = params.bare ? targetPath : path.join(targetPath, ".git");
+    const gitDirExists = await fs.access(gitDirPath).then(() => true).catch(() => false);
+    const successMessage = stdout.trim() || `Successfully initialized Git repository in ${targetPath}`;
+    return { success: true, message: successMessage, path: targetPath, gitDirExists };
 }

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

@@ -3,7 +3,6 @@
  * @module src/mcp-server/tools/gitInit/registration
  */
 import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
-import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
 import { gitInitLogic, GitInitInputSchema, GitInitOutputSchema, } from "./logic.js";
 const TOOL_NAME = "git_init";
 const TOOL_DESCRIPTION = "Initializes a new Git repository at the specified path. If path is relative or omitted, it resolves against the session working directory (if you have set the git_working_dir). Can optionally set the initial branch name and create a bare repository.";
@@ -41,18 +40,19 @@ export const registerGitInitTool = async (server, getSessionId) => {
         }
         catch (error) {
             logger.error(`Error in ${TOOL_NAME} handler`, { error, ...handlerContext });
-            const handledError = ErrorHandler.handleError(error, {
+            const mcpError = ErrorHandler.handleError(error, {
                 operation: `tool:${TOOL_NAME}`,
                 context: handlerContext,
                 input: params,
             });
-            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,
+                content: [{ type: "text", text: `Error: ${mcpError.message}` }],
+                structuredContent: {
+                    code: mcpError.code,
+                    message: mcpError.message,
+                    details: mcpError.details,
+                },
             };
         }
     });

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

@@ -65,38 +65,25 @@ export async function logGitHistory(params, context) {
         args.push(`--until=${params.until}`);
     if (params.branchOrFile)
         args.push(params.branchOrFile);
-    try {
-        logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
-        const { stdout } = await execFileAsync("git", args, { maxBuffer: 1024 * 1024 * 10 });
-        if (params.showSignature) {
-            return { success: true, message: "Raw log output with signature status.", rawOutput: stdout };
-        }
-        const commitRecords = stdout.split(RECORD_SEP).filter(r => r.trim());
-        const commits = commitRecords.map(record => {
-            const fields = record.trim().split(FIELD_SEP);
-            return {
-                hash: fields[0],
-                authorName: fields[1],
-                authorEmail: fields[2],
-                timestamp: parseInt(fields[3], 10),
-                subject: fields[4],
-                body: fields[5] || undefined,
-            };
-        });
-        return { success: true, message: `Found ${commits.length} commit(s).`, commits };
+    logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+    const { stdout, stderr } = await execFileAsync("git", args, { maxBuffer: 1024 * 1024 * 10 });
+    if (stderr && stderr.toLowerCase().includes("does not have any commits yet")) {
+        return { success: true, message: "Repository has no commits yet.", commits: [] };
     }
-    catch (error) {
-        const errorMessage = error.stderr || error.message || "";
-        logger.error(`Failed to execute git log 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}`);
-        }
-        if (errorMessage.includes("bad revision")) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Invalid branch, tag, or revision specified: '${params.branchOrFile}'.`);
-        }
-        if (errorMessage.includes("does not have any commits yet")) {
-            return { success: true, message: "Repository has no commits yet.", commits: [] };
-        }
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git log failed: ${errorMessage}`);
+    if (params.showSignature) {
+        return { success: true, message: "Raw log output with signature status.", rawOutput: stdout };
     }
+    const commitRecords = stdout.split(RECORD_SEP).filter(r => r.trim());
+    const commits = commitRecords.map(record => {
+        const fields = record.trim().split(FIELD_SEP);
+        return {
+            hash: fields[0],
+            authorName: fields[1],
+            authorEmail: fields[2],
+            timestamp: parseInt(fields[3], 10),
+            subject: fields[4],
+            body: fields[5] || undefined,
+        };
+    });
+    return { success: true, message: `Found ${commits.length} commit(s).`, commits };
 }

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

@@ -3,7 +3,6 @@
  * @module src/mcp-server/tools/gitLog/registration
  */
 import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
-import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
 import { logGitHistory, GitLogInputSchema, GitLogOutputSchema, } from "./logic.js";
 const TOOL_NAME = "git_log";
 const TOOL_DESCRIPTION = "Shows commit logs for the repository. Supports limiting count, filtering by author, date range, and specific branch/file. Returns a JSON object containing a list of commit objects (`commits` array) by default. If `showSignature: true` is used, it returns a JSON object where the `commits` array is empty and the raw signature verification output is included in the `rawOutput` field.";
@@ -45,18 +44,19 @@ export const registerGitLogTool = async (server, getWorkingDirectory, getSession
         }
         catch (error) {
             logger.error(`Error in ${TOOL_NAME} handler`, { error, ...handlerContext });
-            const handledError = ErrorHandler.handleError(error, {
+            const mcpError = ErrorHandler.handleError(error, {
                 operation: `tool:${TOOL_NAME}`,
                 context: handlerContext,
                 input: params,
             });
-            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,
+                content: [{ type: "text", text: `Error: ${mcpError.message}` }],
+                structuredContent: {
+                    code: mcpError.code,
+                    message: mcpError.message,
+                    details: mcpError.details,
+                },
             };
         }
     });

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

@@ -51,32 +51,13 @@ export async function gitMergeLogic(params, context) {
             args.push("-m", params.commitMessage);
         args.push(params.branch);
     }
-    try {
-        logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
-        const { stdout } = await execFileAsync("git", args);
-        return {
-            success: true,
-            message: stdout.trim() || "Merge command executed successfully.",
-            fastForward: stdout.includes("Fast-forward"),
-            needsManualCommit: params.squash,
-            aborted: params.abort,
-        };
-    }
-    catch (error) {
-        const errorMessage = error.stderr || error.stdout || error.message || "";
-        logger.error(`Git merge command failed`, { ...context, operation, errorMessage });
-        if (errorMessage.includes("CONFLICT")) {
-            throw new McpError(BaseErrorCode.CONFLICT, "Merge failed due to conflicts. Please resolve them and commit.");
-        }
-        if (errorMessage.includes("unrelated histories")) {
-            throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Merge failed: Refusing to merge unrelated histories.");
-        }
-        if (errorMessage.includes("not a git repository")) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`);
-        }
-        if (errorMessage.match(/fatal: '.*?' does not point to a commit/)) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Merge failed: Branch '${params.branch}' not found.`);
-        }
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git merge failed: ${errorMessage}`);
-    }
+    logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+    const { stdout } = await execFileAsync("git", args);
+    return {
+        success: true,
+        message: stdout.trim() || "Merge command executed successfully.",
+        fastForward: stdout.includes("Fast-forward"),
+        needsManualCommit: params.squash,
+        aborted: params.abort,
+    };
 }

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

@@ -3,7 +3,6 @@
  * @module src/mcp-server/tools/gitMerge/registration
  */
 import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
-import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
 import { gitMergeLogic, GitMergeInputSchema, GitMergeOutputSchema, } from "./logic.js";
 const TOOL_NAME = "git_merge";
 const TOOL_DESCRIPTION = "Merges the specified branch into the current branch. Supports options like --no-ff, --squash, and --abort. Returns the merge result as a JSON object.";
@@ -45,18 +44,19 @@ export const registerGitMergeTool = async (server, getWorkingDirectory, getSessi
         }
         catch (error) {
             logger.error(`Error in ${TOOL_NAME} handler`, { error, ...handlerContext });
-            const handledError = ErrorHandler.handleError(error, {
+            const mcpError = ErrorHandler.handleError(error, {
                 operation: `tool:${TOOL_NAME}`,
                 context: handlerContext,
                 input: params,
             });
-            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,
+                content: [{ type: "text", text: `Error: ${mcpError.message}` }],
+                structuredContent: {
+                    code: mcpError.code,
+                    message: mcpError.message,
+                    details: mcpError.details,
+                },
             };
         }
     });

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

@@ -43,27 +43,8 @@ export async function pullGitChanges(params, context) {
         args.push(params.remote);
     if (params.branch)
         args.push(params.branch);
-    try {
-        logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
-        const { stdout, stderr } = await execFileAsync("git", args);
-        const message = stdout.trim() || stderr.trim() || "Pull command executed successfully.";
-        return { success: true, message, conflict: message.includes("CONFLICT") };
-    }
-    catch (error) {
-        const errorMessage = error.stderr || error.stdout || error.message || "";
-        logger.error(`Failed to execute git pull 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}`);
-        }
-        if (errorMessage.includes("Could not read from remote repository")) {
-            throw new McpError(BaseErrorCode.SERVICE_UNAVAILABLE, "Failed to connect to remote repository.");
-        }
-        if (errorMessage.includes("merge conflict")) {
-            throw new McpError(BaseErrorCode.CONFLICT, "Pull resulted in merge conflicts.");
-        }
-        if (errorMessage.includes("unrelated histories")) {
-            throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Pull failed: Refusing to merge unrelated histories.");
-        }
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git pull failed: ${errorMessage}`);
-    }
+    logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+    const { stdout, stderr } = await execFileAsync("git", args);
+    const message = stdout.trim() || stderr.trim() || "Pull command executed successfully.";
+    return { success: true, message, conflict: message.includes("CONFLICT") };
 }