@cyanheads/git-mcp-server 2.1.0 → 2.1.2

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

@@ -1,12 +1,17 @@
-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_status tool using Zod
 export const GitStatusInputSchema = 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."),
+    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."),
 });
 /**
  * Parses the output of 'git status --porcelain=v1 -b'.
@@ -16,7 +21,7 @@ export const GitStatusInputSchema = z.object({
  * @returns {GitStatusResult} - Structured status information.
  */
 function parseGitStatusPorcelainV1(porcelainOutput) {
-    const lines = porcelainOutput.trim().split('\n');
+    const lines = porcelainOutput.trim().split("\n");
     const result = {
         current_branch: null,
         staged_changes: {},
@@ -25,10 +30,10 @@ function parseGitStatusPorcelainV1(porcelainOutput) {
         conflicted_files: [],
         is_clean: true, // Assume clean initially
     };
-    if (lines.length === 0 || (lines.length === 1 && lines[0] === '')) {
+    if (lines.length === 0 || (lines.length === 1 && lines[0] === "")) {
         return result;
     }
-    if (lines[0].startsWith('## ')) {
+    if (lines[0].startsWith("## ")) {
         const branchLine = lines.shift();
         const standardBranchMatch = branchLine.match(/^## ([^ ]+?)(?:\.\.\.| \[.*\]|$)/);
         const noCommitsMatch = branchLine.match(/^## No commits yet on (.+)/);
@@ -40,11 +45,13 @@ function parseGitStatusPorcelainV1(porcelainOutput) {
             result.current_branch = `${noCommitsMatch[1]} (no commits yet)`;
         }
         else if (detachedMatch) {
-            result.current_branch = 'HEAD (detached)';
+            result.current_branch = "HEAD (detached)";
         }
         else {
-            logger.warning('Could not parse branch information from line:', { branchLine });
-            result.current_branch = '(unknown)';
+            logger.warning("Could not parse branch information from line:", {
+                branchLine,
+            });
+            result.current_branch = "(unknown)";
         }
     }
     for (const line of lines) {
@@ -56,40 +63,41 @@ function parseGitStatusPorcelainV1(porcelainOutput) {
         const stagedStatusChar = xy[0];
         const unstagedStatusChar = xy[1];
         // Handle untracked files
-        if (xy === '??') {
+        if (xy === "??") {
             result.untracked_files.push(file);
             continue;
         }
         // Handle conflicted files (unmerged paths)
         // DD = both deleted, AU = added by us, UD = deleted by them, UA = added by them, DU = deleted by us
         // AA = both added, UU = both modified
-        if (stagedStatusChar === 'U' || unstagedStatusChar === 'U' ||
-            (stagedStatusChar === 'D' && unstagedStatusChar === 'D') ||
-            (stagedStatusChar === 'A' && unstagedStatusChar === 'A')) {
+        if (stagedStatusChar === "U" ||
+            unstagedStatusChar === "U" ||
+            (stagedStatusChar === "D" && unstagedStatusChar === "D") ||
+            (stagedStatusChar === "A" && unstagedStatusChar === "A")) {
             result.conflicted_files.push(file);
             continue; // Conflicted files are handled separately and not in staged/unstaged
         }
         // Handle staged changes (index status)
-        if (stagedStatusChar !== ' ' && stagedStatusChar !== '?') {
+        if (stagedStatusChar !== " " && stagedStatusChar !== "?") {
             let statusDesc = undefined;
             switch (stagedStatusChar) {
-                case 'M':
-                    statusDesc = 'Modified';
+                case "M":
+                    statusDesc = "Modified";
                     break;
-                case 'A':
-                    statusDesc = 'Added';
+                case "A":
+                    statusDesc = "Added";
                     break;
-                case 'D':
-                    statusDesc = 'Deleted';
+                case "D":
+                    statusDesc = "Deleted";
                     break;
-                case 'R':
-                    statusDesc = 'Renamed';
+                case "R":
+                    statusDesc = "Renamed";
                     break;
-                case 'C':
-                    statusDesc = 'Copied';
+                case "C":
+                    statusDesc = "Copied";
                     break;
-                case 'T':
-                    statusDesc = 'TypeChanged';
+                case "T":
+                    statusDesc = "TypeChanged";
                     break;
             }
             if (statusDesc) {
@@ -100,17 +108,17 @@ function parseGitStatusPorcelainV1(porcelainOutput) {
             }
         }
         // Handle unstaged changes (worktree status)
-        if (unstagedStatusChar !== ' ' && unstagedStatusChar !== '?') {
+        if (unstagedStatusChar !== " " && unstagedStatusChar !== "?") {
             let statusDesc = undefined;
             switch (unstagedStatusChar) {
-                case 'M':
-                    statusDesc = 'Modified';
+                case "M":
+                    statusDesc = "Modified";
                     break;
-                case 'D':
-                    statusDesc = 'Deleted';
+                case "D":
+                    statusDesc = "Deleted";
                     break;
-                case 'T':
-                    statusDesc = 'TypeChanged';
+                case "T":
+                    statusDesc = "TypeChanged";
                     break;
                 // 'A' (Added but not committed) is handled by '??' (untracked)
                 // 'R' and 'C' in worktree without being staged are complex, often appear as deleted + untracked
@@ -123,10 +131,11 @@ function parseGitStatusPorcelainV1(porcelainOutput) {
             }
         }
     }
-    result.is_clean = Object.keys(result.staged_changes).length === 0 &&
-        Object.keys(result.unstaged_changes).length === 0 &&
-        result.untracked_files.length === 0 &&
-        result.conflicted_files.length === 0;
+    result.is_clean =
+        Object.keys(result.staged_changes).length === 0 &&
+            Object.keys(result.unstaged_changes).length === 0 &&
+            result.untracked_files.length === 0 &&
+            result.conflicted_files.length === 0;
     return result;
 }
 /**
@@ -137,17 +146,19 @@ function parseGitStatusPorcelainV1(porcelainOutput) {
  * @returns {Promise<GitStatusResult>} A promise that resolves with the structured git status.
  * @throws {McpError} Throws an McpError if path resolution or validation fails, or if the git command fails.
  */
-export async function getGitStatus(input, context // Add getter to context
-) {
-    const operation = 'getGitStatus';
+export async function getGitStatus(input, context) {
+    const operation = "getGitStatus";
     logger.debug(`Executing ${operation}`, { ...context, input });
     let targetPath;
     try {
         // Resolve the target path
-        if (input.path && input.path !== '.') {
+        if (input.path && input.path !== ".") {
             // Use the provided path directly
             targetPath = input.path;
-            logger.debug(`Using provided path: ${targetPath}`, { ...context, operation });
+            logger.debug(`Using provided path: ${targetPath}`, {
+                ...context,
+                operation,
+            });
         }
         else {
             // Path is '.' or undefined, try to get the session's working directory
@@ -156,15 +167,29 @@ export async function getGitStatus(input, context // Add getter to context
                 throw new McpError(BaseErrorCode.VALIDATION_ERROR, "No path provided and no working directory set for the session.", { context, operation });
             }
             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,
+            });
         }
         // Sanitize the resolved path
-        const sanitizedPathInfo = sanitization.sanitizePath(targetPath, { allowAbsolute: true });
-        logger.debug('Sanitized path', { ...context, operation, sanitizedPathInfo });
+        const sanitizedPathInfo = sanitization.sanitizePath(targetPath, {
+            allowAbsolute: true,
+        });
+        logger.debug("Sanitized path", {
+            ...context,
+            operation,
+            sanitizedPathInfo,
+        });
         targetPath = sanitizedPathInfo.sanitizedPath; // Use the sanitized path going forward
     }
     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;
         }
@@ -180,7 +205,11 @@ export async function getGitStatus(input, context // Add getter to context
             // Log stderr as warning but proceed to parse stdout
             logger.warning(`Git status command produced stderr (may be informational)`, { ...context, operation, stderr });
         }
-        logger.info(`${operation} command executed, parsing output...`, { ...context, operation, path: targetPath });
+        logger.debug(`${operation} command executed, parsing output...`, {
+            ...context,
+            operation,
+            path: targetPath,
+        });
         // Parse the porcelain output
         const structuredResult = parseGitStatusPorcelainV1(stdout);
         // If parsing resulted in clean state but no branch, re-check branch explicitly
@@ -190,26 +219,39 @@ export async function getGitStatus(input, context // Add getter to context
                 const branchCommand = `git -C "${targetPath}" rev-parse --abbrev-ref HEAD`;
                 const { stdout: branchStdout } = await execAsync(branchCommand);
                 const currentBranchName = branchStdout.trim(); // Renamed variable for clarity
-                if (currentBranchName && currentBranchName !== 'HEAD') {
+                if (currentBranchName && currentBranchName !== "HEAD") {
                     structuredResult.current_branch = currentBranchName;
                 }
-                else if (currentBranchName === 'HEAD' && !structuredResult.current_branch) {
+                else if (currentBranchName === "HEAD" &&
+                    !structuredResult.current_branch) {
                     // If rev-parse returns HEAD and we still don't have a branch (e.g. detached from no-commits branch)
-                    structuredResult.current_branch = 'HEAD (detached)';
+                    structuredResult.current_branch = "HEAD (detached)";
                 }
             }
             catch (branchError) {
                 // Ignore error if rev-parse fails (e.g., still no commits)
-                logger.debug('Could not determine branch via rev-parse, likely no commits yet.', { ...context, operation, branchError });
+                logger.debug("Could not determine branch via rev-parse, likely no commits yet.", { ...context, operation, branchError });
             }
         }
-        logger.info(`${operation} parsed successfully`, { ...context, operation, path: targetPath });
+        logger.info("git status parsed successfully", {
+            ...context,
+            operation,
+            path: targetPath,
+            isClean: structuredResult.is_clean,
+            currentBranch: structuredResult.current_branch,
+        });
         return structuredResult; // Return the structured JSON object
     }
     catch (error) {
-        logger.error(`Failed to execute or parse git status command`, { ...context, operation, path: targetPath, error: error.message, stderr: error.stderr });
-        const errorMessage = error.stderr || error.message || '';
-        if (errorMessage.toLowerCase().includes('not a git repository')) {
+        logger.error(`Failed to execute or parse git status command`, {
+            ...context,
+            operation,
+            path: targetPath,
+            error: error.message,
+            stderr: error.stderr,
+        });
+        const errorMessage = error.stderr || error.message || "";
+        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.INTERNAL_ERROR, `Failed to get git status for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });

package/dist/mcp-server/tools/gitStatus/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 result type along with the function and input schema
-import { getGitStatus, GitStatusInputSchema } from './logic.js';
+import { getGitStatus, GitStatusInputSchema, } from "./logic.js";
 let _getWorkingDirectory;
 let _getSessionId;
 /**
@@ -13,10 +13,10 @@ let _getSessionId;
 export function initializeGitStatusStateAccessors(getWdFn, getSidFn) {
     _getWorkingDirectory = getWdFn;
     _getSessionId = getSidFn;
-    logger.info('State accessors initialized for git_status tool registration.');
+    logger.info("State accessors initialized for git_status tool registration.");
 }
-const TOOL_NAME = 'git_status';
-const TOOL_DESCRIPTION = 'Retrieves the status of a Git repository. Returns a JSON object detailing the current branch, cleanliness, and changes. Staged and unstaged changes are grouped by status (e.g., Added, Modified), alongside lists of untracked and conflicted files.';
+const TOOL_NAME = "git_status";
+const TOOL_DESCRIPTION = "Retrieves the status of a Git repository. Returns a JSON object detailing the current branch, cleanliness, and changes. Staged and unstaged changes are grouped by status (e.g., Added, Modified), alongside lists of untracked and conflicted files.";
 /**
  * Registers the git_status tool with the MCP server.
  * Uses the high-level server.tool() method for registration, schema validation, and routing.
@@ -27,16 +27,19 @@ const TOOL_DESCRIPTION = 'Retrieves the status of a Git repository. Returns a JS
  */
 export const registerGitStatusTool = async (server) => {
     if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error('State accessors for git_status must be initialized before registration.');
+        throw new Error("State accessors for git_status must be initialized before registration.");
     }
-    const operation = 'registerGitStatusTool';
+    const operation = "registerGitStatusTool";
     const context = requestContextService.createRequestContext({ operation });
     await ErrorHandler.tryCatch(async () => {
         server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitStatusInputSchema.shape, // Provide the Zod schema shape
         async (validatedArgs, callContext) => {
-            const toolOperation = 'tool:git_status';
+            const toolOperation = "tool:git_status";
             // Create context, potentially inheriting from callContext
-            const requestContext = requestContextService.createRequestContext({ operation: toolOperation, parentContext: callContext });
+            const requestContext = requestContextService.createRequestContext({
+                operation: toolOperation,
+                parentContext: callContext,
+            });
             // Get session ID
             const sessionId = _getSessionId(requestContext);
             // Define the session-specific getter function
@@ -56,10 +59,10 @@ export const registerGitStatusTool = async (server) => {
                 const statusResult = await getGitStatus(validatedArgs, logicContext);
                 // Format the successful result as a JSON string within TextContent
                 const resultContent = {
-                    type: 'text',
+                    type: "text",
                     // Stringify the JSON object for the response content
                     text: JSON.stringify(statusResult, null, 2), // Pretty-print JSON
-                    contentType: 'application/json', // Specify content type
+                    contentType: "application/json", // Specify content type
                 };
                 logger.info(`Tool ${TOOL_NAME} executed successfully, returning JSON`, logicContext);
                 return { content: [resultContent] }; // isError defaults to false

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

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

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

@@ -1,28 +1,50 @@
-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_tag tool using Zod
 // We export this separately to access its .shape for registration
 export const GitTagBaseSchema = 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', 'create', 'delete']).describe("The tag operation to perform: 'list' (show all tags), 'create' (add a new tag), 'delete' (remove a local tag)."),
-    tagName: z.string().min(1).optional().describe("The name for the tag. Required for 'create' and 'delete' modes. e.g., 'v2.3.0'."),
-    message: z.string().optional().describe("The annotation message for the tag. Required and used only when 'mode' is 'create' and 'annotate' is true."),
-    commitRef: z.string().optional().describe("The commit hash, branch name, or other reference to tag. Used only in 'create' mode. Defaults to the current HEAD if omitted."),
-    annotate: z.boolean().default(false).describe("If true, creates an annotated tag (-a flag) instead of a lightweight tag. Requires 'message' to be provided. Used only in 'create' 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", "create", "delete"])
+        .describe("The tag operation to perform: 'list' (show all tags), 'create' (add a new tag), 'delete' (remove a local tag)."),
+    tagName: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("The name for the tag. Required for 'create' and 'delete' modes. e.g., 'v2.3.0'."),
+    message: z
+        .string()
+        .optional()
+        .describe("The annotation message for the tag. Required and used only when 'mode' is 'create' and 'annotate' is true."),
+    commitRef: z
+        .string()
+        .optional()
+        .describe("The commit hash, branch name, or other reference to tag. Used only in 'create' mode. Defaults to the current HEAD if omitted."),
+    annotate: z
+        .boolean()
+        .default(false)
+        .describe("If true, creates an annotated tag (-a flag) instead of a lightweight tag. Requires 'message' to be provided. Used only in 'create' mode."),
     // force: z.boolean().default(false).describe("Force tag creation/update (-f flag). Use with caution as it can overwrite existing tags."), // Consider adding later
 });
 // Apply refinements for conditional validation and export the final schema
-export const GitTagInputSchema = GitTagBaseSchema.refine(data => !(data.mode === 'create' && data.annotate && !data.message), {
+export const GitTagInputSchema = GitTagBaseSchema.refine((data) => !(data.mode === "create" && data.annotate && !data.message), {
     message: "An annotation 'message' is required when creating an annotated tag (annotate=true).",
     path: ["message"], // Point Zod error to the message field
-}).refine(data => !(data.mode === 'create' && !data.tagName), {
+})
+    .refine((data) => !(data.mode === "create" && !data.tagName), {
     message: "A 'tagName' is required for 'create' mode.",
     path: ["tagName"], // Point Zod error to the tagName field
-}).refine(data => !(data.mode === 'delete' && !data.tagName), {
+})
+    .refine((data) => !(data.mode === "delete" && !data.tagName), {
     message: "A 'tagName' is required for 'delete' mode.",
     path: ["tagName"], // Point Zod error to the tagName field
 });
@@ -41,25 +63,41 @@ export async function gitTagLogic(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 tag 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 });
@@ -76,14 +114,20 @@ export async function gitTagLogic(input, context) {
         let command;
         let result;
         switch (input.mode) {
-            case 'list':
+            case "list":
                 command = `git -C "${targetPath}" tag --list`;
-                logger.debug(`Executing command: ${command}`, { ...context, operation });
+                logger.debug(`Executing command: ${command}`, {
+                    ...context,
+                    operation,
+                });
                 const { stdout: listStdout } = await execAsync(command);
-                const tags = listStdout.trim().split('\n').filter(tag => tag); // Filter out empty lines
-                result = { success: true, mode: 'list', tags };
+                const tags = listStdout
+                    .trim()
+                    .split("\n")
+                    .filter((tag) => tag); // Filter out empty lines
+                result = { success: true, mode: "list", tags };
                 break;
-            case 'create':
+            case "create":
                 // TagName is validated by Zod refine
                 const tagNameCreate = input.tagName;
                 command = `git -C "${targetPath}" tag`;
@@ -95,47 +139,76 @@ export async function gitTagLogic(input, context) {
                 if (input.commitRef) {
                     command += ` "${input.commitRef}"`;
                 }
-                logger.debug(`Executing command: ${command}`, { ...context, operation });
+                logger.debug(`Executing command: ${command}`, {
+                    ...context,
+                    operation,
+                });
                 await execAsync(command);
-                result = { success: true, mode: 'create', message: `Tag '${tagNameCreate}' created successfully.`, tagName: tagNameCreate };
+                result = {
+                    success: true,
+                    mode: "create",
+                    message: `Tag '${tagNameCreate}' created successfully.`,
+                    tagName: tagNameCreate,
+                };
                 break;
-            case 'delete':
+            case "delete":
                 // TagName is validated by Zod refine
                 const tagNameDelete = input.tagName;
                 command = `git -C "${targetPath}" tag -d "${tagNameDelete}"`;
-                logger.debug(`Executing command: ${command}`, { ...context, operation });
+                logger.debug(`Executing command: ${command}`, {
+                    ...context,
+                    operation,
+                });
                 await execAsync(command);
-                result = { success: true, mode: 'delete', message: `Tag '${tagNameDelete}' deleted successfully.`, tagName: tagNameDelete };
+                result = {
+                    success: true,
+                    mode: "delete",
+                    message: `Tag '${tagNameDelete}' deleted successfully.`,
+                    tagName: tagNameDelete,
+                };
                 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 tag ${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 tag 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 tag 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 === 'create' && errorMessage.toLowerCase().includes('already exists')) {
-            return { success: false, mode: 'create', message: `Failed to create tag: Tag '${input.tagName}' already exists.`, error: errorMessage };
+        if (input.mode === "create" &&
+            errorMessage.toLowerCase().includes("already exists")) {
+            throw new McpError(BaseErrorCode.CONFLICT, `Failed to create tag: Tag '${input.tagName}' already exists. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        if (input.mode === 'delete' && errorMessage.toLowerCase().includes('not found')) {
-            return { success: false, mode: 'delete', message: `Failed to delete tag: Tag '${input.tagName}' not found.`, error: errorMessage };
+        if (input.mode === "delete" &&
+            errorMessage.toLowerCase().includes("not found")) {
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Failed to delete tag: Tag '${input.tagName}' not found. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        if (input.mode === 'create' && input.commitRef && errorMessage.toLowerCase().includes('unknown revision or path not in the working tree')) {
-            return { success: false, mode: 'create', message: `Failed to create tag: Commit reference '${input.commitRef}' not found.`, error: errorMessage };
+        if (input.mode === "create" &&
+            input.commitRef &&
+            errorMessage
+                .toLowerCase()
+                .includes("unknown revision or path not in the working tree")) {
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Failed to create tag: Commit reference '${input.commitRef}' not found. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        // Return structured failure for other git errors
-        return {
-            success: false,
-            mode: input.mode,
-            message: `Git tag ${input.mode} failed for path: ${targetPath}.`,
-            error: errorMessage
-        };
+        // Throw a generic McpError for other failures
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git tag ${input.mode} failed for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
     }
 }