@andrebuzeli/git-mcp 10.0.0 → 10.0.2

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 (REQUIRED)"
+                },
+                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 (REQUIRED)"
+                },
+                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[];
     }>;

package/dist/tools/gitFix.tool.js

@@ -62,6 +62,29 @@ export class GitFixTool {
 - GITEA_URL env var (default: http://nas-ubuntu:9999)
 - Git must be installed and accessible
 `;
+        this.inputSchema = {
+            type: "object",
+            properties: {
+                projectPath: {
+                    type: "string",
+                    description: "Absolute path to the Git repository (REQUIRED)"
+                },
+                githubRepo: {
+                    type: "string",
+                    description: "GitHub repo in format 'owner/repo' (optional, auto-detected)"
+                },
+                giteaRepo: {
+                    type: "string",
+                    description: "Gitea repo in format 'owner/repo' (optional, auto-detected)"
+                },
+                autoDetect: {
+                    type: "boolean",
+                    description: "Auto-detect repos from existing remotes (optional, default: true)"
+                }
+            },
+            required: ["projectPath"],
+            additionalProperties: true
+        };
     }
     async handle(args) {
         return handleGitFix(args);

package/dist/tools/gitHistory.d.ts

@@ -7,6 +7,53 @@ import { Tool, MCPContext } from '../types.js';
 export declare class GitHistoryTool implements Tool {
     name: string;
     description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            action: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            projectPath: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
+            message: {
+                type: string;
+                description: string;
+            };
+            title: {
+                type: string;
+                description: string;
+            };
+            tags: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            category: {
+                type: string;
+                description: string;
+            };
+            owner: {
+                type: string;
+                description: string;
+            };
+            repo: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
     handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
     private trackChange;
     private listLocalHistory;

package/dist/tools/gitHistory.js

@@ -13,6 +13,51 @@ export class GitHistoryTool {
     constructor() {
         this.name = 'git-history';
         this.description = 'Maintain detailed history of all project changes with remote tracking via issues - automatic dual-provider execution';
+        this.inputSchema = {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: ["track", "list", "sync", "report"],
+                    description: "History operation to perform"
+                },
+                projectPath: {
+                    type: "string",
+                    description: "Absolute path to the Git repository"
+                },
+                description: {
+                    type: "string",
+                    description: "Description of the change being tracked - optional for track action"
+                },
+                message: {
+                    type: "string",
+                    description: "Alternative name for description - optional for track action"
+                },
+                title: {
+                    type: "string",
+                    description: "Custom title for the history issue - optional for track action"
+                },
+                tags: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Tags to categorize the change - optional for track action"
+                },
+                category: {
+                    type: "string",
+                    description: "Category of the change (e.g., 'feature', 'bugfix', 'refactor') - optional for track action, default: 'general'"
+                },
+                owner: {
+                    type: "string",
+                    description: "Repository owner username - optional, uses env vars if not provided"
+                },
+                repo: {
+                    type: "string",
+                    description: "Repository name - optional, auto-detected from projectPath"
+                }
+            },
+            required: ["projectPath", "action"],
+            additionalProperties: true
+        };
     }
     async handle(params, ctx) {
         const projectPath = params.projectPath;

package/dist/tools/gitIgnore.d.ts

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

package/dist/tools/gitIgnore.js

@@ -9,6 +9,39 @@ export class GitIgnoreTool {
     constructor() {
         this.name = 'git-ignore';
         this.description = 'Manage .gitignore file - create, add, remove, and update ignore patterns';
+        this.inputSchema = {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: ["read", "create", "ensure", "add", "remove", "update", "clear"],
+                    description: "Git ignore operation to perform"
+                },
+                projectPath: {
+                    type: "string",
+                    description: "Absolute path to the Git repository"
+                },
+                template: {
+                    type: "string",
+                    description: "Template to use for creating .gitignore (e.g., 'default', 'node', 'python') - optional for create, ensure, clear"
+                },
+                patterns: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Array of file patterns to add or remove - required for add and remove actions"
+                },
+                comment: {
+                    type: "string",
+                    description: "Comment to add before patterns - optional for add action"
+                },
+                content: {
+                    type: "string",
+                    description: "Complete .gitignore content to write - required for update action"
+                }
+            },
+            required: ["projectPath", "action"],
+            additionalProperties: true
+        };
     }
     async handle(params, ctx) {
         const projectPath = params.projectPath;