@andrebuzeli/git-mcp 6.2.3 → 6.3.0

package/dist/index.js

@@ -29,6 +29,7 @@ const gitAnalytics_1 = require("./tools/gitAnalytics");
 const gitUpload_1 = require("./tools/gitUpload");
 const gitUpdate_1 = require("./tools/gitUpdate");
 const gitHistory_1 = require("./tools/gitHistory");
+const gitFix_tool_1 = require("./tools/gitFix.tool");
 const toolsGuide_1 = __importDefault(require("./resources/toolsGuide"));
 async function main() {
     // Load optional mcp.json configuration (will populate process.env if values present)
@@ -40,7 +41,7 @@ async function main() {
     if (process.env.DEBUG) {
         console.error('Provider validation:', JSON.stringify(validation, null, 2));
     }
-    // Register all 20 Git tools
+    // Register all 21 Git tools
     const tools = [
         new gitWorkflow_1.GitWorkflowTool(),
         new gitFiles_1.GitFilesTool(),
@@ -62,6 +63,7 @@ async function main() {
         new gitUpload_1.GitUploadTool(),
         new gitUpdate_1.GitUpdateTool(),
         new gitHistory_1.GitHistoryTool(),
+        new gitFix_tool_1.GitFixTool(),
     ];
     // Register resources
     const resources = [
@@ -75,7 +77,7 @@ async function main() {
     // Create MCP Server with STDIO transport
     const server = new index_js_1.Server({
         name: '@andrebuzeli/git-mcp',
-        version: '6.2.2',
+        version: '6.3.0',
     });
     // Register tool list handler
     server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {

package/dist/tools/gitFix.d.ts

@@ -0,0 +1,3 @@
+export declare function handleGitFix(args: any): Promise<{
+    content: any[];
+}>;

package/dist/tools/gitFix.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGitFix = handleGitFix;
+const simple_git_1 = __importDefault(require("simple-git"));
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const fs_1 = require("fs");
+async function handleGitFix(args) {
+    try {
+        const { projectPath, githubRepo, giteaRepo, autoDetect = true } = args;
+        if (!projectPath) {
+            throw new Error('projectPath é obrigatório');
+        }
+        const absolutePath = path_1.default.resolve(projectPath);
+        if (!(0, fs_1.existsSync)(absolutePath)) {
+            throw new Error(`Caminho não existe: ${absolutePath}`);
+        }
+        const git = (0, simple_git_1.default)(absolutePath);
+        const result = {
+            success: false,
+            projectPath: absolutePath,
+            fixed: [],
+            warnings: [],
+            errors: [],
+            remotes: {
+                before: [],
+                after: []
+            }
+        };
+        // Verificar se é um repositório Git
+        let isGitRepo = false;
+        try {
+            await git.status();
+            isGitRepo = true;
+            result.fixed.push('✅ Repositório Git válido encontrado');
+        }
+        catch (err) {
+            if (err.message.includes('not a git repository')) {
+                result.warnings.push('⚠️  Não é um repositório Git - inicializando...');
+                await git.init();
+                result.fixed.push('✅ Git inicializado');
+                isGitRepo = true;
+            }
+            else {
+                throw err;
+            }
+        }
+        // Capturar remotes antes
+        const remotesBefore = await git.getRemotes(true);
+        result.remotes.before = remotesBefore.map(r => ({ name: r.name, url: r.refs.fetch || '' }));
+        // Auto-detectar repos se solicitado
+        let finalGithubRepo = githubRepo;
+        let finalGiteaRepo = giteaRepo;
+        if (autoDetect && remotesBefore.length > 0) {
+            for (const remote of remotesBefore) {
+                const url = remote.refs.fetch || '';
+                if (url.includes('github.com') && !finalGithubRepo) {
+                    const match = url.match(/github\.com[:/]([^/]+)\/([^/.]+)/);
+                    if (match) {
+                        finalGithubRepo = `${match[1]}/${match[2]}`;
+                        result.fixed.push(`🔍 GitHub repo auto-detectado: ${finalGithubRepo}`);
+                    }
+                }
+                if ((url.includes('nas-ubuntu') || url.includes('gitea')) && !finalGiteaRepo) {
+                    const match = url.match(/\/([^/]+)\/([^/.]+)(?:\.git)?$/);
+                    if (match) {
+                        finalGiteaRepo = `${match[1]}/${match[2]}`;
+                        result.fixed.push(`🔍 Gitea repo auto-detectado: ${finalGiteaRepo}`);
+                    }
+                }
+            }
+        }
+        // Obter username dos remotes existentes ou env vars
+        const githubUsername = process.env.GITHUB_USERNAME || 'andrebuzeli';
+        const giteaUsername = process.env.GITEA_USERNAME || 'andrebuzeli';
+        // Se não detectou repos, usar o nome da pasta
+        if (!finalGithubRepo) {
+            const folderName = path_1.default.basename(absolutePath);
+            finalGithubRepo = `${githubUsername}/${folderName}`;
+            result.warnings.push(`⚠️  GitHub repo não detectado - usando: ${finalGithubRepo}`);
+        }
+        if (!finalGiteaRepo) {
+            const folderName = path_1.default.basename(absolutePath);
+            finalGiteaRepo = `${giteaUsername}/${folderName}`;
+            result.warnings.push(`⚠️  Gitea repo não detectado - usando: ${finalGiteaRepo}`);
+        }
+        // Remover remotes antigos
+        const remotesToRemove = ['origin', 'github', 'gitea'];
+        for (const remoteName of remotesToRemove) {
+            const exists = remotesBefore.find(r => r.name === remoteName);
+            if (exists) {
+                await git.removeRemote(remoteName);
+                result.fixed.push(`🗑️  Removido remote antigo: ${remoteName}`);
+            }
+        }
+        // Adicionar novos remotes no padrão dual
+        const giteaUrl = process.env.GITEA_URL || 'http://nas-ubuntu:9999';
+        const githubUrl = `https://github.com/${finalGithubRepo}.git`;
+        const giteaRepoUrl = `${giteaUrl}/${finalGiteaRepo}.git`;
+        await git.addRemote('github', githubUrl);
+        result.fixed.push(`✅ Adicionado remote GitHub: ${githubUrl}`);
+        await git.addRemote('gitea', giteaRepoUrl);
+        result.fixed.push(`✅ Adicionado remote Gitea: ${giteaRepoUrl}`);
+        // Configurar origin como push múltiplo
+        await git.addRemote('origin', githubUrl);
+        await git.addConfig('remote.origin.pushurl', giteaRepoUrl, false, 'local');
+        result.fixed.push(`✅ Configurado origin para push dual (GitHub + Gitea)`);
+        // Capturar remotes depois
+        const remotesAfter = await git.getRemotes(true);
+        result.remotes.after = remotesAfter.map(r => ({ name: r.name, url: r.refs.fetch || '' }));
+        // Verificar se há commits
+        try {
+            await git.log();
+            result.fixed.push('✅ Histórico de commits preservado');
+        }
+        catch (err) {
+            result.warnings.push('⚠️  Sem commits ainda - faça o primeiro commit');
+        }
+        // Criar/atualizar .gitignore se necessário
+        const gitignorePath = path_1.default.join(absolutePath, '.gitignore');
+        if (!(0, fs_1.existsSync)(gitignorePath)) {
+            const defaultGitignore = `node_modules/
+dist/
+.env
+*.log
+.DS_Store
+`;
+            await promises_1.default.writeFile(gitignorePath, defaultGitignore, 'utf-8');
+            result.fixed.push('✅ Criado .gitignore padrão');
+        }
+        result.success = true;
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2)
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: false,
+                        error: error.message,
+                        stack: error.stack
+                    }, null, 2)
+                }]
+        };
+    }
+}

package/dist/tools/gitFix.tool.d.ts

@@ -0,0 +1,8 @@
+import { Tool } from '../types';
+export declare class GitFixTool implements Tool {
+    name: string;
+    description: string;
+    handle(args: any): Promise<{
+        content: any[];
+    }>;
+}

package/dist/tools/gitFix.tool.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitFixTool = void 0;
+const gitFix_1 = require("./gitFix");
+class GitFixTool {
+    constructor() {
+        this.name = 'git-fix';
+        this.description = `Fix local Git repository to work with dual-provider system (GitHub + Gitea).
+
+🔧 WHAT IT DOES:
+- Converts existing Git repos to dual-provider system
+- Auto-detects GitHub/Gitea remotes from existing configuration
+- Removes old remotes and configures new dual-push system
+- Initializes Git if not already a repository
+- Creates standard .gitignore if missing
+
+📋 PARAMETERS:
+- projectPath (required): Absolute path to the Git repository
+- githubRepo (optional): GitHub repo in format "owner/repo" (auto-detected if not provided)
+- giteaRepo (optional): Gitea repo in format "owner/repo" (auto-detected if not provided)
+- autoDetect (optional): Auto-detect repos from existing remotes (default: true)
+
+🎯 WHEN TO USE:
+- You have an existing Git repo not configured for dual-provider
+- Need to migrate from single remote to dual-push system
+- Want to standardize repo configuration for git-mcp tools
+
+✅ WHAT GETS FIXED:
+1. Verifies/initializes Git repository
+2. Captures current remotes (before)
+3. Auto-detects GitHub/Gitea repos from URLs
+4. Removes old remotes (origin, github, gitea)
+5. Adds new 'github' remote
+6. Adds new 'gitea' remote
+7. Configures 'origin' for dual-push (GitHub + Gitea)
+8. Creates .gitignore if missing
+9. Shows before/after comparison
+
+📊 RESULT STRUCTURE:
+{
+  success: boolean,
+  projectPath: string,
+  fixed: string[],        // Actions performed
+  warnings: string[],     // Non-critical issues
+  errors: string[],       // Critical issues
+  remotes: {
+    before: [...],        // Remotes before fix
+    after: [...]          // Remotes after fix
+  }
+}
+
+💡 EXAMPLE:
+{
+  "projectPath": "/path/to/my-project",
+  "autoDetect": true
+}
+
+🔍 AUTO-DETECTION:
+- Scans existing remotes for github.com URLs → extracts owner/repo
+- Scans existing remotes for Gitea URLs → extracts owner/repo
+- Falls back to folder name if no remotes found
+
+⚠️ REQUIREMENTS:
+- GITHUB_USERNAME and GITEA_USERNAME env vars for fallback
+- GITEA_URL env var (default: http://nas-ubuntu:9999)
+- Git must be installed and accessible
+`;
+    }
+    async handle(args) {
+        return (0, gitFix_1.handleGitFix)(args);
+    }
+}
+exports.GitFixTool = GitFixTool;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andrebuzeli/git-mcp",
-  "version": "6.2.3",
+  "version": "6.3.0",
   "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)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",