@andrebuzeli/git-mcp 10.0.8 → 11.0.0

package/dist/tools/gitUpdate.d.ts

@@ -1,60 +0,0 @@
-import { Tool, MCPContext } from '../types.js';
-/**
- * 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
- */
-export declare class GitUpdateTool implements Tool {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            projectPath: {
-                type: string;
-                description: string;
-            };
-            private: {
-                type: string;
-                description: string;
-            };
-            owner: {
-                type: string;
-                description: string;
-            };
-            message: {
-                type: string;
-                description: string;
-            };
-            commitMessage: {
-                type: string;
-                description: string;
-            };
-            branch: {
-                type: string;
-                description: string;
-            };
-            files: {
-                type: string;
-                items: {
-                    type: string;
-                };
-                description: string;
-            };
-            repoName: {
-                type: string;
-                description: string;
-            };
-            description: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-        additionalProperties: boolean;
-    };
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
-    private saveUpdateHistory;
-    private createRemoteHistory;
-    private formatHistoryIssue;
-}

package/dist/tools/gitUpdate.js

@@ -1,474 +0,0 @@
-import { MCPError } from '../utils/errors.js';
-import axios from 'axios';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { getRepoNameFromPath } from '../utils/repoHelpers.js';
-/**
- * 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
- */
-export 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';
-        this.inputSchema = {
-            type: "object",
-            properties: {
-                projectPath: {
-                    type: "string",
-                    description: "The absolute path to the Git repository directory on the local filesystem. This should be the root directory containing the .git folder. For example: '/home/user/my-project' on Linux/Mac or 'C:\\Users\\user\\my-project' on Windows."
-                },
-                private: {
-                    type: "boolean",
-                    description: "Make repository private when auto-creating (optional, default: true)"
-                },
-                owner: {
-                    type: "string",
-                    description: "Repository owner for providers (optional, uses env vars)"
-                },
-                message: {
-                    type: "string",
-                    description: "Commit message"
-                },
-                commitMessage: {
-                    type: "string",
-                    description: "Commit message (alias)"
-                },
-                branch: {
-                    type: "string",
-                    description: "Branch name"
-                },
-                files: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Files to add"
-                },
-                repoName: {
-                    type: "string",
-                    description: "Repository name"
-                },
-                description: {
-                    type: "string",
-                    description: "Repository description"
-                }
-            },
-            required: ["projectPath"],
-            additionalProperties: true
-        };
-    }
-    async handle(params, ctx) {
-        const projectPath = params.projectPath;
-        if (!projectPath) {
-            throw new MCPError('VALIDATION_ERROR', 'projectPath is required');
-        }
-        if (!ctx.gitAdapter) {
-            throw new MCPError('INTERNAL_ERROR', 'Git adapter not available');
-        }
-        const commitMessage = params.message || params.commitMessage || `[git-update] Update at ${new Date().toISOString()}`;
-        const branch = params.branch || 'master';
-        const files = params.files || ['.'];
-        // 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 ctx.gitAdapter.status(projectPath);
-            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(),
-            });
-            // Isomorphic git diff is basic, so we rely on status for changed files list
-            results.traceability.changedFiles = preStatus.files.map(f => ({
-                status: f.working_dir,
-                file: f.path
-            }));
-            // 3. Add files
-            results.traceability.updateSteps.push({
-                step: 3,
-                action: 'stage_changes',
-                timestamp: new Date().toISOString(),
-                files,
-            });
-            await ctx.gitAdapter.add(projectPath, files);
-            // 4. Commit
-            results.traceability.updateSteps.push({
-                step: 4,
-                action: 'commit',
-                timestamp: new Date().toISOString(),
-                message: commitMessage,
-            });
-            let commitResult;
-            try {
-                const sha = await ctx.gitAdapter.commit(projectPath, commitMessage);
-                commitResult = {
-                    commit: sha,
-                    summary: { changes: 0, insertions: 0, deletions: 0 }, // Basic adapter doesn't return stats yet
-                    branch: await ctx.gitAdapter.getCurrentBranch(projectPath),
-                    author: { name: 'unknown', email: 'unknown' } // We could fetch this if needed
-                };
-                results.traceability.commit = {
-                    hash: commitResult.commit,
-                    summary: commitResult.summary,
-                    branch: commitResult.branch,
-                    author: commitResult.author,
-                };
-            }
-            catch (err) {
-                if (err.message.includes('nothing to commit') || (preStatus.isClean && files[0] === '.')) {
-                    results.traceability.commit = { message: 'No changes to commit' };
-                }
-                else {
-                    throw err;
-                }
-            }
-            // 5. Get remotes and ensure repos exist
-            const remotes = await ctx.gitAdapter.listRemotes(projectPath);
-            let githubRemote = remotes.find(r => r.name === 'github' || r.name === 'origin');
-            let giteaRemote = remotes.find(r => r.name === 'gitea');
-            // Auto-create repos if they don't exist
-            const repoName = params.repoName || getRepoNameFromPath(projectPath);
-            const description = params.description || `Project updated via git-update at ${new Date().toISOString()}`;
-            const isPrivate = params.private !== undefined ? params.private : true;
-            const githubOwner = params.owner || process.env.GITHUB_USERNAME;
-            const giteaOwner = process.env.GITEA_USERNAME;
-            // 5a. Ensure GitHub repo exists
-            if (ctx.providerManager.github && !githubRemote) {
-                results.traceability.updateSteps.push({
-                    step: 5,
-                    action: 'ensure_github_repo',
-                    timestamp: new Date().toISOString(),
-                });
-                try {
-                    // Try to get repo, create if doesn't exist
-                    let repoExists = false;
-                    try {
-                        await ctx.providerManager.github.rest.repos.get({
-                            owner: githubOwner,
-                            repo: repoName
-                        });
-                        repoExists = true;
-                    }
-                    catch { }
-                    if (!repoExists) {
-                        await ctx.providerManager.github.rest.repos.createForAuthenticatedUser({
-                            name: repoName,
-                            description,
-                            private: isPrivate,
-                            auto_init: false,
-                        });
-                        results.traceability.updateSteps.push({
-                            step: 5.1,
-                            action: 'created_github_repo',
-                            timestamp: new Date().toISOString(),
-                            repo: repoName,
-                        });
-                    }
-                    // Add remote
-                    const url = `https://github.com/${githubOwner}/${repoName}.git`;
-                    await ctx.gitAdapter.addRemote(projectPath, 'github', url);
-                    githubRemote = { name: 'github', remote: 'github', url, fetch: url };
-                }
-                catch (err) {
-                    results.traceability.errors.push({
-                        provider: 'github',
-                        action: 'ensure_repo',
-                        error: err.message,
-                        timestamp: new Date().toISOString(),
-                    });
-                }
-            }
-            // 5b. Ensure Gitea repo exists
-            if (ctx.providerManager.giteaBaseUrl && !giteaRemote) {
-                results.traceability.updateSteps.push({
-                    step: 5.5,
-                    action: 'ensure_gitea_repo',
-                    timestamp: new Date().toISOString(),
-                });
-                try {
-                    // Try to get repo, create if doesn't exist
-                    let repoExists = false;
-                    try {
-                        await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repoName}`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
-                        repoExists = true;
-                    }
-                    catch { }
-                    if (!repoExists) {
-                        await axios.post(`${ctx.providerManager.giteaBaseUrl}/api/v1/user/repos`, {
-                            name: repoName,
-                            description,
-                            private: isPrivate,
-                            auto_init: false,
-                        }, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
-                        results.traceability.updateSteps.push({
-                            step: 5.6,
-                            action: 'created_gitea_repo',
-                            timestamp: new Date().toISOString(),
-                            repo: repoName,
-                        });
-                    }
-                    // Add remote
-                    const url = `${ctx.providerManager.giteaBaseUrl}/${giteaOwner}/${repoName}.git`;
-                    await ctx.gitAdapter.addRemote(projectPath, 'gitea', url);
-                    giteaRemote = { name: 'gitea', remote: 'gitea', url, fetch: url };
-                }
-                catch (err) {
-                    results.traceability.errors.push({
-                        provider: 'gitea',
-                        action: 'ensure_repo',
-                        error: err.message,
-                        timestamp: new Date().toISOString(),
-                    });
-                }
-            }
-            // 6. Push to GITHUB
-            if (githubRemote && ctx.providerManager.github) {
-                results.traceability.updateSteps.push({
-                    step: 6,
-                    action: 'push_to_github',
-                    timestamp: new Date().toISOString(),
-                    remote: githubRemote.name,
-                    branch,
-                });
-                try {
-                    await ctx.gitAdapter.push(projectPath, githubRemote.name, branch);
-                    results.providers.github = {
-                        success: true,
-                        remote: githubRemote.name,
-                        url: githubRemote.url,
-                        pushed: true,
-                        pushResult: {
-                            message: 'Push successful'
-                        }
-                    };
-                    // Verificar commit no GitHub via API
-                    try {
-                        if (results.traceability.commit?.hash) {
-                            const githubOwner = params.owner || process.env.GITHUB_USERNAME;
-                            const repo = getRepoNameFromPath(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: 7,
-                    action: 'push_to_gitea',
-                    timestamp: new Date().toISOString(),
-                    remote: giteaRemote.name,
-                    branch,
-                });
-                try {
-                    await ctx.gitAdapter.push(projectPath, giteaRemote.name, branch);
-                    results.providers.gitea = {
-                        success: true,
-                        remote: giteaRemote.name,
-                        url: giteaRemote.url,
-                        pushed: true,
-                        pushResult: {
-                            message: 'Push successful'
-                        }
-                    };
-                    // Verificar commit no Gitea via API
-                    try {
-                        if (results.traceability.commit?.hash) {
-                            const giteaOwner = params.owner || process.env.GITEA_USERNAME;
-                            const repo = getRepoNameFromPath(projectPath);
-                            const commitInfo = await axios.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 ctx.gitAdapter.status(projectPath);
-            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 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 remotes = await ctx.gitAdapter.listRemotes(projectPath);
-        let repoName = getRepoNameFromPath(projectPath); // fallback
-        if (remotes.length > 0) {
-            const githubRemote = remotes.find(r => r.name === 'github') || remotes.find(r => r.name === 'origin') || remotes[0];
-            const match = githubRemote.fetch?.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.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*
-`;
-    }
-}

package/dist/tools/gitUpload.d.ts

@@ -1,35 +0,0 @@
-import { Tool, MCPContext } from '../types.js';
-/**
- * Git Upload Tool - Envia projeto completo para GitHub e Gitea automaticamente
- * Modo DUAL automático com rastreabilidade completa
- * VERSÃO SEGURA: Remove tokens das URLs e usa autenticação segura
- */
-export declare class GitUploadTool implements Tool {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            projectPath: {
-                type: string;
-                description: string;
-            };
-            description: {
-                type: string;
-                description: string;
-            };
-            private: {
-                type: string;
-                description: string;
-            };
-            repoName: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-        additionalProperties: boolean;
-    };
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
-    private saveUploadHistory;
-}