@andrebuzeli/git-mcp 10.0.0 → 10.0.1

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/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);
@@ -53,7 +55,15 @@ export function createServer(opts) {
             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;

package/dist/tools/gitBackup.d.ts

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

package/dist/tools/gitBackup.js

@@ -6,6 +6,38 @@ export class GitBackupTool {
     constructor() {
         this.name = 'git-backup';
         this.description = 'Repository backup and restore operations';
+        this.inputSchema = {
+            type: "object",
+            properties: {
+                projectPath: {
+                    type: "string",
+                    description: "Absolute path to the project/repository (REQUIRED)"
+                },
+                action: {
+                    type: "string",
+                    enum: ["backup", "list", "verify", "restore"],
+                    description: "Action to perform: backup (create backup), list (list backups), verify (verify backup), restore (restore from backup)"
+                },
+                backupPath: {
+                    type: "string",
+                    description: "Path to backup file (required for restore/verify)"
+                },
+                compress: {
+                    type: "boolean",
+                    description: "Compress backup (optional for backup, default: true)"
+                },
+                confirm: {
+                    type: "boolean",
+                    description: "Confirm destructive operations (optional for restore)"
+                },
+                name: {
+                    type: "string",
+                    description: "Backup name (optional for backup)"
+                }
+            },
+            required: ["projectPath", "action"],
+            additionalProperties: true
+        };
     }
     async handle(params, ctx) {
         const action = params.action;

package/dist/tools/gitBranches.d.ts

@@ -2,5 +2,53 @@ import { Tool, MCPContext } from '../types.js';
 export declare class GitBranchesTool implements Tool {
     name: string;
     description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            projectPath: {
+                type: string;
+                description: string;
+            };
+            action: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            branchName: {
+                type: string;
+                description: string;
+            };
+            checkout: {
+                type: string;
+                description: string;
+            };
+            sourceBranch: {
+                type: string;
+                description: string;
+            };
+            confirm: {
+                type: string;
+                description: string;
+            };
+            force: {
+                type: string;
+                description: string;
+            };
+            targetBranch: {
+                type: string;
+                description: string;
+            };
+            baseBranch: {
+                type: string;
+                description: string;
+            };
+            compareBranch: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
     handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
 }

package/dist/tools/gitBranches.js

@@ -7,6 +7,54 @@ export class GitBranchesTool {
     constructor() {
         this.name = 'git-branches';
         this.description = 'Branch management operations - automatic dual-provider execution for remote queries';
+        this.inputSchema = {
+            type: "object",
+            properties: {
+                projectPath: {
+                    type: "string",
+                    description: "Absolute path to the project/repository (REQUIRED)"
+                },
+                action: {
+                    type: "string",
+                    enum: ["create", "list", "get", "delete", "merge", "compare"],
+                    description: "Action to perform: create (create branch), list (list branches), get (get branch info), delete (delete branch), merge (merge branches), compare (compare branches)"
+                },
+                branchName: {
+                    type: "string",
+                    description: "Branch name (required for create/get/delete/merge)"
+                },
+                checkout: {
+                    type: "boolean",
+                    description: "Checkout after creating branch (optional for create, default: true)"
+                },
+                sourceBranch: {
+                    type: "string",
+                    description: "Source branch to create from (optional for create)"
+                },
+                confirm: {
+                    type: "boolean",
+                    description: "Confirm destructive operations (optional for delete)"
+                },
+                force: {
+                    type: "boolean",
+                    description: "Force delete branch (optional for delete)"
+                },
+                targetBranch: {
+                    type: "string",
+                    description: "Target branch for merge (optional for merge)"
+                },
+                baseBranch: {
+                    type: "string",
+                    description: "Base branch for comparison (required for compare)"
+                },
+                compareBranch: {
+                    type: "string",
+                    description: "Branch to compare against base (required for compare)"
+                }
+            },
+            required: ["projectPath", "action"],
+            additionalProperties: true
+        };
     }
     async handle(params, ctx) {
         const action = params.action;

package/dist/tools/gitConfig.d.ts

@@ -2,6 +2,42 @@ import { Tool, MCPContext } from '../types.js';
 export declare class GitConfigTool implements Tool {
     name: string;
     description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            action: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            projectPath: {
+                type: string;
+                description: string;
+            };
+            global: {
+                type: string;
+                description: string;
+            };
+            system: {
+                type: string;
+                description: string;
+            };
+            key: {
+                type: string;
+                description: string;
+            };
+            value: {
+                type: string;
+                description: string;
+            };
+            showScope: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
     handle(params: Record<string, any>, ctx: MCPContext): Promise<{
         success: boolean;
         key: any;

package/dist/tools/gitConfig.js

@@ -6,6 +6,42 @@ export class GitConfigTool {
     constructor() {
         this.name = 'git-config';
         this.description = 'Git configuration management - local Git operations';
+        this.inputSchema = {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: ["get", "set", "unset", "list", "show", "edit"],
+                    description: "Configuration operation to perform"
+                },
+                projectPath: {
+                    type: "string",
+                    description: "Absolute path to the Git repository"
+                },
+                global: {
+                    type: "boolean",
+                    description: "Use global configuration scope (optional, default: false)"
+                },
+                system: {
+                    type: "boolean",
+                    description: "Use system configuration scope (optional, default: false)"
+                },
+                key: {
+                    type: "string",
+                    description: "Configuration key name (e.g., 'user.name', 'user.email') - required for get, set, unset, show"
+                },
+                value: {
+                    type: "string",
+                    description: "Configuration value to set - required for set action"
+                },
+                showScope: {
+                    type: "boolean",
+                    description: "Include configuration scope in show action response (optional, default: false)"
+                }
+            },
+            required: ["projectPath", "action"],
+            additionalProperties: true
+        };
     }
     async handle(params, ctx) {
         const action = params.action;

package/dist/tools/gitFiles.d.ts

@@ -2,6 +2,57 @@ import { Tool } from '../types.js';
 export declare class GitFilesTool implements Tool {
     name: string;
     description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            action: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            projectPath: {
+                type: string;
+                description: string;
+            };
+            filePath: {
+                type: string;
+                description: string;
+            };
+            directoryPath: {
+                type: string;
+                description: string;
+            };
+            content: {
+                type: string;
+                description: string;
+            };
+            comment: {
+                type: string;
+                description: string;
+            };
+            patterns: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            searchText: {
+                type: string;
+                description: string;
+            };
+            query: {
+                type: string;
+                description: string;
+            };
+            searchPath: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
     handle(params: Record<string, any>): Promise<{
         success: boolean;
         path: string;

package/dist/tools/gitFiles.js

@@ -5,6 +5,55 @@ export class GitFilesTool {
     constructor() {
         this.name = 'git-files';
         this.description = 'Read-only file operations for repositories - local operations only';
+        this.inputSchema = {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: ["read", "list", "create", "update", "delete", "search"],
+                    description: "File operation to perform"
+                },
+                projectPath: {
+                    type: "string",
+                    description: "Absolute path to the project directory"
+                },
+                filePath: {
+                    type: "string",
+                    description: "Relative path to the file within projectPath - required for read, create, update, delete"
+                },
+                directoryPath: {
+                    type: "string",
+                    description: "Relative path to directory for listing - optional, defaults to projectPath root"
+                },
+                content: {
+                    type: "string",
+                    description: "File content to write - required for create and update actions"
+                },
+                comment: {
+                    type: "string",
+                    description: "Comment to add when appending patterns to .gitignore - optional for add action"
+                },
+                patterns: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Array of file patterns - required for add and remove actions"
+                },
+                searchText: {
+                    type: "string",
+                    description: "Text to search for in files - required for search action"
+                },
+                query: {
+                    type: "string",
+                    description: "Alternative name for searchText - required for search action"
+                },
+                searchPath: {
+                    type: "string",
+                    description: "Relative path to search within - optional for search, defaults to projectPath root"
+                }
+            },
+            required: ["projectPath", "action"],
+            additionalProperties: true
+        };
     }
     async handle(params) {
         const action = params.action;

package/dist/tools/gitFix.tool.d.ts

@@ -2,6 +2,29 @@ import { Tool } from '../types.js';
 export declare class GitFixTool implements Tool {
     name: string;
     description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            projectPath: {
+                type: string;
+                description: string;
+            };
+            githubRepo: {
+                type: string;
+                description: string;
+            };
+            giteaRepo: {
+                type: string;
+                description: string;
+            };
+            autoDetect: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
     handle(args: any): Promise<{
         content: any[];
     }>;