@andrebuzeli/git-mcp 6.3.2 → 7.0.1

package/dist/resources/toolsGuide.js

@@ -10,11 +10,31 @@ exports.TOOLS_GUIDE = {
     name: "Git-MCP Tools Complete Guide",
     description: "Detailed documentation and usage instructions for all 20 Git tools with 102 actions",
     mimeType: "text/markdown",
-    content: `# 🛠️ Git-MCP v6.3.1 - Complete Tools Guide
+    content: `# 🛠️ Git-MCP v7.0.0 - Complete Tools Guide
 
 > **Comprehensive documentation for all 21 Git tools with 110+ actions**
-> **Supports:** GitHub, Gitea, and Local Git operations
-> **NEW in v6.3.1:** git-fix tool for dual-provider migration
+> **Supports:** Automatic DUAL execution on GitHub + Gitea APIs
+> **BREAKING CHANGES in v7.0.0:** ALL tools now execute DUAL automatically with env var usernames
+
+---
+
+## 🚀 v7.0.0 MAJOR UPDATE: AUTOMATIC DUAL EXECUTION
+
+**ALL TOOLS NOW:**
+- ✅ Execute on BOTH GitHub and Gitea APIs automatically
+- ✅ Use GITHUB_USERNAME and GITEA_USERNAME from environment variables
+- ✅ Return separated responses: \`{ github: {...}, gitea: {...} }\`
+- ✅ NO manual owner/user/author parameters needed
+- ✅ Each provider uses its own credentials automatically
+
+### Environment Variables Required:
+\\\`\\\`\\\`bash
+GITHUB_TOKEN=your_github_token
+GITHUB_USERNAME=YourGitHubUsername
+GITEA_TOKEN=your_gitea_token
+GITEA_USERNAME=yourGiteaUsername
+GITEA_URL=http://your-gitea-server:port
+\\\`\\\`\\\`
 
 ---
 

package/dist/tools/gitAnalytics.d.ts

@@ -2,28 +2,5 @@ import { Tool, MCPContext } from '../types';
 export declare class GitAnalyticsTool implements Tool {
     name: string;
     description: string;
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
-        success: boolean;
-        stats: {
-            totalCommits: number;
-            branches: number;
-            tags: number;
-            latestCommit: (import("simple-git").DefaultLogFields & import("simple-git").ListLogLine) | null;
-        };
-        commits?: undefined;
-        details?: undefined;
-        contributors?: undefined;
-    } | {
-        success: boolean;
-        commits: number;
-        details: readonly (import("simple-git").DefaultLogFields & import("simple-git").ListLogLine)[];
-        stats?: undefined;
-        contributors?: undefined;
-    } | {
-        success: boolean;
-        contributors: any[];
-        stats?: undefined;
-        commits?: undefined;
-        details?: undefined;
-    }>;
+    handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
 }

package/dist/tools/gitAnalytics.js

@@ -4,65 +4,190 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitAnalyticsTool = void 0;
-const simple_git_1 = __importDefault(require("simple-git"));
 const errors_1 = require("../utils/errors");
+const axios_1 = __importDefault(require("axios"));
+const repoHelpers_1 = require("../utils/repoHelpers");
 class GitAnalyticsTool {
     constructor() {
         this.name = 'git-analytics';
-        this.description = 'Repository analytics and statistics';
+        this.description = 'Repository analytics and statistics - automatic dual-provider execution using GitHub and Gitea APIs';
     }
     async handle(params, ctx) {
         const action = params.action;
         const projectPath = params.projectPath;
-        if (!action || !projectPath) {
-            throw new errors_1.MCPError('VALIDATION_ERROR', 'action and projectPath are required');
-        }
-        const git = (0, simple_git_1.default)({ baseDir: projectPath });
+        if (!action)
+            throw new errors_1.MCPError('VALIDATION_ERROR', 'action is required');
+        if (!projectPath)
+            throw new errors_1.MCPError('VALIDATION_ERROR', 'projectPath is required');
+        // Auto-extract repo info from projectPath
+        const repoInfo = (0, repoHelpers_1.getRepoInfo)(projectPath);
+        const repo = repoInfo.repoName;
+        // Each provider uses its own username from env
+        const githubOwner = process.env.GITHUB_USERNAME;
+        const giteaOwner = process.env.GITEA_USERNAME;
         switch (action) {
             case 'stats': {
-                const log = await git.log();
-                const branches = await git.branch();
-                const tags = await git.tags();
-                return {
-                    success: true,
-                    stats: {
-                        totalCommits: log.total,
-                        branches: branches.all.length,
-                        tags: tags.all.length,
-                        latestCommit: log.latest,
-                    },
-                };
+                const results = { success: true, providers: {} };
+                // GitHub API
+                if (ctx.providerManager.github && githubOwner) {
+                    try {
+                        const repoData = await ctx.providerManager.github.rest.repos.get({
+                            owner: githubOwner,
+                            repo: repo,
+                        });
+                        const branches = await ctx.providerManager.github.rest.repos.listBranches({
+                            owner: githubOwner,
+                            repo: repo,
+                        });
+                        const tags = await ctx.providerManager.github.rest.repos.listTags({
+                            owner: githubOwner,
+                            repo: repo,
+                        });
+                        const commits = await ctx.providerManager.github.rest.repos.listCommits({
+                            owner: githubOwner,
+                            repo: repo,
+                            per_page: 1,
+                        });
+                        results.providers.github = {
+                            success: true,
+                            stats: {
+                                totalCommits: repoData.data.size,
+                                branches: branches.data.length,
+                                tags: tags.data.length,
+                                defaultBranch: repoData.data.default_branch,
+                                latestCommit: commits.data[0] || null,
+                                size: repoData.data.size,
+                                language: repoData.data.language,
+                                stars: repoData.data.stargazers_count,
+                                forks: repoData.data.forks_count,
+                                openIssues: repoData.data.open_issues_count,
+                            },
+                        };
+                    }
+                    catch (err) {
+                        results.providers.github = { success: false, error: err.message };
+                    }
+                }
+                // Gitea API
+                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
+                    try {
+                        const repoData = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        const branches = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/branches`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        const tags = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/tags`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        const commits = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/commits`, {
+                            params: { limit: 1 },
+                            headers: { Authorization: `token ${ctx.providerManager.giteaToken}` }
+                        });
+                        results.providers.gitea = {
+                            success: true,
+                            stats: {
+                                totalCommits: repoData.data.size,
+                                branches: branches.data.length,
+                                tags: tags.data.length,
+                                defaultBranch: repoData.data.default_branch,
+                                latestCommit: commits.data[0] || null,
+                                size: repoData.data.size,
+                                language: repoData.data.language,
+                                stars: repoData.data.stars_count,
+                                forks: repoData.data.forks_count,
+                                openIssues: repoData.data.open_issues_count,
+                            },
+                        };
+                    }
+                    catch (err) {
+                        results.providers.gitea = { success: false, error: err.message };
+                    }
+                }
+                return results;
             }
             case 'commits': {
-                const since = params.since;
-                const until = params.until;
-                const log = await git.log({
-                    from: since,
-                    to: until,
-                    maxCount: params.limit || 1000,
-                });
-                return {
-                    success: true,
-                    commits: log.all.length,
-                    details: log.all,
-                };
+                const results = { success: true, providers: {} };
+                // GitHub API
+                if (ctx.providerManager.github && githubOwner) {
+                    try {
+                        const commits = await ctx.providerManager.github.rest.repos.listCommits({
+                            owner: githubOwner,
+                            repo: repo,
+                            since: params.since,
+                            until: params.until,
+                            per_page: params.limit || 100,
+                        });
+                        results.providers.github = {
+                            success: true,
+                            commits: commits.data.length,
+                            details: commits.data,
+                        };
+                    }
+                    catch (err) {
+                        results.providers.github = { success: false, error: err.message };
+                    }
+                }
+                // Gitea API
+                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
+                    try {
+                        const commits = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/commits`, {
+                            params: {
+                                since: params.since,
+                                until: params.until,
+                                limit: params.limit || 100,
+                            },
+                            headers: { Authorization: `token ${ctx.providerManager.giteaToken}` }
+                        });
+                        results.providers.gitea = {
+                            success: true,
+                            commits: commits.data.length,
+                            details: commits.data,
+                        };
+                    }
+                    catch (err) {
+                        results.providers.gitea = { success: false, error: err.message };
+                    }
+                }
+                return results;
             }
             case 'contributors': {
-                const log = await git.log();
-                const contributors = new Map();
-                log.all.forEach(commit => {
-                    const author = commit.author_name;
-                    if (contributors.has(author)) {
-                        contributors.get(author).count++;
+                const results = { success: true, providers: {} };
+                // GitHub API
+                if (ctx.providerManager.github && githubOwner) {
+                    try {
+                        const contributors = await ctx.providerManager.github.rest.repos.listContributors({
+                            owner: githubOwner,
+                            repo: repo,
+                            per_page: 100,
+                        });
+                        results.providers.github = {
+                            success: true,
+                            contributors: contributors.data.map((c) => ({
+                                login: c.login,
+                                name: c.login,
+                                contributions: c.contributions,
+                                avatar_url: c.avatar_url,
+                            })),
+                        };
+                    }
+                    catch (err) {
+                        results.providers.github = { success: false, error: err.message };
+                    }
+                }
+                // Gitea API
+                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
+                    try {
+                        const contributors = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/contributors`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        results.providers.gitea = {
+                            success: true,
+                            contributors: contributors.data.map((c) => ({
+                                login: c.login,
+                                name: c.name || c.login,
+                                contributions: c.contributions,
+                                avatar_url: c.avatar_url,
+                            })),
+                        };
                     }
-                    else {
-                        contributors.set(author, { name: author, email: commit.author_email, count: 1 });
+                    catch (err) {
+                        results.providers.gitea = { success: false, error: err.message };
                     }
-                });
-                return {
-                    success: true,
-                    contributors: Array.from(contributors.values()).sort((a, b) => b.count - a.count),
-                };
+                }
+                return results;
             }
             default:
                 throw new errors_1.MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);

package/dist/tools/gitArchive.js

@@ -5,7 +5,7 @@ const errors_1 = require("../utils/errors");
 class GitArchiveTool {
     constructor() {
         this.name = 'git-archive';
-        this.description = 'Repository archive operations';
+        this.description = 'Repository archive operations - local operations';
     }
     async handle(params, ctx) {
         const action = params.action;

package/dist/tools/gitBackup.js

@@ -9,7 +9,7 @@ const errors_1 = require("../utils/errors");
 class GitBackupTool {
     constructor() {
         this.name = 'git-backup';
-        this.description = 'Repository backup and restore operations';
+        this.description = 'Repository backup and restore operations - local operations';
     }
     async handle(params, ctx) {
         const action = params.action;

package/dist/tools/gitBranches.d.ts

@@ -2,71 +2,5 @@ import { Tool, MCPContext } from '../types';
 export declare class GitBranchesTool implements Tool {
     name: string;
     description: string;
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
-        success: boolean;
-        branch: any;
-        branches?: undefined;
-        current?: undefined;
-        deleted?: undefined;
-        result?: undefined;
-        baseBranch?: undefined;
-        compareBranch?: undefined;
-        commits?: undefined;
-        diff?: undefined;
-    } | {
-        branches: string[];
-        current: string;
-        success?: undefined;
-        branch?: undefined;
-        deleted?: undefined;
-        result?: undefined;
-        baseBranch?: undefined;
-        compareBranch?: undefined;
-        commits?: undefined;
-        diff?: undefined;
-    } | {
-        success: boolean;
-        branch: string;
-        current: boolean;
-        branches?: undefined;
-        deleted?: undefined;
-        result?: undefined;
-        baseBranch?: undefined;
-        compareBranch?: undefined;
-        commits?: undefined;
-        diff?: undefined;
-    } | {
-        success: boolean;
-        deleted: any;
-        branch?: undefined;
-        branches?: undefined;
-        current?: undefined;
-        result?: undefined;
-        baseBranch?: undefined;
-        compareBranch?: undefined;
-        commits?: undefined;
-        diff?: undefined;
-    } | {
-        success: boolean;
-        result: import("simple-git").MergeResult;
-        branch?: undefined;
-        branches?: undefined;
-        current?: undefined;
-        deleted?: undefined;
-        baseBranch?: undefined;
-        compareBranch?: undefined;
-        commits?: undefined;
-        diff?: undefined;
-    } | {
-        success: boolean;
-        baseBranch: any;
-        compareBranch: any;
-        commits: readonly (import("simple-git").DefaultLogFields & import("simple-git").ListLogLine)[];
-        diff: string;
-        branch?: undefined;
-        branches?: undefined;
-        current?: undefined;
-        deleted?: undefined;
-        result?: undefined;
-    }>;
+    handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
 }

package/dist/tools/gitBranches.js

@@ -7,10 +7,12 @@ exports.GitBranchesTool = void 0;
 const simple_git_1 = __importDefault(require("simple-git"));
 const errors_1 = require("../utils/errors");
 const safetyController_1 = require("../utils/safetyController");
+const repoHelpers_1 = require("../utils/repoHelpers");
+const axios_1 = __importDefault(require("axios"));
 class GitBranchesTool {
     constructor() {
         this.name = 'git-branches';
-        this.description = 'Branch management operations';
+        this.description = 'Branch management operations - automatic dual-provider execution for remote queries';
     }
     async handle(params, ctx) {
         const action = params.action;
@@ -32,14 +34,60 @@ class GitBranchesTool {
                 if (params.checkout !== false) {
                     await git.checkout(branchName);
                 }
-                return { success: true, branch: branchName };
+                return { success: true, branch: branchName, local: true };
             }
             case 'list': {
-                const branches = await git.branch();
-                return {
-                    branches: branches.all,
-                    current: branches.current,
+                const localBranches = await git.branch();
+                const results = {
+                    success: true,
+                    local: {
+                        branches: localBranches.all,
+                        current: localBranches.current,
+                    },
+                    providers: {}
                 };
+                // Also query remote APIs
+                const repoInfo = (0, repoHelpers_1.getRepoInfo)(projectPath);
+                const githubOwner = process.env.GITHUB_USERNAME;
+                const giteaOwner = process.env.GITEA_USERNAME;
+                // GitHub
+                if (ctx.providerManager.github && githubOwner) {
+                    try {
+                        const branches = await ctx.providerManager.github.rest.repos.listBranches({
+                            owner: githubOwner,
+                            repo: repoInfo.repoName,
+                        });
+                        results.providers.github = {
+                            success: true,
+                            branches: branches.data.map((b) => ({
+                                name: b.name,
+                                protected: b.protected,
+                                sha: b.commit.sha,
+                            })),
+                        };
+                    }
+                    catch (err) {
+                        results.providers.github = { success: false, error: err.message };
+                    }
+                }
+                // Gitea
+                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
+                    try {
+                        const branches = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repoInfo.repoName}/branches`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        results.providers.gitea = {
+                            success: true,
+                            branches: branches.data.map((b) => ({
+                                name: b.name,
+                                protected: b.protected,
+                                sha: b.commit.id,
+                            })),
+                        };
+                    }
+                    catch (err) {
+                        results.providers.gitea = { success: false, error: err.message };
+                    }
+                }
+                return results;
             }
             case 'get': {
                 const branchName = params.branchName;
@@ -47,13 +95,56 @@ class GitBranchesTool {
                     throw new errors_1.MCPError('VALIDATION_ERROR', 'branchName is required');
                 const branches = await git.branch();
                 const branch = branches.all.find(b => b === branchName);
-                if (!branch) {
-                    throw new errors_1.MCPError('BRANCH_NOT_FOUND', `Branch '${branchName}' not found`, [
-                        'Check if the branch name is correct',
-                        'Use git branch -a to see all available branches',
-                    ]);
+                const results = {
+                    success: true,
+                    local: branch ? { branch, current: branches.current === branchName } : { found: false },
+                    providers: {}
+                };
+                // Also query remote APIs
+                const repoInfo = (0, repoHelpers_1.getRepoInfo)(projectPath);
+                const githubOwner = process.env.GITHUB_USERNAME;
+                const giteaOwner = process.env.GITEA_USERNAME;
+                // GitHub
+                if (ctx.providerManager.github && githubOwner) {
+                    try {
+                        const branchData = await ctx.providerManager.github.rest.repos.getBranch({
+                            owner: githubOwner,
+                            repo: repoInfo.repoName,
+                            branch: branchName,
+                        });
+                        results.providers.github = {
+                            success: true,
+                            branch: {
+                                name: branchData.data.name,
+                                protected: branchData.data.protected,
+                                sha: branchData.data.commit.sha,
+                                commit: branchData.data.commit,
+                            },
+                        };
+                    }
+                    catch (err) {
+                        results.providers.github = { success: false, error: err.message };
+                    }
+                }
+                // Gitea
+                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
+                    try {
+                        const branchData = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repoInfo.repoName}/branches/${branchName}`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        results.providers.gitea = {
+                            success: true,
+                            branch: {
+                                name: branchData.data.name,
+                                protected: branchData.data.protected,
+                                sha: branchData.data.commit.id,
+                                commit: branchData.data.commit,
+                            },
+                        };
+                    }
+                    catch (err) {
+                        results.providers.gitea = { success: false, error: err.message };
+                    }
                 }
-                return { success: true, branch, current: branches.current === branchName };
+                return results;
             }
             case 'delete': {
                 (0, safetyController_1.requireConfirmationIfDestructive)('delete', params);
@@ -61,7 +152,7 @@ class GitBranchesTool {
                 if (!branchName)
                     throw new errors_1.MCPError('VALIDATION_ERROR', 'branchName is required');
                 await git.deleteLocalBranch(branchName, params.force);
-                return { success: true, deleted: branchName };
+                return { success: true, deleted: branchName, local: true };
             }
             case 'merge': {
                 const branchName = params.branchName;
@@ -72,7 +163,7 @@ class GitBranchesTool {
                     await git.checkout(targetBranch);
                 }
                 const result = await git.merge([branchName]);
-                return { success: true, result };
+                return { success: true, result, local: true };
             }
             case 'compare': {
                 const baseBranch = params.baseBranch;
@@ -82,13 +173,54 @@ class GitBranchesTool {
                 }
                 const diff = await git.diff([`${baseBranch}...${compareBranch}`]);
                 const log = await git.log({ from: baseBranch, to: compareBranch });
-                return {
+                const results = {
                     success: true,
-                    baseBranch,
-                    compareBranch,
-                    commits: log.all,
-                    diff,
+                    local: {
+                        baseBranch,
+                        compareBranch,
+                        commits: log.all,
+                        diff,
+                    },
+                    providers: {}
                 };
+                // Also compare on remote APIs
+                const repoInfo = (0, repoHelpers_1.getRepoInfo)(projectPath);
+                const githubOwner = process.env.GITHUB_USERNAME;
+                const giteaOwner = process.env.GITEA_USERNAME;
+                // GitHub
+                if (ctx.providerManager.github && githubOwner) {
+                    try {
+                        const comparison = await ctx.providerManager.github.rest.repos.compareCommits({
+                            owner: githubOwner,
+                            repo: repoInfo.repoName,
+                            base: baseBranch,
+                            head: compareBranch,
+                        });
+                        results.providers.github = {
+                            success: true,
+                            comparison: {
+                                status: comparison.data.status,
+                                ahead_by: comparison.data.ahead_by,
+                                behind_by: comparison.data.behind_by,
+                                total_commits: comparison.data.total_commits,
+                                commits: comparison.data.commits.map((c) => ({
+                                    sha: c.sha,
+                                    message: c.commit.message,
+                                    author: c.commit.author.name,
+                                    date: c.commit.author.date,
+                                })),
+                            },
+                        };
+                    }
+                    catch (err) {
+                        results.providers.github = { success: false, error: err.message };
+                    }
+                }
+                // Gitea - comparison API might not be available
+                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
+                    results.providers.gitea = { success: false, error: 'Comparison API not available in Gitea' };
+                }
+                return results;
             }
             default:
                 throw new errors_1.MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);

package/dist/tools/gitConfig.js

@@ -9,7 +9,7 @@ const errors_1 = require("../utils/errors");
 class GitConfigTool {
     constructor() {
         this.name = 'git-config';
-        this.description = 'Git configuration management';
+        this.description = 'Git configuration management - local Git operations';
     }
     async handle(params, ctx) {
         const action = params.action;

package/dist/tools/gitFiles.js

@@ -10,7 +10,7 @@ const errors_1 = require("../utils/errors");
 class GitFilesTool {
     constructor() {
         this.name = 'git-files';
-        this.description = 'Read-only file operations for repositories';
+        this.description = 'Read-only file operations for repositories - local operations only';
     }
     async handle(params) {
         const action = params.action;

package/dist/tools/gitIssues.js

@@ -6,7 +6,7 @@ const repoHelpers_1 = require("../utils/repoHelpers");
 class GitIssuesTool {
     constructor() {
         this.name = 'git-issues';
-        this.description = 'Issue management for GitHub and Gitea';
+        this.description = 'Issue management for GitHub and Gitea - automatic dual-provider execution';
     }
     async handle(params, ctx) {
         const action = params.action;