@cyanheads/git-mcp-server 2.1.8 → 2.2.0

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

@@ -1,18 +1,21 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_wrapup_instructions tool.
+ * @module src/mcp-server/tools/gitWrapupInstructions/logic
+ */
 import { z } from "zod";
-import { logger } from "../../../utils/index.js"; // Added logger
-import { getGitStatus } from "../gitStatus/logic.js"; // Corrected path
-// Define the input schema
+import { logger } from "../../../utils/index.js";
+import { getGitStatus, GitStatusOutputSchema } from "../gitStatus/logic.js";
+// 1. DEFINE the Zod input schema.
 export const GitWrapupInstructionsInputSchema = z.object({
-    acknowledgement: z.enum(["Y", "y", "Yes", "yes"], {
-        required_error: "Acknowledgement is required.",
-        description: 'Acknowledgement that you have permission (implicit allowed, explicit preferred) from the user to initiate this tool. Must be "Y" or "Yes" (case-insensitive).',
-    }),
-    updateAgentMetaFiles: z
-        .enum(["Y", "y", "Yes", "yes"])
-        .optional()
-        .describe("If set to 'Y' or 'Yes', include an extra instruction to review and update agent-specific meta files like .clinerules or claude.md if present. Only use this if the user explicitly requested it."),
+    acknowledgement: z.enum(["Y", "y", "Yes", "yes"]).describe("Acknowledgement to initiate the wrap-up workflow."),
+    updateAgentMetaFiles: z.enum(["Y", "y", "Yes", "yes"]).optional().describe("Include an instruction to update agent-specific meta files."),
+});
+// 2. DEFINE the Zod response schema.
+export const GitWrapupInstructionsOutputSchema = z.object({
+    instructions: z.string().describe("The set of instructions for the wrap-up workflow."),
+    gitStatus: GitStatusOutputSchema.optional().describe("The current structured git status."),
+    gitStatusError: z.string().optional().describe("Any error message if getting git status failed."),
 });
-// The predefined instructions string.
 const WRAPUP_INSTRUCTIONS = `
 Perform all actions for our git wrapup workflow:
 1. Use the git_diff tool to understand the precise nature and rationale behind each change (what changed and why did it change?) within the code base. Use the 'includeUntracked' parameter to view all changes, including untracked files. This will help you understand the context and purpose of the modifications made.
@@ -24,46 +27,31 @@ Note: Be sure to set 'git_set_working_dir' if not already set.
 Instructions: Now write a concise list of what you must do to complete the git wrapup workflow, then perform all actions. Do not push unless requested.
 `;
 /**
- * Core logic for the git_wrapup_instructions tool.
- * This tool simply returns a predefined set of instructions, potentially augmented.
- *
- * @param {GitWrapupInstructionsInput} input - The validated input, may contain 'updateAgentMetaFiles'.
- * @param {RequestContext} _context - The request context (included for consistency, not used in this simple logic).
- * @returns {Promise<GitWrapupInstructionsResult>} A promise that resolves with the wrap-up instructions.
+ * 4. IMPLEMENT the core logic function.
+ * @throws {McpError} If the logic encounters an unrecoverable issue.
  */
-export async function getWrapupInstructions(input, 
-// The context is now expected to be enhanced by the registration layer
-// to include session-specific methods like getWorkingDirectory.
-context) {
+export async function getWrapupInstructions(params, context) {
     const operation = "getWrapupInstructions";
-    logger.debug(`Executing ${operation}`, { ...context, input });
+    logger.debug(`Executing ${operation}`, { ...context, params });
     let finalInstructions = WRAPUP_INSTRUCTIONS;
-    if (input.updateAgentMetaFiles &&
-        ["Y", "y", "Yes", "yes"].includes(input.updateAgentMetaFiles)) {
-        finalInstructions += ` Extra request: review and update if needed the .clinerules and claude.md files if present.`;
+    if (params.updateAgentMetaFiles) {
+        finalInstructions += `\nExtra request: review and update if needed the .clinerules and claude.md files if present.`;
     }
-    let statusResult = undefined;
-    let statusError = undefined;
+    let statusResult;
+    let statusError;
     const workingDir = context.getWorkingDirectory();
     if (workingDir) {
         try {
-            // The `getGitStatus` function expects `path` and a context with `getWorkingDirectory`.
-            // Passing `path: '.'` signals `getGitStatus` to use the working directory from the context.
-            // The `registration.ts` for this tool will be responsible for ensuring `context.getWorkingDirectory` is correctly supplied.
             statusResult = await getGitStatus({ path: "." }, context);
         }
         catch (error) {
-            logger.warning(`Failed to get git status while generating wrapup instructions (working dir: ${workingDir}). Tool will proceed without it.`, {
-                ...context,
-                tool: "gitWrapupInstructions",
-                originalError: error.message,
-            });
-            statusError = error instanceof Error ? error.message : String(error);
+            logger.warning(`Failed to get git status for wrapup instructions: ${error.message}`, { ...context, operation });
+            statusError = error.message;
         }
     }
     else {
-        logger.info("No working directory set for session, skipping git status for wrapup instructions.", { ...context, tool: "gitWrapupInstructions" });
         statusError = "No working directory set for session, git status skipped.";
+        logger.info(statusError, { ...context, operation });
     }
     return {
         instructions: finalInstructions,

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

@@ -1,80 +1,64 @@
-import { BaseErrorCode } from "../../../types-global/errors.js";
-import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js";
-import { getWrapupInstructions, GitWrapupInstructionsInputSchema, } from "./logic.js";
-let _getWorkingDirectory;
-let _getSessionId;
 /**
- * Initializes the state accessors needed by the git_wrapup_instructions tool.
- * This should be called once during server setup by server.ts.
- * @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_wrapup_instructions tool.
+ * @module src/mcp-server/tools/gitWrapupInstructions/registration
  */
-export function initializeGitWrapupInstructionsStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_wrapup_instructions tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
+import { getWrapupInstructions, GitWrapupInstructionsInputSchema, GitWrapupInstructionsOutputSchema, } from "./logic.js";
 const TOOL_NAME = "git_wrapup_instructions";
 const TOOL_DESCRIPTION = "Provides a standard Git wrap-up workflow. This involves reviewing changes with `git_diff`, updating documentation (README, CHANGELOG), and making logical, descriptive commits using the `git_commit` tool. The tool's response also includes the current `git status` output. You should set the working directory using `git_set_working_dir` before running this tool.";
 /**
- * Registers the git_wrapup_instructions 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_wrapup_instructions 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 registerGitWrapupInstructionsTool = async (server) => {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_wrapup_instructions must be initialized before registration.");
-    }
+export const registerGitWrapupInstructionsTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitWrapupInstructionsTool";
-    // Context for the registration operation itself
-    const registrationOpContext = requestContextService.createRequestContext({
-        operation,
-    });
-    await ErrorHandler.tryCatch(async () => {
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitWrapupInstructionsInputSchema.shape, async (validatedArgs, callContext) => {
-            const toolOperation = "tool:git_wrapup_instructions";
-            // Create a base RequestContext for this specific tool call,
-            // potentially linking to the callContext provided by the McpServer.
-            // Pass callContext directly; createRequestContext will handle it appropriately
-            // (e.g., by trying to extract a requestId or sessionId if relevant for linking).
-            const baseRequestContext = requestContextService.createRequestContext({ operation: toolOperation, parentContext: callContext });
-            // Retrieve the session ID using the initialized accessor.
-            // _getSessionId (which is getSessionIdFromContext from server.ts) expects Record<string, any>.
-            // callContext from server.tool() is compatible with Record<string, any>.
-            const sessionId = _getSessionId(callContext);
-            // Create the session-specific getWorkingDirectory function.
-            const getWorkingDirectoryForSession = () => {
-                // _getWorkingDirectory is guaranteed to be defined by the check at the start of register function.
-                return _getWorkingDirectory(sessionId);
-            };
-            // Construct the logicContext to be passed to the tool's core logic.
-            // This includes the base request context properties, the session ID,
-            // and the specific getWorkingDirectory function for this session.
-            const logicContext = {
-                ...baseRequestContext,
-                sessionId: sessionId,
-                getWorkingDirectory: getWorkingDirectoryForSession,
+    const context = requestContextService.createRequestContext({ operation });
+    server.registerTool(TOOL_NAME, {
+        title: "Git Wrap-up Instructions",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitWrapupInstructionsInputSchema.shape,
+        outputSchema: GitWrapupInstructionsOutputSchema.shape,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
+        });
+        try {
+            const sessionId = getSessionId(handlerContext);
+            const result = await getWrapupInstructions(params, {
+                ...handlerContext,
+                getWorkingDirectory: () => getWorkingDirectory(sessionId),
+            });
+            return {
+                structuredContent: result,
+                content: [{ type: "text", text: `Success: ${JSON.stringify(result, null, 2)}` }],
             };
-            logger.info(`Executing tool: ${TOOL_NAME}`, logicContext);
-            return await ErrorHandler.tryCatch(async () => {
-                // Call the core logic function with validated arguments and the prepared logicContext.
-                const result = await getWrapupInstructions(validatedArgs, logicContext);
-                const resultContent = {
-                    type: "text",
-                    text: JSON.stringify(result, null, 2),
-                    contentType: "application/json",
-                };
-                logger.info(`Tool ${TOOL_NAME} executed successfully, returning JSON`, logicContext);
-                return { content: [resultContent] };
-            }, {
-                operation: toolOperation,
-                context: logicContext, // Use the enhanced logicContext for error reporting
-                input: validatedArgs,
-                errorCode: BaseErrorCode.INTERNAL_ERROR,
+        }
+        catch (error) {
+            logger.error(`Error in ${TOOL_NAME} handler`, { error, ...handlerContext });
+            const handledError = ErrorHandler.handleError(error, {
+                operation: `tool:${TOOL_NAME}`,
+                context: handlerContext,
+                input: params,
             });
-        });
-        logger.info(`Tool registered: ${TOOL_NAME}`, registrationOpContext); // Use context for registration operation
-    }, { operation, context: registrationOpContext, critical: true }); // Use context for registration operation
+            const mcpError = handledError instanceof McpError
+                ? handledError
+                : new McpError(BaseErrorCode.INTERNAL_ERROR, "An unexpected error occurred.", { originalError: handledError });
+            return {
+                isError: true,
+                content: [{ type: "text", text: mcpError.message }],
+                structuredContent: mcpError.details,
+            };
+        }
+    });
+    logger.info(`Tool '${TOOL_NAME}' registered successfully.`, context);
 };

package/dist/mcp-server/transports/httpTransport.js

@@ -97,7 +97,7 @@ function startHttpServerWithRetry(app, initialPort, host, maxRetries, parentCont
         reject(new Error("Failed to bind to any port after multiple retries."));
     });
 }
-export async function startHttpTransport(createServerInstanceFn, parentContext) {
+export async function startHttpTransport(server, parentContext) {
     const app = new Hono();
     const transportContext = requestContextService.createRequestContext({
         ...parentContext,
@@ -180,8 +180,7 @@ export async function startHttpTransport(createServerInstanceFn, parentContext)
                     });
                 }
             };
-            // Connect the new transport to a new server instance.
-            const server = await createServerInstanceFn();
+            // Connect the new transport to the existing server instance.
             await server.connect(newTransport);
             transport = newTransport;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyanheads/git-mcp-server",
-  "version": "2.1.8",
+  "version": "2.2.0",
   "description": "An MCP (Model Context Protocol) server enabling LLMs and AI agents to interact with Git repositories. Provides tools for comprehensive Git operations including clone, commit, branch, diff, log, status, push, pull, merge, rebase, worktree, tag management, and more, via the MCP standard. STDIO & HTTP.",
   "main": "dist/index.js",
   "files": [
@@ -35,16 +35,16 @@
     "clean": "ts-node --esm scripts/clean.ts"
   },
   "dependencies": {
-    "@hono/node-server": "^1.14.4",
-    "@modelcontextprotocol/sdk": "^1.13.2",
-    "@types/node": "^24.0.7",
+    "@hono/node-server": "^1.16.0",
+    "@modelcontextprotocol/sdk": "^1.15.1",
+    "@types/node": "^24.0.14",
     "@types/sanitize-html": "^2.16.0",
     "@types/validator": "^13.15.2",
     "chrono-node": "2.8.0",
     "dotenv": "16.6.1",
-    "hono": "^4.8.3",
-    "jose": "^6.0.11",
-    "openai": "^5.8.2",
+    "hono": "^4.8.5",
+    "jose": "^6.0.12",
+    "openai": "^5.9.2",
     "partial-json": "^0.1.7",
     "sanitize-html": "^2.17.0",
     "tiktoken": "^1.0.21",
@@ -106,7 +106,7 @@
   },
   "devDependencies": {
     "prettier": "^3.6.2",
-    "typedoc": "^0.28.6"
+    "typedoc": "^0.28.7"
   },
   "publishConfig": {
     "access": "public"