@andrebuzeli/git-mcp 6.3.2 → 7.0.0

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/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/gitMonitor.d.ts

@@ -2,50 +2,5 @@ import { Tool, MCPContext } from '../types';
 export declare class GitMonitorTool implements Tool {
     name: string;
     description: string;
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
-        success: boolean;
-        commits: readonly (import("simple-git").DefaultLogFields & import("simple-git").ListLogLine)[];
-        total: number;
-        status?: undefined;
-        contributors?: undefined;
-    } | {
-        success: boolean;
-        status: import("simple-git").StatusResult | {
-            branch: string | null;
-            ahead: number;
-            behind: number;
-            staged: string[];
-            modified: string[];
-            deleted: string[];
-            created: string[];
-            renamed: import("simple-git").StatusResultRenamed[];
-            conflicted: string[];
-            not_added: string[];
-        };
-        commits?: undefined;
-        total?: undefined;
-        contributors?: undefined;
-    } | {
-        success: boolean;
-        commits: {
-            hash: string;
-            date: string;
-            message: string;
-            author: string;
-            email: string;
-        }[];
-        total?: undefined;
-        status?: undefined;
-        contributors?: undefined;
-    } | {
-        success: boolean;
-        contributors: {
-            name: string;
-            email: string;
-            commits: number;
-        }[];
-        commits?: undefined;
-        total?: undefined;
-        status?: undefined;
-    }>;
+    handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
 }

package/dist/tools/gitMonitor.js

@@ -6,10 +6,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitMonitorTool = void 0;
 const simple_git_1 = __importDefault(require("simple-git"));
 const errors_1 = require("../utils/errors");
+const repoHelpers_1 = require("../utils/repoHelpers");
+const axios_1 = __importDefault(require("axios"));
 class GitMonitorTool {
     constructor() {
         this.name = 'git-monitor';
-        this.description = 'Repository monitoring and status operations';
+        this.description = 'Repository monitoring and status operations - automatic dual-provider execution for remote queries';
     }
     async handle(params, ctx) {
         const action = params.action;
@@ -30,11 +32,72 @@ class GitMonitorTool {
                 if (params.author)
                     options.author = params.author;
                 const log = await git.log(options);
-                return {
+                const results = {
                     success: true,
-                    commits: log.all,
-                    total: log.total,
+                    local: {
+                        commits: log.all,
+                        total: log.total,
+                    },
+                    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 commits = await ctx.providerManager.github.rest.repos.listCommits({
+                            owner: githubOwner,
+                            repo: repoInfo.repoName,
+                            since: params.since,
+                            until: params.until,
+                            per_page: params.limit || 10,
+                        });
+                        results.providers.github = {
+                            success: true,
+                            commits: commits.data.map((c) => ({
+                                sha: c.sha,
+                                message: c.commit.message,
+                                author: c.commit.author.name,
+                                email: c.commit.author.email,
+                                date: c.commit.author.date,
+                                url: c.html_url,
+                            })),
+                        };
+                    }
+                    catch (err) {
+                        results.providers.github = { success: false, error: err.message };
+                    }
+                }
+                // Gitea
+                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
+                    try {
+                        const commits = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repoInfo.repoName}/commits`, {
+                            params: {
+                                since: params.since,
+                                until: params.until,
+                                limit: params.limit || 10,
+                            },
+                            headers: { Authorization: `token ${ctx.providerManager.giteaToken}` }
+                        });
+                        results.providers.gitea = {
+                            success: true,
+                            commits: commits.data.map((c) => ({
+                                sha: c.sha,
+                                message: c.commit.message,
+                                author: c.commit.author.name,
+                                email: c.commit.author.email,
+                                date: c.commit.author.date,
+                                url: c.html_url,
+                            })),
+                        };
+                    }
+                    catch (err) {
+                        results.providers.gitea = { success: false, error: err.message };
+                    }
+                }
+                return results;
             }
             case 'status': {
                 const status = await git.status();
@@ -50,7 +113,7 @@ class GitMonitorTool {
                     conflicted: status.conflicted,
                     not_added: status.not_added,
                 } : status;
-                return { success: true, status: detailed };
+                return { success: true, local: { status: detailed } };
             }
             case 'commits': {
                 const branch = params.branch;
@@ -64,16 +127,75 @@ class GitMonitorTool {
                 if (params.author)
                     options.author = params.author;
                 const log = await git.log(options);
-                return {
+                const results = {
                     success: true,
-                    commits: log.all.map(c => ({
-                        hash: c.hash,
-                        date: c.date,
-                        message: c.message,
-                        author: c.author_name,
-                        email: c.author_email,
-                    })),
+                    local: {
+                        commits: log.all.map(c => ({
+                            hash: c.hash,
+                            date: c.date,
+                            message: c.message,
+                            author: c.author_name,
+                            email: c.author_email,
+                        })),
+                    },
+                    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 commits = await ctx.providerManager.github.rest.repos.listCommits({
+                            owner: githubOwner,
+                            repo: repoInfo.repoName,
+                            sha: branch,
+                            since: params.since,
+                            per_page: params.limit || 50,
+                        });
+                        results.providers.github = {
+                            success: true,
+                            commits: commits.data.map((c) => ({
+                                sha: c.sha,
+                                message: c.commit.message,
+                                author: c.commit.author.name,
+                                email: c.commit.author.email,
+                                date: c.commit.author.date,
+                            })),
+                        };
+                    }
+                    catch (err) {
+                        results.providers.github = { success: false, error: err.message };
+                    }
+                }
+                // Gitea
+                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
+                    try {
+                        const commits = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repoInfo.repoName}/commits`, {
+                            params: {
+                                sha: branch,
+                                since: params.since,
+                                limit: params.limit || 50,
+                            },
+                            headers: { Authorization: `token ${ctx.providerManager.giteaToken}` }
+                        });
+                        results.providers.gitea = {
+                            success: true,
+                            commits: commits.data.map((c) => ({
+                                sha: c.sha,
+                                message: c.commit.message,
+                                author: c.commit.author.name,
+                                email: c.commit.author.email,
+                                date: c.commit.author.date,
+                            })),
+                        };
+                    }
+                    catch (err) {
+                        results.providers.gitea = { success: false, error: err.message };
+                    }
+                }
+                return results;
             }
             case 'contributors': {
                 const log = await git.log();
@@ -92,7 +214,55 @@ class GitMonitorTool {
                     }
                 });
                 const sorted = Array.from(contributors.values()).sort((a, b) => b.commits - a.commits);
-                return { success: true, contributors: sorted };
+                const results = {
+                    success: true,
+                    local: { contributors: sorted },
+                    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 contributors = await ctx.providerManager.github.rest.repos.listContributors({
+                            owner: githubOwner,
+                            repo: repoInfo.repoName,
+                        });
+                        results.providers.github = {
+                            success: true,
+                            contributors: contributors.data.map((c) => ({
+                                login: c.login,
+                                contributions: c.contributions,
+                                avatar_url: c.avatar_url,
+                                url: c.html_url,
+                            })),
+                        };
+                    }
+                    catch (err) {
+                        results.providers.github = { success: false, error: err.message };
+                    }
+                }
+                // Gitea
+                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
+                    try {
+                        const contributors = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repoInfo.repoName}/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,
+                            })),
+                        };
+                    }
+                    catch (err) {
+                        results.providers.gitea = { success: false, error: err.message };
+                    }
+                }
+                return results;
             }
             default:
                 throw new errors_1.MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);

package/dist/tools/gitTags.d.ts

@@ -2,29 +2,5 @@ import { Tool, MCPContext } from '../types';
 export declare class GitTagsTool implements Tool {
     name: string;
     description: string;
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
-        success: boolean;
-        tag: any;
-        tags?: undefined;
-        details?: undefined;
-        deleted?: undefined;
-    } | {
-        success: boolean;
-        tags: string[];
-        tag?: undefined;
-        details?: undefined;
-        deleted?: undefined;
-    } | {
-        success: boolean;
-        tag: any;
-        details: string;
-        tags?: undefined;
-        deleted?: undefined;
-    } | {
-        success: boolean;
-        deleted: any;
-        tag?: undefined;
-        tags?: undefined;
-        details?: undefined;
-    }>;
+    handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
 }

package/dist/tools/gitTags.js

@@ -6,10 +6,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitTagsTool = 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 GitTagsTool {
     constructor() {
         this.name = 'git-tags';
-        this.description = 'Tag management operations';
+        this.description = 'Tag management operations - automatic dual-provider execution for remote queries';
     }
     async handle(params, ctx) {
         const action = params.action;
@@ -29,37 +31,183 @@ class GitTagsTool {
                 else {
                     await git.addTag(tagName);
                 }
-                return { success: true, tag: tagName };
+                return { success: true, tag: tagName, local: true };
             }
             case 'list': {
-                const tags = await git.tags();
-                return { success: true, tags: tags.all };
+                const localTags = await git.tags();
+                const results = {
+                    success: true,
+                    local: { tags: localTags.all },
+                    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 tags = await ctx.providerManager.github.rest.repos.listTags({
+                            owner: githubOwner,
+                            repo: repoInfo.repoName,
+                        });
+                        results.providers.github = {
+                            success: true,
+                            tags: tags.data.map((t) => ({
+                                name: t.name,
+                                sha: t.commit.sha,
+                                zipball_url: t.zipball_url,
+                                tarball_url: t.tarball_url,
+                            })),
+                        };
+                    }
+                    catch (err) {
+                        results.providers.github = { success: false, error: err.message };
+                    }
+                }
+                // Gitea
+                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
+                    try {
+                        const tags = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repoInfo.repoName}/tags`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        results.providers.gitea = {
+                            success: true,
+                            tags: tags.data.map((t) => ({
+                                name: t.name,
+                                sha: t.commit?.id || t.id,
+                                zipball_url: t.zipball_url,
+                                tarball_url: t.tarball_url,
+                            })),
+                        };
+                    }
+                    catch (err) {
+                        results.providers.gitea = { success: false, error: err.message };
+                    }
+                }
+                return results;
             }
             case 'get': {
                 const tagName = params.tagName;
                 if (!tagName)
                     throw new errors_1.MCPError('VALIDATION_ERROR', 'tagName is required');
-                const tags = await git.tags();
-                if (!tags.all.includes(tagName)) {
-                    throw new errors_1.MCPError('TAG_NOT_FOUND', `Tag '${tagName}' not found`);
+                const localTags = await git.tags();
+                const localTag = localTags.all.find(t => t === tagName);
+                const results = {
+                    success: true,
+                    local: localTag ? { found: true, tag: tagName } : { found: false },
+                    providers: {}
+                };
+                if (localTag) {
+                    try {
+                        const show = await git.show([tagName]);
+                        results.local.details = show;
+                    }
+                    catch { }
+                }
+                // 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 tag = await ctx.providerManager.github.rest.git.getRef({
+                            owner: githubOwner,
+                            repo: repoInfo.repoName,
+                            ref: `tags/${tagName}`,
+                        });
+                        results.providers.github = {
+                            success: true,
+                            tag: {
+                                name: tagName,
+                                sha: tag.data.object.sha,
+                                type: tag.data.object.type,
+                                url: tag.data.url,
+                            },
+                        };
+                    }
+                    catch (err) {
+                        results.providers.github = { success: false, error: err.message };
+                    }
                 }
-                const show = await git.show([tagName]);
-                return { success: true, tag: tagName, details: show };
+                // Gitea
+                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
+                    try {
+                        const tags = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repoInfo.repoName}/tags`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        const tag = tags.data.find((t) => t.name === tagName);
+                        if (tag) {
+                            results.providers.gitea = {
+                                success: true,
+                                tag: {
+                                    name: tag.name,
+                                    sha: tag.commit?.id || tag.id,
+                                    message: tag.message,
+                                },
+                            };
+                        }
+                        else {
+                            results.providers.gitea = { success: false, error: 'Tag not found' };
+                        }
+                    }
+                    catch (err) {
+                        results.providers.gitea = { success: false, error: err.message };
+                    }
+                }
+                return results;
             }
             case 'delete': {
                 const tagName = params.tagName;
                 if (!tagName)
                     throw new errors_1.MCPError('VALIDATION_ERROR', 'tagName is required');
                 await git.tag(['-d', tagName]);
-                return { success: true, deleted: tagName };
+                return { success: true, deleted: tagName, local: true };
             }
             case 'search': {
                 const pattern = params.pattern;
                 if (!pattern)
                     throw new errors_1.MCPError('VALIDATION_ERROR', 'pattern is required');
-                const tags = await git.tags();
-                const filtered = tags.all.filter(t => t.includes(pattern));
-                return { success: true, tags: filtered };
+                const localTags = await git.tags();
+                const filtered = localTags.all.filter(t => t.includes(pattern));
+                const results = {
+                    success: true,
+                    local: { tags: filtered },
+                    providers: {}
+                };
+                // Also search 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 tags = await ctx.providerManager.github.rest.repos.listTags({
+                            owner: githubOwner,
+                            repo: repoInfo.repoName,
+                        });
+                        const matchedTags = tags.data.filter((t) => t.name.includes(pattern));
+                        results.providers.github = {
+                            success: true,
+                            tags: matchedTags.map((t) => t.name),
+                        };
+                    }
+                    catch (err) {
+                        results.providers.github = { success: false, error: err.message };
+                    }
+                }
+                // Gitea
+                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
+                    try {
+                        const tags = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repoInfo.repoName}/tags`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        const matchedTags = tags.data.filter((t) => t.name.includes(pattern));
+                        results.providers.gitea = {
+                            success: true,
+                            tags: matchedTags.map((t) => t.name),
+                        };
+                    }
+                    catch (err) {
+                        results.providers.gitea = { success: false, error: err.message };
+                    }
+                }
+                return results;
             }
             default:
                 throw new errors_1.MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);

package/dist/utils/dualExecution.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Dual Provider Execution Helper
+ * Executes operations on BOTH GitHub and Gitea simultaneously
+ * Uses GITHUB_USERNAME and GITEA_USERNAME from env vars automatically
+ */
+import { ProviderManager } from '../providers/providerManager';
+export interface DualExecutionResult<T> {
+    github: {
+        success: boolean;
+        data?: T;
+        error?: string;
+    };
+    gitea: {
+        success: boolean;
+        data?: T;
+        error?: string;
+    };
+}
+/**
+ * Execute function on both providers simultaneously
+ * @param providerManager Provider manager instance
+ * @param githubFn Function to execute on GitHub
+ * @param giteaFn Function to execute on Gitea
+ * @returns Dual execution result with separate responses
+ */
+export declare function executeDual<T>(providerManager: ProviderManager, githubFn: () => Promise<T>, giteaFn: () => Promise<T>): Promise<DualExecutionResult<T>>;
+/**
+ * Get GitHub username from env vars
+ * @throws Error if GITHUB_USERNAME not found
+ */
+export declare function getGitHubUsername(): string;
+/**
+ * Get Gitea username from env vars
+ * @throws Error if GITEA_USERNAME not found
+ */
+export declare function getGiteaUsername(): string;
+/**
+ * Get repository name from projectPath
+ * @param projectPath Absolute path to project root
+ * @returns Repository name (folder name)
+ */
+export declare function getRepoNameFromPath(projectPath: string): string;
+/**
+ * Execute same function on both providers with automatic username injection
+ * @param providerManager Provider manager instance
+ * @param fn Function that takes (provider, username) and returns data
+ * @returns Dual execution result
+ */
+export declare function executeDualAuto<T>(providerManager: ProviderManager, fn: (provider: any, username: string) => Promise<T>): Promise<DualExecutionResult<T>>;

package/dist/utils/dualExecution.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Dual Provider Execution Helper
+ * Executes operations on BOTH GitHub and Gitea simultaneously
+ * Uses GITHUB_USERNAME and GITEA_USERNAME from env vars automatically
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeDual = executeDual;
+exports.getGitHubUsername = getGitHubUsername;
+exports.getGiteaUsername = getGiteaUsername;
+exports.getRepoNameFromPath = getRepoNameFromPath;
+exports.executeDualAuto = executeDualAuto;
+/**
+ * Execute function on both providers simultaneously
+ * @param providerManager Provider manager instance
+ * @param githubFn Function to execute on GitHub
+ * @param giteaFn Function to execute on Gitea
+ * @returns Dual execution result with separate responses
+ */
+async function executeDual(providerManager, githubFn, giteaFn) {
+    const result = {
+        github: { success: false },
+        gitea: { success: false }
+    };
+    // Execute GitHub
+    try {
+        const githubData = await githubFn();
+        result.github = {
+            success: true,
+            data: githubData
+        };
+    }
+    catch (error) {
+        result.github = {
+            success: false,
+            error: error.message || String(error)
+        };
+    }
+    // Execute Gitea
+    try {
+        const giteaData = await giteaFn();
+        result.gitea = {
+            success: true,
+            data: giteaData
+        };
+    }
+    catch (error) {
+        result.gitea = {
+            success: false,
+            error: error.message || String(error)
+        };
+    }
+    return result;
+}
+/**
+ * Get GitHub username from env vars
+ * @throws Error if GITHUB_USERNAME not found
+ */
+function getGitHubUsername() {
+    const username = process.env.GITHUB_USERNAME;
+    if (!username) {
+        throw new Error('GITHUB_USERNAME not found in environment variables');
+    }
+    return username;
+}
+/**
+ * Get Gitea username from env vars
+ * @throws Error if GITEA_USERNAME not found
+ */
+function getGiteaUsername() {
+    const username = process.env.GITEA_USERNAME;
+    if (!username) {
+        throw new Error('GITEA_USERNAME not found in environment variables');
+    }
+    return username;
+}
+/**
+ * Get repository name from projectPath
+ * @param projectPath Absolute path to project root
+ * @returns Repository name (folder name)
+ */
+function getRepoNameFromPath(projectPath) {
+    const parts = projectPath.replace(/\\/g, '/').split('/');
+    return parts[parts.length - 1];
+}
+/**
+ * Execute same function on both providers with automatic username injection
+ * @param providerManager Provider manager instance
+ * @param fn Function that takes (provider, username) and returns data
+ * @returns Dual execution result
+ */
+async function executeDualAuto(providerManager, fn) {
+    const githubUsername = getGitHubUsername();
+    const giteaUsername = getGiteaUsername();
+    return executeDual(providerManager, () => fn(providerManager.getProvider('github'), githubUsername), () => fn(providerManager.getProvider('gitea'), giteaUsername));
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@andrebuzeli/git-mcp",
-  "version": "6.3.2",
-  "description": "Professional MCP server for Git operations - STDIO UNIVERSAL: works in ANY IDE (Cursor, VSCode, Claude Desktop). Fully autonomous with intelligent error handling. Auto-detects branches, owner, repo. User-friendly error messages. Dual-provider execution (GitHub + Gitea)",
+  "version": "7.0.0",
+  "description": "Professional MCP server for Git operations - STDIO UNIVERSAL: works in ANY IDE (Cursor, VSCode, Claude Desktop). Fully autonomous DUAL execution (GitHub + Gitea APIs) with automatic username detection. All tools execute on BOTH providers simultaneously. No manual parameters needed.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {