@andrebuzeli/git-mcp 10.0.0 → 10.0.2

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { ProviderManager } from './providers/providerManager.js';
 import { loadMCPConfig } from './config.js';
 import { IsomorphicGitAdapter } from './utils/gitAdapter.js';
@@ -27,6 +27,7 @@ import { GitUpdateTool } from './tools/gitUpdate.js';
 import { GitHistoryTool } from './tools/gitHistory.js';
 import { GitFixTool } from './tools/gitFix.tool.js';
 import { GitIgnoreTool } from './tools/gitIgnore.js';
+import { GIT_PROMPTS } from './prompts/gitPrompts.js';
 import TOOLS_GUIDE from './resources/toolsGuide.js';
 async function main() {
     // Load optional mcp.json configuration (will populate process.env if values present)
@@ -68,11 +69,12 @@ async function main() {
     if (process.env.DEBUG) {
         console.error(`Registered ${tools.length} Git tools`);
         console.error(`Registered ${resources.length} resource(s)`);
+        console.error(`Registered ${GIT_PROMPTS.length} prompt(s)`);
     }
     // Create MCP Server with STDIO transport
     const server = new Server({
         name: '@andrebuzeli/git-mcp',
-        version: '7.3.2',
+        version: '10.0.1',
     });
     // Register tool list handler
     server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -146,7 +148,29 @@ async function main() {
             ],
         };
     });
-    // Start server with STDIO transport
+    // Register prompt list handler
+    server.setRequestHandler(ListPromptsRequestSchema, async () => {
+        return {
+            prompts: GIT_PROMPTS.map(prompt => ({
+                name: prompt.name,
+                description: prompt.description,
+                arguments: prompt.arguments,
+            })),
+        };
+    });
+    // Register prompt get handler
+    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+        const promptName = request.params.name;
+        const prompt = GIT_PROMPTS.find(p => p.name === promptName);
+        if (!prompt) {
+            throw new Error(`Prompt not found: ${promptName}`);
+        }
+        const result = await prompt.generate(request.params.arguments ?? {}, { providerManager, gitAdapter });
+        return {
+            description: result.description,
+            messages: result.messages,
+        };
+    });
     const transport = new StdioServerTransport();
     await server.connect(transport);
     // Only log in debug mode
@@ -154,6 +178,7 @@ async function main() {
         console.error(`✅ git-mcp MCP server running via STDIO`);
         console.error(`Tools: ${tools.length} registered`);
         console.error(`Resources: ${resources.length} registered`);
+        console.error(`Prompts: ${GIT_PROMPTS.length} registered`);
     }
 }
 main().catch(err => {

package/dist/prompts/gitPrompts.d.ts

@@ -26,11 +26,6 @@ export declare class GitUpdatePrompt implements Prompt {
     name: string;
     title: string;
     description: string;
-    arguments: {
-        name: string;
-        description: string;
-        required: boolean;
-    }[];
     generate(args: Record<string, any>, ctx: MCPContext): Promise<{
         description: string;
         messages: {
@@ -41,19 +36,13 @@ export declare class GitUpdatePrompt implements Prompt {
             };
         }[];
     }>;
-}
-/**
+} /**
  * /gitfix - Fix repository configuration
  */
 export declare class GitFixPrompt implements Prompt {
     name: string;
     title: string;
     description: string;
-    arguments: {
-        name: string;
-        description: string;
-        required: boolean;
-    }[];
     generate(args: Record<string, any>, ctx: MCPContext): Promise<{
         description: string;
         messages: {
@@ -72,11 +61,6 @@ export declare class GitLogPrompt implements Prompt {
     name: string;
     title: string;
     description: string;
-    arguments: {
-        name: string;
-        description: string;
-        required: boolean;
-    }[];
     generate(args: Record<string, any>, ctx: MCPContext): Promise<{
         description: string;
         messages: {
@@ -95,11 +79,6 @@ export declare class GitReleasePrompt implements Prompt {
     name: string;
     title: string;
     description: string;
-    arguments: {
-        name: string;
-        description: string;
-        required: boolean;
-    }[];
     generate(args: Record<string, any>, ctx: MCPContext): Promise<{
         description: string;
         messages: {

package/dist/prompts/gitPrompts.js

@@ -1,4 +1,3 @@
-import { getRepoInfo } from '../utils/repoHelpers.js';
 /**
  * /gitupdate - Complete update workflow with remote traceability
  */
@@ -7,31 +6,10 @@ export class GitUpdatePrompt {
         this.name = "gitupdate";
         this.title = "Git Update - Complete Workflow";
         this.description = "Execute complete Git update (add, commit, push) with full remote traceability via issues";
-        this.arguments = [
-            {
-                name: "projectPath",
-                description: "Absolute path to the repository (REQUIRED)",
-                required: true
-            }
-        ];
     }
     async generate(args, ctx) {
-        const projectPath = args.projectPath;
-        if (!projectPath) {
-            throw new Error('projectPath is required');
-        }
-        // Get current status to generate context
-        const status = await ctx.gitAdapter.status(projectPath);
-        const repoInfo = getRepoInfo(projectPath);
-        const filesChanged = [
-            ...status.modified,
-            ...status.created,
-            ...status.deleted,
-            ...status.renamed.map((r) => `${r.from} → ${r.to}`)
-        ];
-        const changesSummary = filesChanged.length > 0
-            ? `\n\nFiles to be committed:\n${filesChanged.map(f => `- ${f}`).join('\n')}`
-            : '\n\nNo changes detected.';
+        // PROMPT só instrui o AI AGENT - não detecta nada
+        // AI AGENT é responsável por detectar workspace e passar projectPath obrigatório
         return {
             description: "Git update workflow with remote traceability",
             messages: [
@@ -39,33 +17,27 @@ export class GitUpdatePrompt {
                     role: "user",
                     content: {
                         type: "text",
-                        text: `Execute git-update tool for repository: ${repoInfo.repoName}
-Project path: ${projectPath}
-Current branch: ${status.current || 'unknown'}
-${changesSummary}
+                        text: `Execute the git-update tool to update the current project.
 
-Use the git-update tool with these exact parameters:
-{
-  "projectPath": "${projectPath}",
-  "message": "Generate appropriate conventional commit message based on the changes above",
-  "files": ["."]
-}
+You must call the git-update tool with:
+- projectPath: (REQUIRED) Detect the user's current workspace folder path
+- message: (optional) Generate appropriate conventional commit message
+- files: (optional) Default is ["."]
 
 The tool will automatically:
 1. Stage all changes
-2. Create commit with the message
-3. Push to GitHub and Gitea with force
-4. Create traceability issues on both providers with change details
-5. Return complete tracking report
+2. Create commit
+3. Push to GitHub and Gitea
+4. Create traceability issues
+5. Return tracking report
 
-Execute the tool now without asking for confirmation.`
+Call the tool now with the workspace path you detect from context.`
                     }
                 }
             ]
         };
     }
-}
-/**
+} /**
  * /gitfix - Fix repository configuration
  */
 export class GitFixPrompt {
@@ -73,24 +45,9 @@ export class GitFixPrompt {
         this.name = "gitfix";
         this.title = "Git Fix - Repository Configuration";
         this.description = "Automatically fix and configure Git repository for dual-provider system";
-        this.arguments = [
-            {
-                name: "projectPath",
-                description: "Absolute path to the repository (REQUIRED)",
-                required: true
-            }
-        ];
     }
     async generate(args, ctx) {
-        const projectPath = args.projectPath;
-        if (!projectPath) {
-            throw new Error('projectPath is required');
-        }
-        const remotes = await ctx.gitAdapter.listRemotes(projectPath);
-        const repoInfo = getRepoInfo(projectPath);
-        const remotesInfo = remotes.length > 0
-            ? `\n\nCurrent remotes:\n${remotes.map(r => `- ${r.name}: ${r.url}`).join('\n')}`
-            : '\n\nNo remotes configured.';
+        // PROMPT só instrui o AI AGENT - não detecta nada
         return {
             description: "Fix Git repository configuration",
             messages: [
@@ -98,27 +55,20 @@ export class GitFixPrompt {
                     role: "user",
                     content: {
                         type: "text",
-                        text: `Execute git-fix tool for repository: ${repoInfo.repoName}
-Project path: ${projectPath}
-${remotesInfo}
+                        text: `Execute the git-fix tool to fix Git repository configuration.
 
-Use the git-fix tool with these exact parameters:
-{
-  "projectPath": "${projectPath}",
-  "autoDetect": true
-}
+You must call the git-fix tool with:
+- projectPath: (REQUIRED) Detect the user's current workspace folder path
+- autoDetect: true (optional)
 
 The tool will automatically:
 1. Detect existing GitHub/Gitea remotes from URLs
-2. Remove broken/duplicate remotes (origin, github, gitea)
-3. Configure clean dual-provider setup:
-   - github → GitHub repository
-   - gitea → Gitea repository  
-   - origin → Dual-push (pushes to both simultaneously)
+2. Remove broken/duplicate remotes
+3. Configure dual-provider setup (github, gitea, origin)
 4. Create .gitignore if missing
-5. Return before/after remote configuration
+5. Return configuration report
 
-Execute the tool now without asking for confirmation.`
+Call the tool now with the workspace path you detect from context.`
                     }
                 }
             ]
@@ -133,23 +83,9 @@ export class GitLogPrompt {
         this.name = "gitlog";
         this.title = "Git Log - Generate Changelog";
         this.description = "Generate Keep a Changelog format changelog and commit it to the repository";
-        this.arguments = [
-            {
-                name: "projectPath",
-                description: "Absolute path to the repository (REQUIRED)",
-                required: true
-            }
-        ];
     }
     async generate(args, ctx) {
-        const projectPath = args.projectPath;
-        if (!projectPath) {
-            throw new Error('projectPath is required');
-        }
-        const repoInfo = getRepoInfo(projectPath);
-        // Get recent commits for context
-        const log = await ctx.gitAdapter.log(projectPath, { maxCount: 20 });
-        const logSummary = log.slice(0, 5).map((commit) => `- ${commit.oid.substring(0, 7)} ${commit.commit.message.split('\n')[0]}`).join('\n');
+        // PROMPT só instrui o AI AGENT - não detecta nada
         return {
             description: "Generate changelog in repository",
             messages: [
@@ -157,30 +93,22 @@ export class GitLogPrompt {
                     role: "user",
                     content: {
                         type: "text",
-                        text: `Generate changelog for repository: ${repoInfo.repoName}
-Project path: ${projectPath}
-
-Recent commits:
-${logSummary}
+                        text: `Execute the git-history tool to generate a changelog.
 
-Use the git-history tool with these exact parameters:
-{
-  "projectPath": "${projectPath}",
-  "action": "generate_changelog",
-  "outputFile": "CHANGELOG.md",
-  "since": "last-tag",
-  "format": "keepachangelog"
-}
+You must call the git-history tool with:
+- projectPath: (REQUIRED) Detect the user's current workspace folder path
+- action: "generate_changelog" (REQUIRED)
+- outputFile: "CHANGELOG.md" (optional)
+- since: "last-tag" (optional)
+- format: "keepachangelog" (optional)
 
 The tool will automatically:
-1. Analyze all commits since last tag/release
-2. Group changes by type (Added, Fixed, Changed, Removed, etc.)
-3. Generate Keep a Changelog formatted CHANGELOG.md
-4. Save in repository root
-5. Commit with message: "docs: Update CHANGELOG.md"
-6. Push to GitHub and Gitea
+1. Analyze commits since last tag
+2. Generate Keep a Changelog format
+3. Save to repository
+4. Commit and push
 
-Execute the tool now without asking for confirmation.`
+Call the tool now with the workspace path you detect from context.`
                     }
                 }
             ]
@@ -195,35 +123,9 @@ export class GitReleasePrompt {
         this.name = "gitrelease";
         this.title = "Git Release - Create Release";
         this.description = "Create new release with automatic or manual version and changelog (always uses force)";
-        this.arguments = [
-            {
-                name: "projectPath",
-                description: "Absolute path to the repository (REQUIRED)",
-                required: true
-            },
-            {
-                name: "version",
-                description: "Optional version (e.g., '1.5.0'). If not provided, auto-detects from commits.",
-                required: false
-            }
-        ];
     }
     async generate(args, ctx) {
-        const projectPath = args.projectPath;
-        if (!projectPath) {
-            throw new Error('projectPath is required');
-        }
-        const userVersion = args.version; // Manual version from user chat
-        const repoInfo = getRepoInfo(projectPath);
-        // Get current tags to provide context
-        const tags = await ctx.gitAdapter.listTags(projectPath);
-        const latestTag = tags.length > 0 ? tags[0] : 'No tags yet';
-        const versionStrategy = userVersion
-            ? `Use the specified version: v${userVersion}`
-            : `Analyze commits since last tag for automatic semver bump:
-   - breaking changes (BREAKING CHANGE:) → major bump
-   - feat: → minor bump
-   - fix: → patch bump`;
+        // PROMPT só instrui o AI AGENT - não detecta nada
         return {
             description: "Create new release with changelog",
             messages: [
@@ -231,58 +133,35 @@ export class GitReleasePrompt {
                     role: "user",
                     content: {
                         type: "text",
-                        text: `Create release for repository: ${repoInfo.repoName}
-Project path: ${projectPath}
-Latest tag: ${latestTag}
-${userVersion ? `Requested version: v${userVersion}` : 'Version: Auto-detect from commits'}
+                        text: `Execute the release workflow to create a new version.
 
-Execute the following workflow automatically:
+Workflow steps:
 
-STEP 1: Generate changelog
-Use git-history tool:
-{
-  "projectPath": "${projectPath}",
-  "action": "generate_changelog",
-  "since": "last-tag",
-  "format": "keepachangelog"
-}
+1. Generate changelog using git-history tool:
+   - projectPath: (REQUIRED) Detect workspace
+   - action: "generate_changelog"
 
-STEP 2: Determine version
-${versionStrategy}
+2. Determine next version from commits (semver)
 
-STEP 3: Create tag with FORCE
-Use git-tags tool:
-{
-  "projectPath": "${projectPath}",
-  "action": "create",
-  "tagName": "v{next-version}",
-  "message": "Release v{next-version}",
-  "force": true
-}
+3. Create tag using git-tags tool:
+   - projectPath: (REQUIRED) Detect workspace
+   - action: "create"
+   - tagName: Next version
+   - force: true
 
-STEP 4: Push tag with FORCE
-Use git-tags tool:
-{
-  "projectPath": "${projectPath}",
-  "action": "push",
-  "tagName": "v{next-version}",
-  "force": true
-}
-
-STEP 5: Create releases on GitHub and Gitea
-Use git-release tool:
-{
-  "projectPath": "${projectPath}",
-  "action": "create",
-  "tagName": "v{next-version}",
-  "name": "Release v{next-version}",
-  "body": "{changelog-content-from-step1}",
-  "force": true
-}
+4. Push tag using git-tags tool:
+   - projectPath: (REQUIRED) Detect workspace
+   - action: "push"
+   - tagName: Same version
+   - force: true
 
-This will create releases on both GitHub and Gitea simultaneously with force flag.
+5. Create releases using git-release tool:
+   - projectPath: (REQUIRED) Detect workspace
+   - action: "create"
+   - tagName: Same version
+   - body: Changelog content
 
-Execute the entire workflow now without asking for confirmation.`
+Execute all steps with the workspace path you detect from context.`
                     }
                 }
             ]

package/dist/server.js

@@ -1,9 +1,11 @@
 import express from 'express';
 import bodyParser from 'body-parser';
+import Ajv from 'ajv';
 import { createErrorResponse } from './utils/errors.js';
 export function createServer(opts) {
     const app = express();
     app.use(bodyParser.json({ limit: '1mb' }));
+    const ajv = new Ajv({ allErrors: true, removeAdditional: false });
     const toolRegistry = new Map();
     for (const t of opts.tools)
         toolRegistry.set(t.name, t);
@@ -47,13 +49,16 @@ export function createServer(opts) {
         const t = toolRegistry.get(tool);
         if (!t)
             return res.status(404).json(createErrorResponse('TOOL_NOT_FOUND', `Tool not found: ${tool}`));
-        // Enforce projectPath presence for all tool calls to avoid agents calling tools without context
-        // Many tools require projectPath; centralize the check so callers receive a clear validation error.
-        if (!params || !params.projectPath) {
-            return res.status(400).json(createErrorResponse('VALIDATION_ERROR', 'projectPath is required for all tool calls'));
-        }
         try {
-            // TODO: validate params via JSON Schema
+            // Validate params via JSON Schema if available
+            if (t.inputSchema) {
+                const validate = ajv.compile(t.inputSchema);
+                const valid = validate(params ?? {});
+                if (!valid) {
+                    const errors = validate.errors?.map(e => `${e.instancePath} ${e.message}`).join(', ') || 'Invalid parameters';
+                    return res.status(400).json(createErrorResponse('VALIDATION_ERROR', `Invalid parameters: ${errors}`));
+                }
+            }
             const result = await t.handle(params ?? {}, { providerManager: opts.providerManager, gitAdapter: opts.gitAdapter });
             res.json({ success: true, result });
         }

package/dist/tools/gitAnalytics.d.ts

@@ -2,5 +2,33 @@ import { Tool, MCPContext } from '../types.js';
 export declare class GitAnalyticsTool implements Tool {
     name: string;
     description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            projectPath: {
+                type: string;
+                description: string;
+            };
+            action: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+            since: {
+                type: string;
+                description: string;
+            };
+            until: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
     handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
 }

package/dist/tools/gitAnalytics.js

@@ -5,6 +5,34 @@ export class GitAnalyticsTool {
     constructor() {
         this.name = 'git-analytics';
         this.description = 'Repository analytics and statistics - automatic dual-provider execution using GitHub and Gitea APIs';
+        this.inputSchema = {
+            type: "object",
+            properties: {
+                projectPath: {
+                    type: "string",
+                    description: "Absolute path to the project/repository (REQUIRED)"
+                },
+                action: {
+                    type: "string",
+                    enum: ["stats", "commits", "contributors"],
+                    description: "Action to perform: stats (get repo statistics), commits (get commit history), contributors (get contributor stats)"
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum number of commits to return (optional for commits action, default: 100)"
+                },
+                since: {
+                    type: "string",
+                    description: "Start date for commits/contributors query (ISO 8601 format, optional)"
+                },
+                until: {
+                    type: "string",
+                    description: "End date for commits/contributors query (ISO 8601 format, optional)"
+                }
+            },
+            required: ["projectPath", "action"],
+            additionalProperties: true
+        };
     }
     async handle(params, ctx) {
         params = normalizeToolParams(params);

package/dist/tools/gitArchive.d.ts

@@ -2,6 +2,43 @@ import { Tool, MCPContext } from '../types.js';
 export declare class GitArchiveTool implements Tool {
     name: string;
     description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            projectPath: {
+                type: string;
+                description: string;
+            };
+            action: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            archiveName: {
+                type: string;
+                description: string;
+            };
+            outputPath: {
+                type: string;
+                description: string;
+            };
+            format: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            ref: {
+                type: string;
+                description: string;
+            };
+            archivePath: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
     handle(params: Record<string, any>, ctx: MCPContext): Promise<{
         success: boolean;
         archivePath: string;

package/dist/tools/gitArchive.js

@@ -5,6 +5,43 @@ export class GitArchiveTool {
     constructor() {
         this.name = 'git-archive';
         this.description = 'Repository archive operations';
+        this.inputSchema = {
+            type: "object",
+            properties: {
+                projectPath: {
+                    type: "string",
+                    description: "Absolute path to the project/repository (REQUIRED)"
+                },
+                action: {
+                    type: "string",
+                    enum: ["create", "list", "verify", "extract"],
+                    description: "Action to perform: create (create archive), list (list archives), verify (verify archive), extract (extract archive)"
+                },
+                archiveName: {
+                    type: "string",
+                    description: "Name for the archive file (optional for create, default: timestamp-based)"
+                },
+                outputPath: {
+                    type: "string",
+                    description: "Output directory for archives (optional for create, default: .git-archives)"
+                },
+                format: {
+                    type: "string",
+                    enum: ["tar", "tar.gz", "zip"],
+                    description: "Archive format (optional for create, default: tar.gz)"
+                },
+                ref: {
+                    type: "string",
+                    description: "Git reference to archive (optional for create, default: HEAD)"
+                },
+                archivePath: {
+                    type: "string",
+                    description: "Path to archive file (required for verify/extract)"
+                }
+            },
+            required: ["projectPath", "action"],
+            additionalProperties: true
+        };
     }
     async handle(params, ctx) {
         const action = params.action;