@cyanheads/git-mcp-server 2.1.8 → 2.2.1

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

@@ -1,214 +1,73 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_tag tool.
+ * @module src/mcp-server/tools/gitTag/logic
+ */
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { z } from "zod";
-import { BaseErrorCode, McpError } from "../../../types-global/errors.js"; // Direct import for types-global
-import { logger, sanitization } from "../../../utils/index.js"; // logger (./utils/internal/logger.js), RequestContext (./utils/internal/requestContext.js), sanitization (./utils/security/sanitization.js)
+import { logger, sanitization } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
 const execFileAsync = promisify(execFile);
-// Define the base input schema for the git_tag tool using Zod
-// We export this separately to access its .shape for registration
+// 1. DEFINE the Zod input schema.
 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."),
-    // force: z.boolean().default(false).describe("Force tag creation/update (-f flag). Use with caution as it can overwrite existing tags."), // Consider adding later
+    path: z.string().default(".").describe("Path to the local Git repository."),
+    mode: z.enum(["list", "create", "delete"]).describe("The tag operation to perform."),
+    tagName: z.string().min(1).optional().describe("The name for the tag."),
+    message: z.string().optional().describe("The annotation message for the tag."),
+    commitRef: z.string().optional().describe("The commit hash, branch, or other reference to tag."),
+    annotate: z.boolean().default(false).describe("Create an annotated tag."),
 });
-// Apply refinements for conditional validation and export the final schema
 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), {
+    message: "An annotation 'message' is required when creating an annotated tag.",
+    path: ["message"],
+}).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), {
+    path: ["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
+    path: ["tagName"],
+});
+// 2. DEFINE the Zod response schema.
+export const GitTagOutputSchema = z.object({
+    success: z.boolean().describe("Indicates if the command was successful."),
+    mode: z.string().describe("The mode of operation that was performed."),
+    message: z.string().optional().describe("A summary message of the result."),
+    tags: z.array(z.string()).optional().describe("A list of tags for the 'list' mode."),
+    tagName: z.string().optional().describe("The name of the tag that was created or deleted."),
 });
 /**
- * Executes git tag commands based on the specified mode.
- *
- * @param {GitTagInput} input - The validated input object.
- * @param {RequestContext} context - The request context for logging and error handling.
- * @returns {Promise<GitTagResult>} A promise that resolves with the structured result.
- * @throws {McpError} Throws an McpError for path resolution/validation failures or unexpected errors.
+ * 4. IMPLEMENT the core logic function.
+ * @throws {McpError} If the logic encounters an unrecoverable issue.
  */
-export async function gitTagLogic(input, context) {
-    const operation = `gitTagLogic:${input.mode}`;
-    logger.debug(`Executing ${operation}`, { ...context, input });
-    let targetPath;
-    try {
-        // Resolve and sanitize the target path
-        const workingDir = context.getWorkingDirectory();
-        targetPath =
-            input.path && input.path !== "." ? input.path : (workingDir ?? ".");
-        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) {
-            targetPath = workingDir;
-            logger.debug(`Using session working directory: ${targetPath}`, {
-                ...context,
-                operation,
-                sessionId: context.sessionId,
-            });
-        }
-        else {
-            logger.debug(`Using provided path: ${targetPath}`, {
-                ...context,
-                operation,
-            });
-        }
-        targetPath = sanitization.sanitizePath(targetPath, {
-            allowAbsolute: true,
-        }).sanitizedPath;
-        logger.debug("Sanitized path", {
-            ...context,
-            operation,
-            sanitizedPath: targetPath,
-        });
-    }
-    catch (error) {
-        logger.error("Path resolution or sanitization failed", {
-            ...context,
-            operation,
-            error,
-        });
-        if (error instanceof McpError)
-            throw error;
-        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path: ${error instanceof Error ? error.message : String(error)}`, { context, operation, originalError: error });
-    }
-    // Validate tag name format (simple validation)
-    if (input.tagName && !/^[a-zA-Z0-9_./-]+$/.test(input.tagName)) {
-        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid tag name format: ${input.tagName}`, { context, operation });
-    }
-    // Validate commit ref format (simple validation - allows hashes, HEAD, branches, etc.)
-    if (input.commitRef && !/^[a-zA-Z0-9_./~^-]+$/.test(input.commitRef)) {
-        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid commit reference format: ${input.commitRef}`, { context, operation });
+export async function gitTagLogic(params, context) {
+    const operation = `gitTagLogic:${params.mode}`;
+    logger.debug(`Executing ${operation}`, { ...context, params });
+    const workingDir = context.getWorkingDirectory();
+    if (params.path === "." && !workingDir) {
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, "No session working directory set. Please specify a 'path' or use 'git_set_working_dir' first.");
     }
-    try {
-        let args;
-        let result;
-        switch (input.mode) {
-            case "list":
-                args = ["-C", targetPath, "tag", "--list"];
-                logger.debug(`Executing command: git ${args.join(" ")}`, {
-                    ...context,
-                    operation,
-                });
-                const { stdout: listStdout } = await execFileAsync("git", args);
-                const tags = listStdout
-                    .trim()
-                    .split("\n")
-                    .filter((tag) => tag); // Filter out empty lines
-                result = { success: true, mode: "list", tags };
-                break;
-            case "create":
-                // TagName is validated by Zod refine
-                const tagNameCreate = input.tagName;
-                args = ["-C", targetPath, "tag"];
-                if (input.annotate) {
-                    // Message is validated by Zod refine
-                    args.push("-a", "-m", input.message);
-                }
-                args.push(tagNameCreate);
-                if (input.commitRef) {
-                    args.push(input.commitRef);
-                }
-                logger.debug(`Executing command: git ${args.join(" ")}`, {
-                    ...context,
-                    operation,
-                });
-                await execFileAsync("git", args);
-                result = {
-                    success: true,
-                    mode: "create",
-                    message: `Tag '${tagNameCreate}' created successfully.`,
-                    tagName: tagNameCreate,
-                };
-                break;
-            case "delete":
-                // TagName is validated by Zod refine
-                const tagNameDelete = input.tagName;
-                args = ["-C", targetPath, "tag", "-d", tagNameDelete];
-                logger.debug(`Executing command: git ${args.join(" ")}`, {
-                    ...context,
-                    operation,
-                });
-                await execFileAsync("git", args);
-                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(`git tag ${input.mode} executed successfully`, {
-            ...context,
-            operation,
-            path: targetPath,
-            result,
-        });
-        return result;
+    const targetPath = sanitization.sanitizePath(params.path === "." ? workingDir : params.path, { allowAbsolute: true }).sanitizedPath;
+    const args = ["-C", targetPath, "tag"];
+    switch (params.mode) {
+        case "list":
+            args.push("--list");
+            break;
+        case "create":
+            if (params.annotate)
+                args.push("-a", "-m", params.message);
+            args.push(params.tagName);
+            if (params.commitRef)
+                args.push(params.commitRef);
+            break;
+        case "delete":
+            args.push("-d", params.tagName);
+            break;
     }
-    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,
-        });
-        // Specific error handling
-        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")) {
-            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")) {
-            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")) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Failed to create tag: Commit reference '${input.commitRef}' not found. Error: ${errorMessage}`, { context, operation, originalError: error });
-        }
-        // 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 });
+    logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+    const { stdout } = await execFileAsync("git", args);
+    if (params.mode === 'list') {
+        const tags = stdout.trim().split("\n").filter(Boolean);
+        return { success: true, mode: params.mode, tags };
     }
+    return { success: true, mode: params.mode, message: `Tag '${params.tagName}' ${params.mode}d successfully.`, tagName: params.tagName };
 }

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

@@ -1,85 +1,66 @@
-import { BaseErrorCode } from "../../../types-global/errors.js"; // Direct import for types-global
-import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js"; // ErrorHandler (./utils/internal/errorHandler.js), logger (./utils/internal/logger.js), requestContextService (./utils/internal/requestContext.js)
-// Import the final schema and types for handler logic
-// Import the BASE schema separately for registration shape
-import { GitTagBaseSchema, gitTagLogic, } from "./logic.js";
-let _getWorkingDirectory;
-let _getSessionId;
 /**
- * Initializes the state accessors needed by the git_tag tool registration.
- * @param getWdFn - Function to get the working directory for a session.
- * @param getSidFn - Function to get the session ID from context.
+ * @fileoverview Handles registration and error handling for the git_tag tool.
+ * @module src/mcp-server/tools/gitTag/registration
  */
-export function initializeGitTagStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_tag tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { gitTagLogic, GitTagInputSchema, GitTagOutputSchema, GitTagBaseSchema, } from "./logic.js";
 const TOOL_NAME = "git_tag";
 const TOOL_DESCRIPTION = "Manages Git tags. Supports listing existing tags, creating new lightweight or annotated tags against specific commits, and deleting local tags. Returns results as a JSON object.";
 /**
- * Registers the git_tag tool with the MCP server.
- *
- * @param {McpServer} server - The McpServer instance to register the tool with.
- * @returns {Promise<void>}
- * @throws {Error} If registration fails or state accessors are not initialized.
+ * Registers the git_tag tool with the MCP server instance.
+ * @param server The MCP server instance.
+ * @param getWorkingDirectory Function to get the session's working directory.
+ * @param getSessionId Function to get the session ID from context.
  */
-export const registerGitTagTool = async (server) => {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_tag must be initialized before registration.");
-    }
+export const registerGitTagTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitTagTool";
     const context = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(async () => {
-        // Register the tool using the *base* schema's shape for definition
-        server.tool(// Use BASE schema shape here
-        TOOL_NAME, TOOL_DESCRIPTION, GitTagBaseSchema.shape, // Use the shape from the BASE schema
-        // Let TypeScript infer handler argument types.
-        // The SDK validates against the full GitTagInputSchema before calling this.
-        async (validatedArgs, callContext) => {
-            // 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,
+    server.registerTool(TOOL_NAME, {
+        title: "Git Tag",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitTagBaseSchema.shape,
+        outputSchema: GitTagOutputSchema.shape,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true, // Can create/delete tags
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
+        });
+        try {
+            // Explicitly parse with the refined schema to enforce validation rules
+            const validatedParams = GitTagInputSchema.parse(params);
+            const sessionId = getSessionId(handlerContext);
+            const result = await gitTagLogic(validatedParams, {
+                ...handlerContext,
+                getWorkingDirectory: () => getWorkingDirectory(sessionId),
             });
-            const sessionId = _getSessionId(requestContext);
-            const getWorkingDirectoryForSession = () => {
-                return _getWorkingDirectory(sessionId);
-            };
-            const logicContext = {
-                ...requestContext,
-                sessionId: sessionId,
-                getWorkingDirectory: getWorkingDirectoryForSession,
+            return {
+                structuredContent: result,
+                content: [{ type: "text", text: `Success: ${JSON.stringify(result, null, 2)}` }],
             };
-            logger.info(`Executing tool: ${TOOL_NAME} (mode: ${toolInput.mode})`, logicContext);
-            return await ErrorHandler.tryCatch(async () => {
-                // Call the core logic function which returns a GitTagResult object
-                const tagResult = await gitTagLogic(toolInput, logicContext);
-                // Format the result as a JSON string within TextContent
-                const resultContent = {
-                    type: "text",
-                    text: JSON.stringify(tagResult, null, 2), // Pretty-print JSON
-                    contentType: "application/json",
-                };
-                // Log based on the success flag in the result
-                if (tagResult.success) {
-                    logger.info(`Tool ${TOOL_NAME} (mode: ${toolInput.mode}) executed successfully, returning JSON`, logicContext);
-                }
-                else {
-                    // Log specific failure message from the result
-                    logger.warning(`Tool ${TOOL_NAME} (mode: ${toolInput.mode}) failed: ${tagResult.message}`, { ...logicContext, errorDetails: tagResult.error });
-                }
-                // Return the result, whether success or structured failure
-                return { content: [resultContent] };
-            }, {
-                operation: toolOperation,
-                context: logicContext,
-                input: validatedArgs, // Log the raw validated args
-                errorCode: BaseErrorCode.INTERNAL_ERROR, // Default if unexpected error occurs in logic/wrapper
+        }
+        catch (error) {
+            logger.error(`Error in ${TOOL_NAME} handler`, { error, ...handlerContext });
+            const mcpError = ErrorHandler.handleError(error, {
+                operation: `tool:${TOOL_NAME}`,
+                context: handlerContext,
+                input: params,
             });
-        });
-        logger.info(`Tool registered: ${TOOL_NAME}`, context);
-    }, { operation, context, critical: true }); // Mark registration as critical
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error: ${mcpError.message}` }],
+                structuredContent: {
+                    code: mcpError.code,
+                    message: mcpError.message,
+                    details: mcpError.details,
+                },
+            };
+        }
+    });
+    logger.info(`Tool '${TOOL_NAME}' registered successfully.`, context);
 };

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

@@ -1,7 +1,5 @@
 /**
- * @fileoverview Barrel file for the git_worktree tool.
- * Exports the registration function and state accessor initialization function.
+ * @fileoverview Barrel file for the gitWorktree tool.
+ * @module src/mcp-server/tools/gitWorktree/index
  */
-export { registerGitWorktreeTool, initializeGitWorktreeStateAccessors, } from "./registration.js";
-// Export types if needed elsewhere, e.g.:
-// export type { GitWorktreeInput, GitWorktreeResult } from './logic.js';
+export { registerGitWorktreeTool } from "./registration.js";