@andrebuzeli/git-mcp 9.1.0 → 10.0.0

package/dist/tools/gitFix.js

@@ -1,7 +1,8 @@
+import simpleGit from 'simple-git';
 import path from 'path';
 import fs from 'fs/promises';
 import { existsSync } from 'fs';
-export async function handleGitFix(args, git, providerManager) {
+export async function handleGitFix(args) {
     try {
         const { projectPath, githubRepo, giteaRepo, autoDetect = true } = args;
         if (!projectPath) {
@@ -11,6 +12,7 @@ export async function handleGitFix(args, git, providerManager) {
         if (!existsSync(absolutePath)) {
             throw new Error(`Caminho não existe: ${absolutePath}`);
         }
+        const git = simpleGit(absolutePath);
         const result = {
             success: false,
             projectPath: absolutePath,
@@ -25,14 +27,14 @@ export async function handleGitFix(args, git, providerManager) {
         // Verificar se é um repositório Git
         let isGitRepo = false;
         try {
-            await git.status(absolutePath);
+            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(absolutePath);
+                await git.init();
                 result.fixed.push('✅ Git inicializado');
                 isGitRepo = true;
             }
@@ -41,18 +43,21 @@ export async function handleGitFix(args, git, providerManager) {
             }
         }
         // Capturar remotes antes
-        const remotesBefore = await git.listRemotes(absolutePath);
-        result.remotes.before = remotesBefore.map(r => ({ name: r.name, url: r.url }));
-        // Obter usernames automaticamente (API ou env vars)
-        const githubUsername = await providerManager.getGitHubUsername();
-        const giteaUsername = await providerManager.getGiteaUsername();
+        const remotesBefore = await git.getRemotes(true);
+        result.remotes.before = remotesBefore.map(r => ({ name: r.name, url: r.refs.fetch || '' }));
+        // Obter usernames das env vars (OBRIGATÓRIO usar as credenciais fornecidas)
+        const githubUsername = process.env.GITHUB_USERNAME;
+        const giteaUsername = process.env.GITEA_USERNAME;
+        if (!githubUsername || !giteaUsername) {
+            throw new Error('GITHUB_USERNAME e GITEA_USERNAME são obrigatórios nas env vars');
+        }
         // Auto-detectar repos se solicitado
         let finalGithubRepo = githubRepo;
         let finalGiteaRepo = giteaRepo;
         let detectedRepoName = null;
         if (autoDetect && remotesBefore.length > 0) {
             for (const remote of remotesBefore) {
-                const url = remote.url || '';
+                const url = remote.refs.fetch || '';
                 // Detectar APENAS o nome do repo (sem username)
                 if (url.includes('github.com') && !detectedRepoName) {
                     const match = url.match(/github\.com[:/][^/]+\/([^/.]+)/);
@@ -96,63 +101,29 @@ export async function handleGitFix(args, git, providerManager) {
         for (const remoteName of remotesToRemove) {
             const exists = remotesBefore.find(r => r.name === remoteName);
             if (exists) {
-                await git.removeRemote(absolutePath, remoteName);
+                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 giteaToken = process.env.GITEA_TOKEN;
-        const githubToken = process.env.GITHUB_TOKEN;
-        // Build GitHub URL
-        let githubUrl = `https://github.com/${finalGithubRepo}.git`;
-        if (githubToken) {
-            // Use token for private repos or to avoid 2FA prompts
-            githubUrl = `https://${githubToken}@github.com/${finalGithubRepo}.git`;
-        }
-        // Build Gitea URL - support both HTTP and HTTPS (Cloudflare Tunnels)
-        let giteaRepoUrl;
-        if (giteaToken) {
-            const parsedGiteaUrl = new URL(giteaUrl);
-            const protocol = parsedGiteaUrl.protocol;
-            const host = parsedGiteaUrl.host;
-            if (protocol === 'https:') {
-                // HTTPS (Cloudflare Tunnel): use token-based auth
-                giteaRepoUrl = `${protocol}//${giteaToken}@${host}/${finalGiteaRepo}.git`;
-            }
-            else {
-                // HTTP: use username:token format
-                giteaRepoUrl = `${protocol}//${giteaUsername}:${giteaToken}@${host}/${finalGiteaRepo}.git`;
-            }
-        }
-        else {
-            // No token - use basic URL (will prompt for credentials)
-            giteaRepoUrl = `${giteaUrl}/${finalGiteaRepo}.git`;
-        }
-        await git.addRemote(absolutePath, 'github', githubUrl);
-        result.fixed.push(`✅ Adicionado remote GitHub: ${githubUrl.replace(githubToken || '', '***')}`);
-        await git.addRemote(absolutePath, 'gitea', giteaRepoUrl);
-        result.fixed.push(`✅ Adicionado remote Gitea: ${giteaRepoUrl.replace(giteaToken || '', '***')}`);
+        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(absolutePath, 'origin', githubUrl);
-        // Configure dual push URL using shell command (not supported by isomorphic-git)
-        const { exec } = await import('child_process');
-        const { promisify } = await import('util');
-        const execAsync = promisify(exec);
-        await execAsync(`git -C "${absolutePath}" config --add remote.origin.pushurl "${giteaRepoUrl}"`);
+        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.listRemotes(absolutePath);
-        result.remotes.after = remotesAfter.map(r => ({ name: r.name, url: r.url }));
+        const remotesAfter = await git.getRemotes(true);
+        result.remotes.after = remotesAfter.map(r => ({ name: r.name, url: r.refs.fetch || '' }));
         // Verificar se há commits
         try {
-            const log = await git.log(absolutePath);
-            if (log.length > 0) {
-                result.fixed.push('✅ Histórico de commits preservado');
-            }
-            else {
-                result.warnings.push('⚠️  Sem commits ainda - faça o primeiro commit');
-            }
+            await git.log();
+            result.fixed.push('✅ Histórico de commits preservado');
         }
         catch (err) {
             result.warnings.push('⚠️  Sem commits ainda - faça o primeiro commit');
@@ -160,11 +131,11 @@ export async function handleGitFix(args, git, providerManager) {
         // Criar/atualizar .gitignore se necessário
         const gitignorePath = path.join(absolutePath, '.gitignore');
         if (!existsSync(gitignorePath)) {
-            const defaultGitignore = `node_modules/
-dist/
-.env
-*.log
-.DS_Store
+            const defaultGitignore = `node_modules/
+dist/
+.env
+*.log
+.DS_Store
 `;
             await fs.writeFile(gitignorePath, defaultGitignore, 'utf-8');
             result.fixed.push('✅ Criado .gitignore padrão');
@@ -190,4 +161,3 @@ dist/
         };
     }
 }
-//# sourceMappingURL=gitFix.js.map

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

@@ -1,32 +1,8 @@
-import { Tool, MCPContext } from '../types.js';
+import { Tool } from '../types.js';
 export declare class GitFixTool implements Tool {
     name: string;
     description: string;
-    inputSchema: {
-        type: string;
-        properties: {
-            projectPath: {
-                type: string;
-                description: string;
-            };
-            githubRepo: {
-                type: string;
-                description: string;
-            };
-            giteaRepo: {
-                type: string;
-                description: string;
-            };
-            autoDetect: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-        additionalProperties: boolean;
-    };
-    handle(args: any, ctx: MCPContext): Promise<{
+    handle(args: any): Promise<{
         content: any[];
     }>;
 }
-//# sourceMappingURL=gitFix.tool.d.ts.map

package/dist/tools/gitFix.tool.js

@@ -2,92 +2,68 @@ import { handleGitFix } from './gitFix.js';
 export 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
+        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
 `;
-        this.inputSchema = {
-            type: "object",
-            properties: {
-                projectPath: {
-                    type: "string",
-                    description: "Absolute path to the Git repository (REQUIRED)"
-                },
-                githubRepo: {
-                    type: "string",
-                    description: "GitHub repo in format 'owner/repo' (optional, auto-detected)"
-                },
-                giteaRepo: {
-                    type: "string",
-                    description: "Gitea repo in format 'owner/repo' (optional, auto-detected)"
-                },
-                autoDetect: {
-                    type: "boolean",
-                    description: "Auto-detect repos from existing remotes (default: true)"
-                }
-            },
-            required: ["projectPath"],
-            additionalProperties: true
-        };
     }
-    async handle(args, ctx) {
-        return handleGitFix(args, ctx.gitAdapter, ctx.providerManager);
+    async handle(args) {
+        return handleGitFix(args);
     }
 }
-//# sourceMappingURL=gitFix.tool.js.map

package/dist/tools/gitHistory.d.ts

@@ -1,17 +1,12 @@
 import { Tool, MCPContext } from '../types.js';
+/**
+ * Git History Tool - Mantém histórico detalhado de TODAS alterações
+ * Modo DUAL automático - cria issues de histórico em GitHub e Gitea
+ * Rastreabilidade completa de cada mudança local
+ */
 export declare class GitHistoryTool implements Tool {
     name: string;
     description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            projectPath: {
-                type: string;
-            };
-        };
-        required: string[];
-        additionalProperties: boolean;
-    };
     handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
     private trackChange;
     private listLocalHistory;
@@ -19,12 +14,4 @@ export declare class GitHistoryTool implements Tool {
     private generateReport;
     private saveLocalHistory;
     private formatHistoryBody;
-    private generateChangelog;
-    private groupCommitsByType;
-    private formatKeepAChangelog;
-    private formatConventionalChangelog;
-    private getHistoryEntry;
-    private searchHistory;
-    private getStats;
 }
-//# sourceMappingURL=gitHistory.d.ts.map