@cyanheads/git-mcp-server 2.0.15 → 2.1.0

package/README.md

@@ -2,7 +2,7 @@
 
 [![TypeScript](https://img.shields.io/badge/TypeScript-^5.8.3-blue.svg)](https://www.typescriptlang.org/)
 [![Model Context Protocol](https://img.shields.io/badge/MCP%20SDK-^1.12.1-green.svg)](https://modelcontextprotocol.io/)
-[![Version](https://img.shields.io/badge/Version-2.0.15-blue.svg)](./CHANGELOG.md)
+[![Version](https://img.shields.io/badge/Version-2.1.0-blue.svg)](./CHANGELOG.md)
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![Status](https://img.shields.io/badge/Status-Stable-green.svg)](https://github.com/cyanheads/git-mcp-server/issues)
 [![GitHub](https://img.shields.io/github/stars/cyanheads/git-mcp-server?style=social)](https://github.com/cyanheads/git-mcp-server)

package/dist/mcp-server/server.js

@@ -42,7 +42,7 @@ import { initializeGitStashStateAccessors, registerGitStashTool } from './tools/
 import { initializeGitStatusStateAccessors, registerGitStatusTool } from './tools/gitStatus/index.js';
 import { initializeGitTagStateAccessors, registerGitTagTool } from './tools/gitTag/index.js';
 import { initializeGitWorktreeStateAccessors, registerGitWorktreeTool } from './tools/gitWorktree/index.js';
-import { registerGitWrapupInstructionsTool } from './tools/gitWrapupInstructions/index.js';
+import { initializeGitWrapupInstructionsStateAccessors, registerGitWrapupInstructionsTool } from './tools/gitWrapupInstructions/index.js';
 // Import transport setup functions AND state accessors
 import { getHttpSessionWorkingDirectory, setHttpSessionWorkingDirectory, startHttpTransport } from './transports/httpTransport.js';
 import { connectStdioTransport, getStdioWorkingDirectory, setStdioWorkingDirectory } from './transports/stdioTransport.js';
@@ -160,7 +160,7 @@ async function createMcpServerInstance() {
         initializeGitStatusStateAccessors(getWorkingDirectory, getSessionIdFromContext);
         initializeGitTagStateAccessors(getWorkingDirectory, getSessionIdFromContext);
         initializeGitWorktreeStateAccessors(getWorkingDirectory, getSessionIdFromContext);
-        // No state accessor initialization needed for gitWrapupInstructionsTool
+        initializeGitWrapupInstructionsStateAccessors(getWorkingDirectory, getSessionIdFromContext); // Added this line
         logger.debug('State accessors initialized successfully.', context);
     }
     catch (initError) {

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

@@ -18,72 +18,61 @@ export const GitStatusInputSchema = z.object({
 function parseGitStatusPorcelainV1(porcelainOutput) {
     const lines = porcelainOutput.trim().split('\n');
     const result = {
-        currentBranch: null,
-        staged: [],
-        modified: [],
-        untracked: [],
-        conflicted: [],
-        isClean: true, // Assume clean initially
+        current_branch: null,
+        staged_changes: {},
+        unstaged_changes: {},
+        untracked_files: [],
+        conflicted_files: [],
+        is_clean: true, // Assume clean initially
     };
     if (lines.length === 0 || (lines.length === 1 && lines[0] === '')) {
-        // If output is empty, it might mean no branch yet or truly clean
-        // We'll refine branch detection below if possible
         return result;
     }
-    // First line often contains branch info (e.g., ## master...origin/master)
     if (lines[0].startsWith('## ')) {
-        const branchLine = lines.shift(); // Remove and process the branch line
-        // Try matching standard branch format first (e.g., ## master...origin/master [ahead 1])
-        // Make regex more specific: look for '...' or '[' after branch name, or end of line for simple branch name
+        const branchLine = lines.shift();
         const standardBranchMatch = branchLine.match(/^## ([^ ]+?)(?:\.\.\.| \[.*\]|$)/);
-        // Try matching the 'No commits yet' format (e.g., ## No commits yet on master)
         const noCommitsMatch = branchLine.match(/^## No commits yet on (.+)/);
-        // Try matching detached HEAD format (e.g., ## HEAD (no branch))
         const detachedMatch = branchLine.match(/^## HEAD \(no branch\)/);
         if (standardBranchMatch) {
-            result.currentBranch = standardBranchMatch[1];
-            // TODO: Optionally parse ahead/behind counts if needed from the full match
+            result.current_branch = standardBranchMatch[1];
         }
         else if (noCommitsMatch) {
-            // More descriptive state: Branch exists but has no commits
-            result.currentBranch = `${noCommitsMatch[1]} (no commits yet)`;
+            result.current_branch = `${noCommitsMatch[1]} (no commits yet)`;
         }
-        else if (detachedMatch) { // Handle detached HEAD
-            result.currentBranch = 'HEAD (detached)';
+        else if (detachedMatch) {
+            result.current_branch = 'HEAD (detached)';
         }
         else {
-            // Fallback if branch line format is unexpected
             logger.warning('Could not parse branch information from line:', { branchLine });
-            result.currentBranch = '(unknown)';
+            result.current_branch = '(unknown)';
         }
     }
     for (const line of lines) {
         if (!line)
-            continue; // Skip empty lines if any
-        result.isClean = false; // Any line indicates non-clean state
+            continue;
+        result.is_clean = false; // Any line indicates non-clean state
         const xy = line.substring(0, 2);
-        const file = line.substring(3); // Path starts after 'XY '
-        const stagedStatus = xy[0];
-        const unstagedStatus = xy[1];
+        const file = line.substring(3);
+        const stagedStatusChar = xy[0];
+        const unstagedStatusChar = xy[1];
         // Handle untracked files
         if (xy === '??') {
-            result.untracked.push(file);
+            result.untracked_files.push(file);
             continue;
         }
-        // Handle conflicted files (complex statuses)
-        if (stagedStatus === 'U' || unstagedStatus === 'U' || (stagedStatus === 'A' && unstagedStatus === 'A') || (stagedStatus === 'D' && unstagedStatus === 'D')) {
-            result.conflicted.push(file);
-            // Decide how to represent conflicts (could be more granular)
-            if (!result.staged.some(f => f.file === file))
-                result.staged.push({ status: 'Conflicted', file });
-            if (!result.modified.some(f => f.file === file))
-                result.modified.push({ status: 'Conflicted', 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')) {
+            result.conflicted_files.push(file);
+            continue; // Conflicted files are handled separately and not in staged/unstaged
         }
         // Handle staged changes (index status)
-        if (stagedStatus !== ' ' && stagedStatus !== '?') {
-            let statusDesc = 'Unknown Staged';
-            switch (stagedStatus) {
+        if (stagedStatusChar !== ' ' && stagedStatusChar !== '?') {
+            let statusDesc = undefined;
+            switch (stagedStatusChar) {
                 case 'M':
                     statusDesc = 'Modified';
                     break;
@@ -95,20 +84,25 @@ function parseGitStatusPorcelainV1(porcelainOutput) {
                     break;
                 case 'R':
                     statusDesc = 'Renamed';
-                    break; // Often includes ' -> new_name' in file path
+                    break;
                 case 'C':
                     statusDesc = 'Copied';
-                    break; // Often includes ' -> new_name' in file path
+                    break;
                 case 'T':
-                    statusDesc = 'Type Changed';
+                    statusDesc = 'TypeChanged';
                     break;
             }
-            result.staged.push({ status: statusDesc, file });
+            if (statusDesc) {
+                if (!result.staged_changes[statusDesc]) {
+                    result.staged_changes[statusDesc] = [];
+                }
+                result.staged_changes[statusDesc].push(file);
+            }
         }
         // Handle unstaged changes (worktree status)
-        if (unstagedStatus !== ' ' && unstagedStatus !== '?') {
-            let statusDesc = 'Unknown Unstaged';
-            switch (unstagedStatus) {
+        if (unstagedStatusChar !== ' ' && unstagedStatusChar !== '?') {
+            let statusDesc = undefined;
+            switch (unstagedStatusChar) {
                 case 'M':
                     statusDesc = 'Modified';
                     break;
@@ -116,18 +110,23 @@ function parseGitStatusPorcelainV1(porcelainOutput) {
                     statusDesc = 'Deleted';
                     break;
                 case 'T':
-                    statusDesc = 'Type Changed';
+                    statusDesc = 'TypeChanged';
                     break;
-                // Note: 'A' (Added) in unstaged usually means untracked ('??') handled above
+                // 'A' (Added but not committed) is handled by '??' (untracked)
+                // 'R' and 'C' in worktree without being staged are complex, often appear as deleted + untracked
             }
-            // Avoid duplicating if already marked as conflicted
-            if (!result.modified.some(f => f.file === file && f.status === 'Conflicted')) {
-                result.modified.push({ status: statusDesc, file });
+            if (statusDesc) {
+                if (!result.unstaged_changes[statusDesc]) {
+                    result.unstaged_changes[statusDesc] = [];
+                }
+                result.unstaged_changes[statusDesc].push(file);
             }
         }
     }
-    // Final check for cleanliness
-    result.isClean = result.staged.length === 0 && result.modified.length === 0 && result.untracked.length === 0 && result.conflicted.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;
 }
 /**
@@ -186,13 +185,17 @@ export async function getGitStatus(input, context // Add getter to context
         const structuredResult = parseGitStatusPorcelainV1(stdout);
         // If parsing resulted in clean state but no branch, re-check branch explicitly
         // This handles the case of an empty repo after init but before first commit
-        if (structuredResult.isClean && !structuredResult.currentBranch) {
+        if (structuredResult.is_clean && !structuredResult.current_branch) {
             try {
                 const branchCommand = `git -C "${targetPath}" rev-parse --abbrev-ref HEAD`;
                 const { stdout: branchStdout } = await execAsync(branchCommand);
-                const currentBranch = branchStdout.trim();
-                if (currentBranch && currentBranch !== 'HEAD') {
-                    structuredResult.currentBranch = currentBranch;
+                const currentBranchName = branchStdout.trim(); // Renamed variable for clarity
+                if (currentBranchName && currentBranchName !== 'HEAD') {
+                    structuredResult.current_branch = currentBranchName;
+                }
+                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)';
                 }
             }
             catch (branchError) {

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

@@ -16,7 +16,7 @@ export function initializeGitStatusStateAccessors(getWdFn, getSidFn) {
     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. Shows the working tree status including tracked/untracked files, modifications, staged changes, and current branch information. Returns the status as a JSON object.';
+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.

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

@@ -1,3 +1,3 @@
-export { registerGitWrapupInstructionsTool } from './registration.js';
-// This tool does not require session-specific state accessors like getWorkingDirectory,
-// so no initialize...StateAccessors function is needed or exported here.
+export { registerGitWrapupInstructionsTool, initializeGitWrapupInstructionsStateAccessors } from './registration.js';
+// This tool now requires session-specific state accessors (getWorkingDirectory, getSessionId)
+// to fetch git status, so initializeGitWrapupInstructionsStateAccessors is exported for server setup.

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

@@ -1,4 +1,6 @@
 import { z } from 'zod';
+import { logger } from '../../../utils/index.js'; // Added logger
+import { getGitStatus } from '../gitStatus/logic.js'; // Corrected path
 // Define the input schema
 export const GitWrapupInstructionsInputSchema = z.object({
     acknowledgement: z.enum(['Y', 'y', 'Yes', 'yes'], {
@@ -24,13 +26,36 @@ Note: Be sure to set 'git_set_working_dir' if not already set.
  * @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.
  */
-export async function getWrapupInstructions(input, _context // Included for structural consistency, not used by this simple tool
-) {
+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) {
     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.`;
     }
+    let statusResult = undefined;
+    let statusError = undefined;
+    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);
+        }
+    }
+    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.';
+    }
     return {
         instructions: finalInstructions,
+        gitStatus: statusResult,
+        gitStatusError: statusError,
     };
 }

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

@@ -1,42 +1,78 @@
 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.
+ */
+export function initializeGitWrapupInstructionsStateAccessors(getWdFn, getSidFn) {
+    _getWorkingDirectory = getWdFn;
+    _getSessionId = getSidFn;
+    logger.info('State accessors initialized for git_wrapup_instructions tool registration.');
+}
 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.';
+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.';
 /**
  * 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.
+ * @throws {Error} If registration fails or state accessors are not initialized.
  */
 export const registerGitWrapupInstructionsTool = async (server) => {
+    if (!_getWorkingDirectory || !_getSessionId) {
+        throw new Error('State accessors for git_wrapup_instructions must be initialized before registration.');
+    }
     const operation = 'registerGitWrapupInstructionsTool';
-    const context = requestContextService.createRequestContext({ operation });
+    // Context for the registration operation itself
+    const registrationOpContext = requestContextService.createRequestContext({ operation });
     await ErrorHandler.tryCatch(async () => {
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitWrapupInstructionsInputSchema.shape, // Empty schema shape
-        async (validatedArgs, callContext) => {
+        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitWrapupInstructionsInputSchema.shape, async (validatedArgs, callContext) => {
             const toolOperation = 'tool:git_wrapup_instructions';
-            // Pass callContext as parentContext for consistent context chaining
-            const requestContext = requestContextService.createRequestContext({ operation: toolOperation, parentContext: callContext });
-            logger.info(`Executing tool: ${TOOL_NAME}`, requestContext);
+            // 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,
+            };
+            logger.info(`Executing tool: ${TOOL_NAME}`, logicContext);
             return await ErrorHandler.tryCatch(async () => {
-                const result = await getWrapupInstructions(validatedArgs, requestContext // Pass the created requestContext
-                );
+                // 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`, requestContext);
+                logger.info(`Tool ${TOOL_NAME} executed successfully, returning JSON`, logicContext);
                 return { content: [resultContent] };
             }, {
                 operation: toolOperation,
-                context: requestContext,
+                context: logicContext, // Use the enhanced logicContext for error reporting
                 input: validatedArgs,
                 errorCode: BaseErrorCode.INTERNAL_ERROR,
             });
         });
-        logger.info(`Tool registered: ${TOOL_NAME}`, context);
-    }, { operation, context, critical: true });
+        logger.info(`Tool registered: ${TOOL_NAME}`, registrationOpContext); // Use context for registration operation
+    }, { operation, context: registrationOpContext, critical: true }); // Use context for registration operation
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyanheads/git-mcp-server",
-  "version": "2.0.15",
+  "version": "2.1.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.",
   "type": "module",
   "license": "Apache-2.0",
@@ -40,15 +40,15 @@
     "@modelcontextprotocol/inspector": "^0.13.0",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "@types/jsonwebtoken": "^9.0.9",
-    "@types/node": "^22.15.27",
+    "@types/node": "^22.15.29",
     "@types/sanitize-html": "^2.16.0",
     "@types/validator": "^13.15.1",
     "chrono-node": "2.8.0",
     "dotenv": "^16.5.0",
     "express": "^5.1.0",
-    "ignore": "^7.0.4",
+    "ignore": "^7.0.5",
     "jsonwebtoken": "^9.0.2",
-    "openai": "^5.0.1",
+    "openai": "^5.0.2",
     "partial-json": "^0.1.7",
     "sanitize-html": "^2.17.0",
     "tiktoken": "^1.0.21",
@@ -58,7 +58,7 @@
     "winston": "^3.17.0",
     "winston-daily-rotate-file": "^5.0.0",
     "yargs": "^18.0.0",
-    "zod": "^3.25.42"
+    "zod": "^3.25.49"
   },
   "keywords": [
     "typescript",