@andrebuzeli/git-mcp 5.5.2 → 5.8.0

package/dist/tools/gitUpload.js

@@ -0,0 +1,342 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitUploadTool = void 0;
+const simple_git_1 = __importDefault(require("simple-git"));
+const errors_1 = require("../utils/errors");
+const axios_1 = __importDefault(require("axios"));
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+/**
+ * Git Upload Tool - Envia projeto completo para GitHub e Gitea automaticamente
+ * Modo DUAL automático com rastreabilidade completa
+ */
+class GitUploadTool {
+    constructor() {
+        this.name = 'git-upload';
+        this.description = 'Upload complete project to GitHub and Gitea with full traceability - automatic dual-provider execution';
+    }
+    async handle(params, ctx) {
+        const projectPath = params.projectPath;
+        if (!projectPath) {
+            throw new errors_1.MCPError('VALIDATION_ERROR', 'projectPath is required');
+        }
+        const repoName = params.repoName || path.basename(projectPath);
+        const description = params.description || `Project uploaded via git-upload at ${new Date().toISOString()}`;
+        const isPrivate = params.private !== undefined ? params.private : true;
+        const branch = params.branch || 'master';
+        const git = (0, simple_git_1.default)({ baseDir: projectPath });
+        // Resultado com rastreabilidade completa
+        const results = {
+            success: true,
+            timestamp: new Date().toISOString(),
+            projectPath,
+            repoName,
+            branch,
+            providers: {},
+            traceability: {
+                localChanges: {},
+                uploadSteps: [],
+                errors: [],
+            }
+        };
+        try {
+            // 1. Verificar status local
+            results.traceability.uploadSteps.push({
+                step: 1,
+                action: 'check_local_status',
+                timestamp: new Date().toISOString(),
+            });
+            const status = await git.status();
+            results.traceability.localChanges = {
+                modified: status.modified,
+                created: status.created,
+                deleted: status.deleted,
+                renamed: status.renamed,
+                staged: status.staged,
+                conflicted: status.conflicted,
+                isClean: status.isClean(),
+            };
+            // 2. Verificar se tem mudanças
+            if (!status.isClean()) {
+                results.traceability.uploadSteps.push({
+                    step: 2,
+                    action: 'stage_all_changes',
+                    timestamp: new Date().toISOString(),
+                    files: [...status.modified, ...status.created, ...status.deleted],
+                });
+                await git.add('.');
+            }
+            // 3. Commit com rastreabilidade
+            const commitMessage = params.commitMessage || `[git-upload] Upload project at ${new Date().toISOString()}`;
+            results.traceability.uploadSteps.push({
+                step: 3,
+                action: 'commit_changes',
+                timestamp: new Date().toISOString(),
+                message: commitMessage,
+            });
+            let commitResult;
+            try {
+                commitResult = await git.commit(commitMessage);
+                results.traceability.commit = {
+                    hash: commitResult.commit,
+                    summary: commitResult.summary,
+                    branch: commitResult.branch,
+                    author: commitResult.author,
+                };
+            }
+            catch (err) {
+                if (err.message.includes('nothing to commit')) {
+                    results.traceability.commit = { message: 'No changes to commit' };
+                }
+                else {
+                    throw err;
+                }
+            }
+            // 4. Criar repositórios remotos em ambos providers
+            // Nota: Cada provider precisa usar seu próprio username (Gitea é case-sensitive)
+            const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+            const giteaOwner = params.owner || process.env.GITEA_USERNAME;
+            // GITHUB
+            if (ctx.providerManager.github) {
+                results.traceability.uploadSteps.push({
+                    step: 4,
+                    action: 'create_github_repo',
+                    timestamp: new Date().toISOString(),
+                });
+                try {
+                    // Verificar se repo já existe
+                    let repoExists = false;
+                    try {
+                        await ctx.providerManager.github.rest.repos.get({ owner: githubOwner, repo: repoName });
+                        repoExists = true;
+                    }
+                    catch { }
+                    if (!repoExists) {
+                        const createResult = await ctx.providerManager.github.rest.repos.createForAuthenticatedUser({
+                            name: repoName,
+                            description,
+                            private: isPrivate,
+                            auto_init: false,
+                        });
+                        results.providers.github = {
+                            success: true,
+                            created: true,
+                            repo: createResult.data,
+                            url: createResult.data.html_url,
+                            clone_url: createResult.data.clone_url,
+                        };
+                    }
+                    else {
+                        results.providers.github = {
+                            success: true,
+                            created: false,
+                            message: 'Repository already exists',
+                            url: `https://github.com/${githubOwner}/${repoName}`,
+                        };
+                    }
+                    // Adicionar remote se necessário
+                    const remotes = await git.getRemotes(true);
+                    const githubRemote = remotes.find(r => r.name === 'github');
+                    if (!githubRemote) {
+                        await git.addRemote('github', `https://github.com/${githubOwner}/${repoName}.git`);
+                        results.traceability.uploadSteps.push({
+                            step: 5,
+                            action: 'add_github_remote',
+                            timestamp: new Date().toISOString(),
+                            remote: `https://github.com/${githubOwner}/${repoName}.git`,
+                        });
+                    }
+                    // Push para GitHub
+                    results.traceability.uploadSteps.push({
+                        step: 6,
+                        action: 'push_to_github',
+                        timestamp: new Date().toISOString(),
+                        branch,
+                    });
+                    try {
+                        await git.push('github', branch, ['--set-upstream', '--force']);
+                        results.providers.github.pushed = true;
+                        results.providers.github.pushStatus = 'success';
+                    }
+                    catch (pushErr) {
+                        results.providers.github.pushed = false;
+                        results.providers.github.pushError = pushErr.message;
+                        results.traceability.errors.push({
+                            provider: 'github',
+                            action: 'push',
+                            error: pushErr.message,
+                            timestamp: new Date().toISOString(),
+                        });
+                    }
+                }
+                catch (err) {
+                    results.providers.github = {
+                        success: false,
+                        error: err.message,
+                        timestamp: new Date().toISOString(),
+                    };
+                    results.traceability.errors.push({
+                        provider: 'github',
+                        action: 'upload',
+                        error: err.message,
+                        timestamp: new Date().toISOString(),
+                    });
+                }
+            }
+            // GITEA
+            if (ctx.providerManager.giteaBaseUrl) {
+                results.traceability.uploadSteps.push({
+                    step: 7,
+                    action: 'create_gitea_repo',
+                    timestamp: new Date().toISOString(),
+                });
+                try {
+                    // Verificar se repo já existe
+                    let repoExists = false;
+                    try {
+                        await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repoName}`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        repoExists = true;
+                    }
+                    catch { }
+                    if (!repoExists) {
+                        const createResult = await axios_1.default.post(`${ctx.providerManager.giteaBaseUrl}/api/v1/user/repos`, {
+                            name: repoName,
+                            description,
+                            private: isPrivate,
+                            auto_init: false,
+                        }, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        results.providers.gitea = {
+                            success: true,
+                            created: true,
+                            repo: createResult.data,
+                            url: createResult.data.html_url,
+                            clone_url: createResult.data.clone_url,
+                        };
+                    }
+                    else {
+                        results.providers.gitea = {
+                            success: true,
+                            created: false,
+                            message: 'Repository already exists',
+                            url: `${ctx.providerManager.giteaBaseUrl}/${giteaOwner}/${repoName}`,
+                        };
+                    }
+                    // Adicionar remote se necessário
+                    const remotes = await git.getRemotes(true);
+                    const giteaRemote = remotes.find(r => r.name === 'gitea');
+                    if (!giteaRemote) {
+                        const giteaUrl = `${ctx.providerManager.giteaBaseUrl}/${giteaOwner}/${repoName}.git`;
+                        await git.addRemote('gitea', giteaUrl);
+                        results.traceability.uploadSteps.push({
+                            step: 8,
+                            action: 'add_gitea_remote',
+                            timestamp: new Date().toISOString(),
+                            remote: giteaUrl,
+                        });
+                    }
+                    // Push para Gitea
+                    results.traceability.uploadSteps.push({
+                        step: 9,
+                        action: 'push_to_gitea',
+                        timestamp: new Date().toISOString(),
+                        branch,
+                    });
+                    try {
+                        await git.push('gitea', branch, ['--set-upstream', '--force']);
+                        results.providers.gitea.pushed = true;
+                        results.providers.gitea.pushStatus = 'success';
+                    }
+                    catch (pushErr) {
+                        results.providers.gitea.pushed = false;
+                        results.providers.gitea.pushError = pushErr.message;
+                        results.traceability.errors.push({
+                            provider: 'gitea',
+                            action: 'push',
+                            error: pushErr.message,
+                            timestamp: new Date().toISOString(),
+                        });
+                    }
+                }
+                catch (err) {
+                    results.providers.gitea = {
+                        success: false,
+                        error: err.message,
+                        timestamp: new Date().toISOString(),
+                    };
+                    results.traceability.errors.push({
+                        provider: 'gitea',
+                        action: 'upload',
+                        error: err.message,
+                        timestamp: new Date().toISOString(),
+                    });
+                }
+            }
+            // 5. Salvar histórico local
+            await this.saveUploadHistory(projectPath, results);
+            return results;
+        }
+        catch (err) {
+            throw new errors_1.MCPError('UPLOAD_ERROR', `Failed to upload project: ${err.message}`);
+        }
+    }
+    async saveUploadHistory(projectPath, results) {
+        try {
+            const historyDir = path.join(projectPath, '.git-mcp-history');
+            await fs.mkdir(historyDir, { recursive: true });
+            const historyFile = path.join(historyDir, `upload-${Date.now()}.json`);
+            await fs.writeFile(historyFile, JSON.stringify(results, null, 2), 'utf-8');
+            // Também manter um log consolidado
+            const logFile = path.join(historyDir, 'upload-log.jsonl');
+            const logEntry = JSON.stringify({
+                timestamp: results.timestamp,
+                repoName: results.repoName,
+                branch: results.branch,
+                github: results.providers.github?.success || false,
+                gitea: results.providers.gitea?.success || false,
+                errors: results.traceability.errors.length,
+            }) + '\n';
+            await fs.appendFile(logFile, logEntry, 'utf-8');
+        }
+        catch (err) {
+            // Não falhar se não conseguir salvar histórico
+            console.warn('Failed to save upload history:', err);
+        }
+    }
+}
+exports.GitUploadTool = GitUploadTool;

package/dist/tools/gitWorkflow.d.ts

@@ -2,68 +2,5 @@ import { Tool, MCPContext } from '../types';
 export declare class GitWorkflowTool implements Tool {
     name: string;
     description: string;
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
-        success: boolean;
-        path: any;
-        status?: undefined;
-        commit?: undefined;
-        message?: undefined;
-        backupPath?: undefined;
-        repo?: undefined;
-        repos?: undefined;
-    } | {
-        success: boolean;
-        status: import("simple-git").StatusResult;
-        path?: undefined;
-        commit?: undefined;
-        message?: undefined;
-        backupPath?: undefined;
-        repo?: undefined;
-        repos?: undefined;
-    } | {
-        success: boolean;
-        commit: import("simple-git").CommitResult;
-        path?: undefined;
-        status?: undefined;
-        message?: undefined;
-        backupPath?: undefined;
-        repo?: undefined;
-        repos?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        path?: undefined;
-        status?: undefined;
-        commit?: undefined;
-        backupPath?: undefined;
-        repo?: undefined;
-        repos?: undefined;
-    } | {
-        success: boolean;
-        backupPath: any;
-        message: string;
-        path?: undefined;
-        status?: undefined;
-        commit?: undefined;
-        repo?: undefined;
-        repos?: undefined;
-    } | {
-        success: boolean;
-        repo: any;
-        path?: undefined;
-        status?: undefined;
-        commit?: undefined;
-        message?: undefined;
-        backupPath?: undefined;
-        repos?: undefined;
-    } | {
-        success: boolean;
-        repos: any;
-        path?: undefined;
-        status?: undefined;
-        commit?: undefined;
-        message?: undefined;
-        backupPath?: undefined;
-        repo?: undefined;
-    }>;
+    handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
 }