@andrebuzeli/git-mcp 5.5.2 → 5.8.0

package/dist/tools/gitWorkflow.js

@@ -10,7 +10,7 @@ const axios_1 = __importDefault(require("axios"));
 class GitWorkflowTool {
     constructor() {
         this.name = 'git-workflow';
-        this.description = 'Core Git operations including init, status, commit, sync, backup, and remote operations';
+        this.description = 'Core Git operations including init, status, commit, sync, backup, and remote operations - automatic dual-provider for remote ops';
     }
     async handle(params, ctx) {
         const action = params.action;
@@ -62,65 +62,239 @@ class GitWorkflowTool {
                 return { success: true, backupPath, message: 'Backup marked (simplified)' };
             }
             case 'create': {
-                const provider = params.provider;
                 const name = params.name;
-                if (!provider || !name)
-                    throw new errors_1.MCPError('VALIDATION_ERROR', 'provider and name are required');
-                const owner = params.owner || process.env.GITHUB_USERNAME || process.env.GITEA_USERNAME;
-                if (provider === 'github' && ctx.providerManager.github) {
-                    const result = await ctx.providerManager.github.rest.repos.createForAuthenticatedUser({
-                        name,
-                        description: params.description,
-                        private: params.private || false,
-                    });
-                    return { success: true, repo: result.data };
-                }
-                if (provider === 'gitea' && ctx.providerManager.giteaBaseUrl) {
-                    const result = await axios_1.default.post(`${ctx.providerManager.giteaBaseUrl}/api/v1/user/repos`, {
-                        name,
-                        description: params.description,
-                        private: params.private || false,
-                    }, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
-                    return { success: true, repo: result.data };
-                }
-                throw new errors_1.MCPError('PROVIDER_NOT_CONFIGURED', `Provider ${provider} is not configured`);
+                if (!name)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'name is required');
+                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
+                const results = { success: true, providers: {} };
+                // GitHub
+                if (ctx.providerManager.github) {
+                    try {
+                        const result = await ctx.providerManager.github.rest.repos.createForAuthenticatedUser({
+                            name,
+                            description: params.description,
+                            private: params.private || false,
+                        });
+                        results.providers.github = { success: true, repo: result.data };
+                    }
+                    catch (err) {
+                        results.providers.github = { success: false, error: err.message };
+                    }
+                }
+                // Gitea
+                if (ctx.providerManager.giteaBaseUrl) {
+                    try {
+                        const result = await axios_1.default.post(`${ctx.providerManager.giteaBaseUrl}/api/v1/user/repos`, {
+                            name,
+                            description: params.description,
+                            private: params.private || false,
+                        }, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        results.providers.gitea = { success: true, repo: result.data };
+                    }
+                    catch (err) {
+                        results.providers.gitea = { success: false, error: err.message };
+                    }
+                }
+                return results;
             }
             case 'list': {
-                const provider = params.provider;
-                if (!provider)
-                    throw new errors_1.MCPError('VALIDATION_ERROR', 'provider is required');
-                if (provider === 'github' && ctx.providerManager.github) {
-                    const result = await ctx.providerManager.github.rest.repos.listForAuthenticatedUser();
-                    return { success: true, repos: result.data };
-                }
-                if (provider === 'gitea' && ctx.providerManager.giteaBaseUrl) {
-                    const result = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/user/repos`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
-                    return { success: true, repos: result.data };
-                }
-                throw new errors_1.MCPError('PROVIDER_NOT_CONFIGURED', `Provider ${provider} is not configured`);
+                const results = { success: true, providers: {} };
+                // GitHub
+                if (ctx.providerManager.github) {
+                    try {
+                        const result = await ctx.providerManager.github.rest.repos.listForAuthenticatedUser();
+                        results.providers.github = { success: true, repos: result.data };
+                    }
+                    catch (err) {
+                        results.providers.github = { success: false, error: err.message };
+                    }
+                }
+                // Gitea
+                if (ctx.providerManager.giteaBaseUrl) {
+                    try {
+                        const result = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/user/repos`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        results.providers.gitea = { success: true, repos: result.data };
+                    }
+                    catch (err) {
+                        results.providers.gitea = { success: false, error: err.message };
+                    }
+                }
+                return results;
             }
             case 'get': {
-                const provider = params.provider;
-                const owner = params.owner;
+                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
+                const repo = params.repo;
+                if (!githubOwner || !repo) {
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'owner and repo are required');
+                }
+                const results = { success: true, providers: {} };
+                // GitHub
+                if (ctx.providerManager.github) {
+                    try {
+                        const result = await ctx.providerManager.github.rest.repos.get({ owner: githubOwner, repo });
+                        results.providers.github = { success: true, repo: result.data };
+                    }
+                    catch (err) {
+                        results.providers.github = { success: false, error: err.message };
+                    }
+                }
+                // Gitea
+                if (ctx.providerManager.giteaBaseUrl) {
+                    try {
+                        const result = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        results.providers.gitea = { success: true, repo: result.data };
+                    }
+                    catch (err) {
+                        results.providers.gitea = { success: false, error: err.message };
+                    }
+                }
+                return results;
+            }
+            case 'update': {
+                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
+                const repo = params.repo;
+                if (!githubOwner || !repo) {
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'owner and repo are required');
+                }
+                const results = { success: true, providers: {} };
+                // GitHub
+                if (ctx.providerManager.github) {
+                    try {
+                        const result = await ctx.providerManager.github.rest.repos.update({
+                            owner: githubOwner,
+                            repo,
+                            description: params.description,
+                            private: params.private,
+                            has_issues: params.has_issues,
+                            has_projects: params.has_projects,
+                            has_wiki: params.has_wiki,
+                        });
+                        results.providers.github = { success: true, repo: result.data };
+                    }
+                    catch (err) {
+                        results.providers.github = { success: false, error: err.message };
+                    }
+                }
+                // Gitea
+                if (ctx.providerManager.giteaBaseUrl) {
+                    try {
+                        const result = await axios_1.default.patch(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}`, {
+                            description: params.description,
+                            private: params.private,
+                            has_issues: params.has_issues,
+                            has_projects: params.has_projects,
+                            has_wiki: params.has_wiki,
+                        }, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        results.providers.gitea = { success: true, repo: result.data };
+                    }
+                    catch (err) {
+                        results.providers.gitea = { success: false, error: err.message };
+                    }
+                }
+                return results;
+            }
+            case 'delete': {
+                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
                 const repo = params.repo;
-                if (!provider || !owner || !repo) {
-                    throw new errors_1.MCPError('VALIDATION_ERROR', 'provider, owner, and repo are required');
+                if (!githubOwner || !repo) {
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'owner and repo are required');
                 }
-                if (provider === 'github' && ctx.providerManager.github) {
-                    const result = await ctx.providerManager.github.rest.repos.get({ owner, repo });
-                    return { success: true, repo: result.data };
+                const results = { success: true, providers: {} };
+                // GitHub
+                if (ctx.providerManager.github) {
+                    try {
+                        await ctx.providerManager.github.rest.repos.delete({ owner: githubOwner, repo });
+                        results.providers.github = { success: true, deleted: true };
+                    }
+                    catch (err) {
+                        results.providers.github = { success: false, error: err.message };
+                    }
+                }
+                // Gitea
+                if (ctx.providerManager.giteaBaseUrl) {
+                    try {
+                        await axios_1.default.delete(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        results.providers.gitea = { success: true, deleted: true };
+                    }
+                    catch (err) {
+                        results.providers.gitea = { success: false, error: err.message };
+                    }
+                }
+                return results;
+            }
+            case 'fork': {
+                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
+                const repo = params.repo;
+                if (!githubOwner || !repo) {
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'owner and repo are required');
+                }
+                const results = { success: true, providers: {} };
+                // GitHub
+                if (ctx.providerManager.github) {
+                    try {
+                        const result = await ctx.providerManager.github.rest.repos.createFork({
+                            owner: githubOwner,
+                            repo,
+                            organization: params.organization,
+                        });
+                        results.providers.github = { success: true, fork: result.data };
+                    }
+                    catch (err) {
+                        results.providers.github = { success: false, error: err.message };
+                    }
+                }
+                // Gitea
+                if (ctx.providerManager.giteaBaseUrl) {
+                    try {
+                        const result = await axios_1.default.post(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/forks`, { organization: params.organization }, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        results.providers.gitea = { success: true, fork: result.data };
+                    }
+                    catch (err) {
+                        results.providers.gitea = { success: false, error: err.message };
+                    }
+                }
+                return results;
+            }
+            case 'search': {
+                const query = params.query;
+                if (!query)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'query is required');
+                const results = { success: true, providers: {} };
+                // GitHub
+                if (ctx.providerManager.github) {
+                    try {
+                        const result = await ctx.providerManager.github.rest.search.repos({
+                            q: query,
+                            sort: params.sort,
+                            order: params.order,
+                            per_page: params.limit || 30,
+                        });
+                        results.providers.github = { success: true, repos: result.data.items, total: result.data.total_count };
+                    }
+                    catch (err) {
+                        results.providers.github = { success: false, error: err.message };
+                    }
                 }
-                if (provider === 'gitea' && ctx.providerManager.giteaBaseUrl) {
-                    const result = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${owner}/${repo}`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
-                    return { success: true, repo: result.data };
+                // Gitea
+                if (ctx.providerManager.giteaBaseUrl) {
+                    try {
+                        const result = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/search`, {
+                            params: { q: query, limit: params.limit || 30, sort: params.sort },
+                            headers: { Authorization: `token ${ctx.providerManager.giteaToken}` }
+                        });
+                        results.providers.gitea = { success: true, repos: result.data.data, total: result.data.ok ? result.data.data.length : 0 };
+                    }
+                    catch (err) {
+                        results.providers.gitea = { success: false, error: err.message };
+                    }
                 }
-                throw new errors_1.MCPError('PROVIDER_NOT_CONFIGURED', `Provider ${provider} is not configured`);
+                return results;
             }
-            case 'update':
-            case 'delete':
-            case 'fork':
-            case 'search':
-                throw new errors_1.MCPError('NOT_IMPLEMENTED', `Action ${action} not yet fully implemented`);
             default:
                 throw new errors_1.MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
         }

package/dist/types.d.ts

@@ -8,3 +8,10 @@ export interface Tool {
     description?: string;
     handle(params: Record<string, any>, ctx: MCPContext): Promise<ToolHandleResult>;
 }
+export interface Resource {
+    uri: string;
+    name: string;
+    description: string;
+    mimeType: string;
+    content: string;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@andrebuzeli/git-mcp",
-  "version": "5.5.2",
-  "description": "Professional MCP server for Git operations with Universal Mode - automatic multi-provider support (GitHub + Gitea), enhanced security, and comprehensive safety features",
+  "version": "5.8.0",
+  "description": "Professional MCP server for Git operations - automatic dual-provider execution (GitHub + Gitea), no provider parameter needed, organized responses by provider, enhanced security and safety features",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {