@andrebuzeli/git-mcp 5.5.2 → 5.8.1

package/dist/tools/gitUpdate.js

@@ -0,0 +1,374 @@
+"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.GitUpdateTool = 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 Update Tool - Atualiza projeto completo em GitHub e Gitea automaticamente
+ * Modo DUAL automático com rastreabilidade completa
+ * Inclui: add, commit, push, sync, history tracking
+ */
+class GitUpdateTool {
+    constructor() {
+        this.name = 'git-update';
+        this.description = 'Complete project update workflow (add, commit, push) to GitHub and Gitea with full traceability - automatic dual-provider execution';
+    }
+    async handle(params, ctx) {
+        const projectPath = params.projectPath;
+        if (!projectPath) {
+            throw new errors_1.MCPError('VALIDATION_ERROR', 'projectPath is required');
+        }
+        const commitMessage = params.message || params.commitMessage || `[git-update] Update at ${new Date().toISOString()}`;
+        const branch = params.branch || 'master';
+        const files = params.files || ['.'];
+        const git = (0, simple_git_1.default)({ baseDir: projectPath });
+        // Resultado com rastreabilidade completa
+        const results = {
+            success: true,
+            timestamp: new Date().toISOString(),
+            projectPath,
+            branch,
+            commitMessage,
+            providers: {},
+            traceability: {
+                preUpdateStatus: {},
+                changedFiles: [],
+                updateSteps: [],
+                syncStatus: {},
+                errors: [],
+            }
+        };
+        try {
+            // 1. Status PRÉ-UPDATE
+            results.traceability.updateSteps.push({
+                step: 1,
+                action: 'check_pre_update_status',
+                timestamp: new Date().toISOString(),
+            });
+            const preStatus = await git.status();
+            results.traceability.preUpdateStatus = {
+                branch: preStatus.current,
+                ahead: preStatus.ahead,
+                behind: preStatus.behind,
+                modified: preStatus.modified,
+                created: preStatus.created,
+                deleted: preStatus.deleted,
+                renamed: preStatus.renamed,
+                staged: preStatus.staged,
+                conflicted: preStatus.conflicted,
+                isClean: preStatus.isClean(),
+            };
+            // 2. Detectar arquivos alterados com diff
+            results.traceability.updateSteps.push({
+                step: 2,
+                action: 'detect_changes',
+                timestamp: new Date().toISOString(),
+            });
+            const diff = await git.diff(['--name-status']);
+            const diffLines = diff.split('\n').filter(l => l.trim());
+            results.traceability.changedFiles = diffLines.map(line => {
+                const [status, ...fileParts] = line.split('\t');
+                return {
+                    status: status.trim(),
+                    file: fileParts.join('\t').trim(),
+                };
+            });
+            // 3. Add files
+            results.traceability.updateSteps.push({
+                step: 3,
+                action: 'stage_changes',
+                timestamp: new Date().toISOString(),
+                files,
+            });
+            await git.add(files);
+            // 4. Commit
+            results.traceability.updateSteps.push({
+                step: 4,
+                action: 'commit',
+                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;
+                }
+            }
+            // 5. Get remotes
+            const remotes = await git.getRemotes(true);
+            const githubRemote = remotes.find(r => r.name === 'github' || r.name === 'origin');
+            const giteaRemote = remotes.find(r => r.name === 'gitea');
+            // 6. Push to GITHUB
+            if (githubRemote && ctx.providerManager.github) {
+                results.traceability.updateSteps.push({
+                    step: 5,
+                    action: 'push_to_github',
+                    timestamp: new Date().toISOString(),
+                    remote: githubRemote.name,
+                    branch,
+                });
+                try {
+                    const pushResult = await git.push(githubRemote.name, branch);
+                    results.providers.github = {
+                        success: true,
+                        remote: githubRemote.name,
+                        url: githubRemote.refs.push,
+                        pushed: true,
+                        pushResult: {
+                            remoteMessages: pushResult.remoteMessages?.all || [],
+                            update: pushResult.update,
+                        }
+                    };
+                    // Verificar commit no GitHub via API
+                    try {
+                        if (results.traceability.commit?.hash) {
+                            const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+                            const repo = path.basename(projectPath);
+                            const commitInfo = await ctx.providerManager.github.rest.repos.getCommit({
+                                owner: githubOwner,
+                                repo,
+                                ref: results.traceability.commit.hash,
+                            });
+                            results.providers.github.commitVerified = true;
+                            results.providers.github.commitUrl = commitInfo.data.html_url;
+                            results.providers.github.stats = commitInfo.data.stats;
+                        }
+                    }
+                    catch { }
+                }
+                catch (err) {
+                    results.providers.github = {
+                        success: false,
+                        error: err.message,
+                        remote: githubRemote.name,
+                    };
+                    results.traceability.errors.push({
+                        provider: 'github',
+                        action: 'push',
+                        error: err.message,
+                        timestamp: new Date().toISOString(),
+                    });
+                }
+            }
+            // 7. Push to GITEA
+            if (giteaRemote && ctx.providerManager.giteaBaseUrl) {
+                results.traceability.updateSteps.push({
+                    step: 6,
+                    action: 'push_to_gitea',
+                    timestamp: new Date().toISOString(),
+                    remote: giteaRemote.name,
+                    branch,
+                });
+                try {
+                    const pushResult = await git.push(giteaRemote.name, branch);
+                    results.providers.gitea = {
+                        success: true,
+                        remote: giteaRemote.name,
+                        url: giteaRemote.refs.push,
+                        pushed: true,
+                        pushResult: {
+                            remoteMessages: pushResult.remoteMessages?.all || [],
+                            update: pushResult.update,
+                        }
+                    };
+                    // Verificar commit no Gitea via API
+                    try {
+                        if (results.traceability.commit?.hash) {
+                            const giteaOwner = params.owner || process.env.GITEA_USERNAME;
+                            const repo = path.basename(projectPath);
+                            const commitInfo = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/git/commits/${results.traceability.commit.hash}`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                            results.providers.gitea.commitVerified = true;
+                            results.providers.gitea.commitUrl = commitInfo.data.html_url;
+                        }
+                    }
+                    catch { }
+                }
+                catch (err) {
+                    results.providers.gitea = {
+                        success: false,
+                        error: err.message,
+                        remote: giteaRemote.name,
+                    };
+                    results.traceability.errors.push({
+                        provider: 'gitea',
+                        action: 'push',
+                        error: err.message,
+                        timestamp: new Date().toISOString(),
+                    });
+                }
+            }
+            // 8. Status PÓS-UPDATE
+            results.traceability.updateSteps.push({
+                step: 7,
+                action: 'check_post_update_status',
+                timestamp: new Date().toISOString(),
+            });
+            const postStatus = await git.status();
+            results.traceability.postUpdateStatus = {
+                branch: postStatus.current,
+                ahead: postStatus.ahead,
+                behind: postStatus.behind,
+                isClean: postStatus.isClean(),
+                tracking: postStatus.tracking,
+            };
+            // 9. Salvar histórico local
+            await this.saveUpdateHistory(projectPath, results);
+            // 10. Criar histórico remoto via git-history
+            await this.createRemoteHistory(ctx, projectPath, results, params);
+            return results;
+        }
+        catch (err) {
+            throw new errors_1.MCPError('UPDATE_ERROR', `Failed to update project: ${err.message}`);
+        }
+    }
+    async saveUpdateHistory(projectPath, results) {
+        try {
+            const historyDir = path.join(projectPath, '.git-mcp-history');
+            await fs.mkdir(historyDir, { recursive: true });
+            const historyFile = path.join(historyDir, `update-${Date.now()}.json`);
+            await fs.writeFile(historyFile, JSON.stringify(results, null, 2), 'utf-8');
+            // Log consolidado
+            const logFile = path.join(historyDir, 'update-log.jsonl');
+            const logEntry = JSON.stringify({
+                timestamp: results.timestamp,
+                branch: results.branch,
+                commit: results.traceability.commit?.hash || 'none',
+                filesChanged: results.traceability.changedFiles.length,
+                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) {
+            console.warn('Failed to save update history:', err);
+        }
+    }
+    async createRemoteHistory(ctx, projectPath, results, params) {
+        // Criar issue de histórico em ambos providers
+        const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+        const giteaOwner = params.owner || process.env.GITEA_USERNAME;
+        // Pegar nome do repo dos remotes do Git ao invés do nome da pasta
+        const git = (0, simple_git_1.default)(projectPath);
+        const remotes = await git.getRemotes(true);
+        let repoName = path.basename(projectPath).replace(/\s+/g, '-'); // fallback
+        if (remotes.length > 0) {
+            const githubRemote = remotes.find(r => r.name === 'github') || remotes.find(r => r.name === 'origin') || remotes[0];
+            const match = githubRemote.refs.push?.match(/\/([^\/]+?)(\.git)?$/);
+            if (match)
+                repoName = match[1];
+        }
+        const historyBody = this.formatHistoryIssue(results);
+        const historyTitle = `[git-history] Update ${results.timestamp}`;
+        // GitHub
+        if (ctx.providerManager.github && results.providers.github?.success) {
+            try {
+                await ctx.providerManager.github.rest.issues.create({
+                    owner: githubOwner,
+                    repo: repoName,
+                    title: historyTitle,
+                    body: historyBody,
+                    labels: ['git-history', 'automated'],
+                });
+            }
+            catch (err) {
+                console.warn('Failed to create GitHub history issue:', err);
+            }
+        }
+        // Gitea
+        if (ctx.providerManager.giteaBaseUrl && results.providers.gitea?.success) {
+            try {
+                await axios_1.default.post(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repoName}/issues`, {
+                    title: historyTitle,
+                    body: historyBody,
+                    labels: [1], // Assumindo label ID 1 para git-history
+                }, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+            }
+            catch (err) {
+                console.warn('Failed to create Gitea history issue:', err);
+            }
+        }
+    }
+    formatHistoryIssue(results) {
+        return `
+## 📋 Git Update History
+
+**Timestamp:** ${results.timestamp}
+**Branch:** ${results.branch}
+**Commit:** ${results.traceability.commit?.hash || 'N/A'}
+
+### 📝 Changes Summary
+${results.traceability.commit?.summary || 'No commit made'}
+
+**Files Changed:** ${results.traceability.changedFiles.length}
+**Insertions:** ${results.traceability.commit?.inserted || 0}
+**Deletions:** ${results.traceability.commit?.deleted || 0}
+
+### 📁 Changed Files
+${results.traceability.changedFiles.map((f) => `- [${f.status}] ${f.file}`).join('\n') || 'No files changed'}
+
+### 🔄 Provider Status
+- **GitHub:** ${results.providers.github?.success ? '✅ Success' : '❌ Failed'}
+- **Gitea:** ${results.providers.gitea?.success ? '✅ Success' : '❌ Failed'}
+
+### 🔗 Links
+${results.providers.github?.commitUrl ? `- GitHub: ${results.providers.github.commitUrl}` : ''}
+${results.providers.gitea?.commitUrl ? `- Gitea: ${results.providers.gitea.commitUrl}` : ''}
+
+---
+*Generated by git-mcp git-update tool*
+`;
+    }
+}
+exports.GitUpdateTool = GitUpdateTool;

package/dist/tools/gitUpload.d.ts

@@ -0,0 +1,11 @@
+import { Tool, MCPContext } from '../types';
+/**
+ * Git Upload Tool - Envia projeto completo para GitHub e Gitea automaticamente
+ * Modo DUAL automático com rastreabilidade completa
+ */
+export declare class GitUploadTool implements Tool {
+    name: string;
+    description: string;
+    handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
+    private saveUploadHistory;
+}