@andrebuzeli/git-mcp 10.0.0 → 10.0.1

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;

package/dist/tools/gitIssues.d.ts

@@ -2,5 +2,83 @@ import { Tool, MCPContext } from '../types.js';
 export declare class GitIssuesTool implements Tool {
     name: string;
     description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            projectPath: {
+                type: string;
+                description: string;
+            };
+            action: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            repo: {
+                type: string;
+                description: string;
+            };
+            title: {
+                type: string;
+                description: string;
+            };
+            body: {
+                type: string;
+                description: string;
+            };
+            assignees: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            labels: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            milestone: {
+                type: string;
+                description: string;
+            };
+            issueNumber: {
+                type: string;
+                description: string;
+            };
+            state: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            state_filter: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            direction: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            sort: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            since: {
+                type: string;
+                description: string;
+            };
+            query: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
     handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
 }

package/dist/tools/gitIssues.js

@@ -4,6 +4,80 @@ export class GitIssuesTool {
     constructor() {
         this.name = 'git-issues';
         this.description = 'Issue management for GitHub and Gitea - automatic dual-provider execution';
+        this.inputSchema = {
+            type: "object",
+            properties: {
+                projectPath: {
+                    type: "string",
+                    description: "Absolute path to the project/repository (optional, used to auto-detect repo name)"
+                },
+                action: {
+                    type: "string",
+                    enum: ["create", "list", "get", "update", "close", "comment", "search"],
+                    description: "Action to perform: create (create issue), list (list issues), get (get issue), update (update issue), close (close issue), comment (add comment), search (search issues)"
+                },
+                repo: {
+                    type: "string",
+                    description: "Repository name (required if projectPath not provided)"
+                },
+                title: {
+                    type: "string",
+                    description: "Issue title (required for create)"
+                },
+                body: {
+                    type: "string",
+                    description: "Issue body/description (optional for create/update/comment)"
+                },
+                assignees: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Assignees usernames (optional for create/update)"
+                },
+                labels: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Issue labels (optional for create/update)"
+                },
+                milestone: {
+                    type: "number",
+                    description: "Milestone number (optional for create/update)"
+                },
+                issueNumber: {
+                    type: "number",
+                    description: "Issue number (required for get/update/close/comment)"
+                },
+                state: {
+                    type: "string",
+                    enum: ["open", "closed"],
+                    description: "Issue state (optional for update)"
+                },
+                state_filter: {
+                    type: "string",
+                    enum: ["open", "closed", "all"],
+                    description: "Filter by state (optional for list, default: open)"
+                },
+                direction: {
+                    type: "string",
+                    enum: ["asc", "desc"],
+                    description: "Sort direction (optional for list, default: desc)"
+                },
+                sort: {
+                    type: "string",
+                    enum: ["created", "updated", "comments"],
+                    description: "Sort field (optional for list, default: created)"
+                },
+                since: {
+                    type: "string",
+                    description: "Only issues updated after this time (ISO 8601, optional for list)"
+                },
+                query: {
+                    type: "string",
+                    description: "Search query (required for search action)"
+                }
+            },
+            required: ["action"],
+            additionalProperties: true
+        };
     }
     async handle(params, ctx) {
         params = normalizeToolParams(params);

package/dist/tools/gitMonitor.d.ts

@@ -2,5 +2,29 @@ import { Tool, MCPContext } from '../types.js';
 export declare class GitMonitorTool implements Tool {
     name: string;
     description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            projectPath: {
+                type: string;
+                description: string;
+            };
+            action: {
+                type: string;
+                enum: 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/gitMonitor.js

@@ -6,6 +6,30 @@ export class GitMonitorTool {
     constructor() {
         this.name = 'git-monitor';
         this.description = 'Repository monitoring and status 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: ["log", "status", "commits", "contributors"],
+                    description: "Monitor operation to perform: log (get activity log), status (get repo status), commits (get commit activity), contributors (get contributor activity)"
+                },
+                since: {
+                    type: "string",
+                    description: "Start date for activity query (ISO 8601, optional)"
+                },
+                until: {
+                    type: "string",
+                    description: "End date for activity query (ISO 8601, optional)"
+                }
+            },
+            required: ["projectPath", "action"],
+            additionalProperties: true
+        };
     }
     async handle(params, ctx) {
         const action = params.action;

package/dist/tools/gitUpdate.d.ts

@@ -7,6 +7,52 @@ import { Tool, MCPContext } from '../types.js';
 export declare class GitUpdateTool implements Tool {
     name: string;
     description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            projectPath: {
+                type: string;
+                description: string;
+            };
+            message: {
+                type: string;
+                description: string;
+            };
+            commitMessage: {
+                type: string;
+                description: string;
+            };
+            branch: {
+                type: string;
+                description: string;
+            };
+            files: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            repoName: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
+            private: {
+                type: string;
+                description: string;
+            };
+            owner: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
     handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
     private saveUpdateHistory;
     private createRemoteHistory;

package/dist/tools/gitUpdate.js

@@ -13,6 +13,50 @@ export class GitUpdateTool {
     constructor() {
         this.name = 'git-update';
         this.description = 'Complete project update workflow (add, commit, push) to GitHub and Gitea with full traceability - automatic dual-provider execution';
+        this.inputSchema = {
+            type: "object",
+            properties: {
+                projectPath: {
+                    type: "string",
+                    description: "Absolute path to the project/repository (REQUIRED)"
+                },
+                message: {
+                    type: "string",
+                    description: "Commit message (optional, defaults to timestamp-based message)"
+                },
+                commitMessage: {
+                    type: "string",
+                    description: "Alternative commit message parameter (optional)"
+                },
+                branch: {
+                    type: "string",
+                    description: "Branch to update (optional, default: 'master')"
+                },
+                files: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Files to add and commit (optional, default: ['.'])"
+                },
+                repoName: {
+                    type: "string",
+                    description: "Repository name (optional, auto-detected from projectPath)"
+                },
+                description: {
+                    type: "string",
+                    description: "Repository description for auto-creation (optional)"
+                },
+                private: {
+                    type: "boolean",
+                    description: "Make repository private when auto-creating (optional, default: true)"
+                },
+                owner: {
+                    type: "string",
+                    description: "Repository owner for providers (optional, uses env vars)"
+                }
+            },
+            required: ["projectPath"],
+            additionalProperties: true
+        };
     }
     async handle(params, ctx) {
         const projectPath = params.projectPath;

package/dist/tools/gitUpload.d.ts

@@ -6,6 +6,37 @@ import { Tool, MCPContext } from '../types.js';
 export declare class GitUploadTool implements Tool {
     name: string;
     description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            projectPath: {
+                type: string;
+                description: string;
+            };
+            repoName: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
+            private: {
+                type: string;
+                description: string;
+            };
+            branch: {
+                type: string;
+                description: string;
+            };
+            commitMessage: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
     handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
     private saveUploadHistory;
 }

package/dist/tools/gitUpload.js

@@ -12,6 +12,37 @@ export class GitUploadTool {
     constructor() {
         this.name = 'git-upload';
         this.description = 'Upload complete project to GitHub and Gitea with full traceability - automatic dual-provider execution';
+        this.inputSchema = {
+            type: "object",
+            properties: {
+                projectPath: {
+                    type: "string",
+                    description: "Absolute path to the project/repository (REQUIRED)"
+                },
+                repoName: {
+                    type: "string",
+                    description: "Repository name (optional, auto-detected from projectPath)"
+                },
+                description: {
+                    type: "string",
+                    description: "Repository description (optional, defaults to timestamp-based message)"
+                },
+                private: {
+                    type: "boolean",
+                    description: "Make repository private (optional, default: true)"
+                },
+                branch: {
+                    type: "string",
+                    description: "Branch to upload (optional, default: 'master')"
+                },
+                commitMessage: {
+                    type: "string",
+                    description: "Commit message (optional, defaults to timestamp-based message)"
+                }
+            },
+            required: ["projectPath"],
+            additionalProperties: true
+        };
     }
     async handle(params, ctx) {
         const projectPath = params.projectPath;