@andre.buzeli/git-mcp 16.0.6 → 16.1.2

package/src/utils/gitAdapter.js

@@ -7,12 +7,10 @@ import { getRepoNameFromPath, getProvidersEnv, findGitRoot } from "./repoHelpers
 // Common locations for Git on Windows, Linux, and macOS
 const GIT_CANDIDATES = [
     // Windows paths
-    "C:\\Program Files\\Git\\mingw64\\bin\\git.exe",
-    "C:\\Program Files\\Git\\bin\\git.exe",
     "C:\\Program Files\\Git\\cmd\\git.exe",
-    "C:\\Users\\andre\\AppData\\Local\\Programs\\Git\\mingw64\\bin\\git.exe",
-    "C:\\Users\\andre\\AppData\\Local\\Programs\\Git\\bin\\git.exe",
-    "C:\\Users\\andre\\AppData\\Local\\Programs\\Git\\cmd\\git.exe",
+    "C:\\Program Files\\Git\\bin\\git.exe",
+    "C:\\Program Files\\Git\\mingw64\\bin\\git.exe",
+    "C:\\Program Files (x86)\\Git\\cmd\\git.exe",
     // Linux/macOS paths
     "/usr/bin/git",
     "/usr/local/bin/git",
@@ -616,9 +614,16 @@ export class GitAdapter {
     }
 
     async pushParallel(dir, branch, force = false, organization) {
-        await this.ensureRemotes(dir, { organization });
+        // Check if remotes already configured (caller may have set correct fallback URLs)
         const remotesStr = await this._exec(dir, ["remote"]);
-        const remotes = remotesStr.split("\n").filter(r => ["github", "gitea"].includes(r.trim()));
+        let remotes = remotesStr.split("\n").filter(r => ["github", "gitea"].includes(r.trim()));
+
+        // Only setup remotes if none exist — caller is responsible for correct URLs
+        if (remotes.length === 0) {
+            await this.ensureRemotes(dir, { organization });
+            const newStr = await this._exec(dir, ["remote"]);
+            remotes = newStr.split("\n").filter(r => ["github", "gitea"].includes(r.trim()));
+        }
 
         if (remotes.length === 0) {
             throw createError("REMOTE_NOT_FOUND", { message: "Nenhum remote github/gitea configurado" });
@@ -643,10 +648,13 @@ export class GitAdapter {
                     try {
                         console.error(`[GitAdapter] Auto-fix: repositório não existe no remote '${remote}', criando automaticamente...`);
                         const repoName = getRepoNameFromPath(dir);
-                        const ensured = await this.pm.ensureRepos({ repoName, createIfMissing: true, isPublic: false });
+                        const ensured = await this.pm.ensureRepos({ repoName, createIfMissing: true, isPublic: false, organization });
 
-                        // Atualiza remotes após criar repo
-                        await this.ensureRemotes(dir, {});
+                        // Atualiza remotes após criar repo — use actual result URLs
+                        const ghUrl = ensured.github?.ok && ensured.github.repo ? `https://github.com/${ensured.github.repo}.git` : "";
+                        const gtBase = this.pm.giteaUrl?.replace(/\/$/, "");
+                        const gtUrl = ensured.gitea?.ok && ensured.gitea.repo && gtBase ? `${gtBase}/${ensured.gitea.repo}.git` : "";
+                        await this.ensureRemotes(dir, { githubUrl: ghUrl, giteaUrl: gtUrl, organization });
 
                         // Tenta push novamente
                         await this.pushOne(dir, remote, branch, force, true); // Usa -u para criar branch também
@@ -953,7 +961,6 @@ export class GitAdapter {
     // ============ DIFF/CLONE ============
     async diff(dir, options = {}) { return await this._exec(dir, ["diff"]); }
     async diffCommits(dir, from, to) { return await this._exec(dir, ["diff", from, to]); }
-    async diffStats(dir, from, to) { const out = await this._exec(dir, ["diff", "--stat", from, to]); return { message: out }; }
 
     async clone(url, dir, options = {}) {
         const { branch, depth, singleBranch } = options;
@@ -1022,6 +1029,121 @@ export class GitAdapter {
         return Array.from(map.values());
     }
 
+    // ============ WORKTREE ============
+
+    async addWorktree(dir, branch, worktreePath) {
+        // Verifica se branch já existe
+        const branches = await this.listBranches(dir);
+        const branchExists = branches.includes(branch);
+
+        const args = ["worktree", "add"];
+        // Se branch não existe, cria com -b. Se existe, usa checkout normal (sem flag)
+        if (!branchExists) {
+            args.push("-b", branch);
+        }
+        args.push(worktreePath, branch);
+
+        await this._exec(dir, args);
+    }
+
+    async listWorktrees(dir) {
+        try {
+            const out = await this._exec(dir, ["worktree", "list", "--porcelain"]);
+            const worktrees = [];
+            let current = {};
+
+            const lines = out.split("\n");
+            for (const line of lines) {
+                if (!line.trim()) {
+                    if (current.worktree) {
+                        worktrees.push(current);
+                        current = {};
+                    }
+                    continue;
+                }
+
+                const [key, ...rest] = line.split(" ");
+                const value = rest.join(" ");
+
+                if (key === "worktree") {
+                    if (current.worktree) worktrees.push(current);
+                    current = { worktree: value };
+                } else if (key === "branch") {
+                    current.branch = value.replace("refs/heads/", "");
+                } else if (key === "HEAD") {
+                    current.head = value;
+                }
+            }
+            if (current.worktree) worktrees.push(current);
+
+            return worktrees.map(w => ({
+                path: w.worktree,
+                branch: w.branch,
+                head: w.head
+            }));
+        } catch (e) {
+            // Fallback para versão antiga do git se --porcelain falhar
+            const out = await this._exec(dir, ["worktree", "list"]);
+            return out.split("\n").filter(Boolean).map(line => {
+                const parts = line.split(/\s+/);
+                const path = parts.slice(0, -2).join(" "); // Path pode ter espaços
+                const head = parts[parts.length - 2];
+                const branchRaw = parts[parts.length - 1];
+                const branch = branchRaw.replace("[", "").replace("]", "");
+                return { path, head, branch };
+            });
+        }
+    }
+
+    async removeWorktree(dir, worktreePath) {
+        await this._exec(dir, ["worktree", "remove", worktreePath, "--force"]);
+    }
+
+    async pushRefspec(dir, remote, localBranch, remoteBranch, force = false) {
+        const remoteUrl = await this._exec(dir, ["remote", "get-url", remote]);
+        const header = this._getAuthHeader(remoteUrl);
+        const args = [];
+        if (header) args.push("-c", `http.extraHeader=${header}`);
+        args.push("push");
+        if (force) args.push("--force");
+        args.push(remote, `${localBranch}:${remoteBranch}`);
+        await this._exec(dir, args);
+    }
+
+    async getWorktreeConfigs(dir) {
+        try {
+            const configPath = path.join(dir, ".git", "config");
+            if (!fs.existsSync(configPath)) return [];
+
+            const content = fs.readFileSync(configPath, "utf8");
+            const results = [];
+            const sectionRegex = /\[worktree-branch "([^"]+)"\]([\s\S]*?)(?=\[|$)/g;
+
+            let match;
+            while ((match = sectionRegex.exec(content)) !== null) {
+                const branchName = match[1];
+                const body = match[2];
+                const wtPath = body.match(/path\s*=\s*(.+)/)?.[1]?.trim();
+                const channel = body.match(/channel\s*=\s*(.+)/)?.[1]?.trim() || "production";
+                if (branchName && wtPath) {
+                    results.push({ branch: branchName, path: wtPath, channel });
+                }
+            }
+            return results;
+        } catch (e) {
+            console.error("[GitAdapter] Error reading worktree configs:", e);
+            return [];
+        }
+    }
+
+    async setWorktreeConfig(dir, branchName, config) {
+        // Normalizar path para usar forward slashes (compatível com git config em windows)
+        const normalizedPath = config.path.replace(/\\/g, "/");
+        
+        await this._exec(dir, ["config", `worktree-branch.${branchName}.path`, normalizedPath]);
+        await this._exec(dir, ["config", `worktree-branch.${branchName}.channel`, config.channel || "production"]);
+    }
+
     // ============ GIT LFS SUPPORT ============
 
     /**

package/src/utils/mcpNotify.js

@@ -0,0 +1,45 @@
+// Helpers para notificações MCP com graceful degradation
+// Permite que o server funcione mesmo se o IDE não suportar features avançadas
+
+// sendProgress - envia notificacao de progresso
+export async function sendProgress(server, token, progress, total, message) {
+  if (!token) return;
+  try {
+    await server.notification({
+      method: "notifications/progress",
+      params: { progressToken: token, progress, total, message }
+    });
+  } catch (e) { /* IDE nao suporta — ignora */ }
+}
+
+// sendLog - envia log estruturado
+export async function sendLog(server, level, message, data) {
+  try {
+    await server.notification({
+      method: "notifications/message",
+      params: { level, logger: "git-mcp", data: data || message }
+    });
+  } catch (e) { /* IDE nao suporta — ignora */ }
+}
+
+// requestConfirmation - pede confirmacao via elicitation
+export async function requestConfirmation(server, message) {
+  try {
+    const result = await server.request(
+      { method: "elicitation/create", params: {
+        mode: "form",
+        message,
+        requestedSchema: {
+          type: "object",
+          properties: { confirm: { type: "string", enum: ["yes", "no"], title: "Confirmar?" } },
+          required: ["confirm"]
+        }
+      }},
+      /* schema de validacao opcional */ 
+    );
+    if (result.action === "accept" && result.content?.confirm === "yes") return true;
+    return false;
+  } catch (e) {
+    return true; // IDE nao suporta elicitation — prossegue sem confirmar (fail-open)
+  }
+}

package/src/utils/repoHelpers.js

@@ -179,38 +179,12 @@ export function detectProjectType(projectPath) {
 }
 
 /**
- * Executa uma operação com retries exponenciais
- * @param {Function} operation - Função assíncrona a executar
- * @param {number} maxRetries - Número máximo de tentativas
- * @param {string} context - Contexto para logs
- * @returns {Promise<any>} Resultado da operação
+ * Re-exporta withRetry de retry.js com adaptador para API legada (fn, maxRetries, context)
  */
+import { withRetry as _withRetry } from "./retry.js";
+
 export async function withRetry(operation, maxRetries = 3, context = "") {
-  let lastError;
-  for (let i = 0; i < maxRetries; i++) {
-    try {
-      return await operation();
-    } catch (e) {
-      lastError = e;
-      const msg = e.message || String(e);
-      // Retry on network errors, lock files, or timeouts
-      const isRetryable = msg.includes("lock") || 
-                          msg.includes("network") || 
-                          msg.includes("resolve host") || 
-                          msg.includes("timeout") || 
-                          msg.includes("connection") ||
-                          msg.includes("ECONNRESET") ||
-                          msg.includes("ETIMEDOUT");
-      
-      if (!isRetryable && i === 0) throw e; // Fail fast if not retryable and first attempt
-      
-      if (i < maxRetries - 1) {
-        const delay = 2000 * Math.pow(2, i);
-        console.warn(`[${context}] Attempt ${i + 1} failed, retrying in ${delay}ms... Error: ${msg}`);
-        await new Promise(r => setTimeout(r, delay));
-      }
-    }
-  }
-  throw lastError;
+  return _withRetry(operation, { maxRetries });
 }
 
+

package/src/utils/hooks.js

@@ -1,255 +0,0 @@
-// Sistema de Hooks para git-mcp
-// Permite executar código customizado antes/depois de operações
-
-/**
- * Tipos de hooks disponíveis
- */
-export const HOOK_TYPES = {
-  // Workflow hooks
-  PRE_INIT: "pre:init",
-  POST_INIT: "post:init",
-  PRE_COMMIT: "pre:commit",
-  POST_COMMIT: "post:commit",
-  PRE_PUSH: "pre:push",
-  POST_PUSH: "post:push",
-  PRE_PULL: "pre:pull",
-  POST_PULL: "post:pull",
-  
-  // Branch hooks
-  PRE_BRANCH_CREATE: "pre:branch:create",
-  POST_BRANCH_CREATE: "post:branch:create",
-  PRE_BRANCH_DELETE: "pre:branch:delete",
-  POST_BRANCH_DELETE: "post:branch:delete",
-  PRE_CHECKOUT: "pre:checkout",
-  POST_CHECKOUT: "post:checkout",
-  
-  // Merge hooks
-  PRE_MERGE: "pre:merge",
-  POST_MERGE: "post:merge",
-  ON_CONFLICT: "on:conflict",
-  
-  // Reset hooks
-  PRE_RESET: "pre:reset",
-  POST_RESET: "post:reset",
-  
-  // Remote hooks
-  PRE_SYNC: "pre:sync",
-  POST_SYNC: "post:sync",
-  
-  // Error handling
-  ON_ERROR: "on:error"
-};
-
-// Armazena hooks registrados
-const registeredHooks = new Map();
-
-/**
- * Registra um hook
- * @param {string} hookType - Tipo do hook (usar HOOK_TYPES)
- * @param {Function} handler - Função async (context) => result
- * @param {Object} options - { priority: number, name: string }
- * @returns {string} - ID do hook para remover depois
- */
-export function registerHook(hookType, handler, options = {}) {
-  const { priority = 0, name = "anonymous" } = options;
-  const hookId = `${hookType}_${name}_${Date.now()}`;
-  
-  if (!registeredHooks.has(hookType)) {
-    registeredHooks.set(hookType, []);
-  }
-  
-  registeredHooks.get(hookType).push({
-    id: hookId,
-    handler,
-    priority,
-    name
-  });
-  
-  // Ordena por prioridade (maior primeiro)
-  registeredHooks.get(hookType).sort((a, b) => b.priority - a.priority);
-  
-  return hookId;
-}
-
-/**
- * Remove um hook específico
- * @param {string} hookId - ID retornado por registerHook
- */
-export function unregisterHook(hookId) {
-  for (const [type, hooks] of registeredHooks.entries()) {
-    const index = hooks.findIndex(h => h.id === hookId);
-    if (index !== -1) {
-      hooks.splice(index, 1);
-      return true;
-    }
-  }
-  return false;
-}
-
-/**
- * Remove todos os hooks de um tipo
- * @param {string} hookType - Tipo do hook
- */
-export function clearHooks(hookType) {
-  if (hookType) {
-    registeredHooks.delete(hookType);
-  } else {
-    registeredHooks.clear();
-  }
-}
-
-/**
- * Executa todos os hooks de um tipo
- * @param {string} hookType - Tipo do hook
- * @param {Object} context - Contexto passado para os handlers
- * @returns {Object} - { success: boolean, results: [], errors: [] }
- */
-export async function runHooks(hookType, context = {}) {
-  const hooks = registeredHooks.get(hookType) || [];
-  
-  if (hooks.length === 0) {
-    return { success: true, results: [], errors: [], skipped: true };
-  }
-  
-  const results = [];
-  const errors = [];
-  let shouldContinue = true;
-  
-  for (const hook of hooks) {
-    if (!shouldContinue) break;
-    
-    try {
-      const result = await hook.handler({
-        ...context,
-        hookType,
-        hookName: hook.name
-      });
-      
-      results.push({
-        hookId: hook.id,
-        name: hook.name,
-        success: true,
-        result
-      });
-      
-      // Hook pode retornar { abort: true } para parar execução
-      if (result?.abort) {
-        shouldContinue = false;
-      }
-    } catch (error) {
-      errors.push({
-        hookId: hook.id,
-        name: hook.name,
-        error: error.message || String(error)
-      });
-      
-      // Por padrão, continua mesmo com erro
-      // Hook pode definir { stopOnError: true } nas options
-    }
-  }
-  
-  return {
-    success: errors.length === 0,
-    results,
-    errors,
-    aborted: !shouldContinue
-  };
-}
-
-/**
- * Wrapper para executar função com hooks pre/post
- * @param {string} operationType - Tipo da operação (ex: "commit", "push")
- * @param {Function} fn - Função principal async
- * @param {Object} context - Contexto para os hooks
- */
-export async function withHooks(operationType, fn, context = {}) {
-  const preHookType = `pre:${operationType}`;
-  const postHookType = `post:${operationType}`;
-  
-  // Pre-hooks
-  const preResult = await runHooks(preHookType, context);
-  if (preResult.aborted) {
-    return {
-      success: false,
-      abortedByHook: true,
-      hookResults: preResult,
-      message: `Operação abortada por hook ${preHookType}`
-    };
-  }
-  
-  // Operação principal
-  let mainResult;
-  let mainError = null;
-  
-  try {
-    mainResult = await fn();
-  } catch (error) {
-    mainError = error;
-    
-    // Executa hook de erro
-    await runHooks(HOOK_TYPES.ON_ERROR, {
-      ...context,
-      error: {
-        message: error.message,
-        code: error.code,
-        stack: error.stack
-      }
-    });
-    
-    throw error;
-  }
-  
-  // Post-hooks
-  const postResult = await runHooks(postHookType, {
-    ...context,
-    result: mainResult
-  });
-  
-  return mainResult;
-}
-
-/**
- * Lista todos os hooks registrados
- */
-export function listHooks() {
-  const list = {};
-  for (const [type, hooks] of registeredHooks.entries()) {
-    list[type] = hooks.map(h => ({
-      id: h.id,
-      name: h.name,
-      priority: h.priority
-    }));
-  }
-  return list;
-}
-
-/**
- * Verifica se há hooks registrados para um tipo
- */
-export function hasHooks(hookType) {
-  const hooks = registeredHooks.get(hookType);
-  return hooks && hooks.length > 0;
-}
-
-/**
- * Exemplo de registro de hooks
- */
-export function exampleHookSetup() {
-  // Hook para logging
-  registerHook(HOOK_TYPES.POST_COMMIT, async (ctx) => {
-    console.log(`[Hook] Commit criado: ${ctx.result?.sha}`);
-  }, { name: "commit-logger", priority: 10 });
-
-  // Hook para validação pré-push
-  registerHook(HOOK_TYPES.PRE_PUSH, async (ctx) => {
-    // Exemplo: verificar se branch é protegida
-    if (ctx.branch === "main" && !ctx.force) {
-      console.warn("[Hook] Push para main sem force - considere criar PR");
-    }
-  }, { name: "branch-protection", priority: 100 });
-
-  // Hook para notificação de erro
-  registerHook(HOOK_TYPES.ON_ERROR, async (ctx) => {
-    console.error(`[Hook] Erro: ${ctx.error?.message}`);
-  }, { name: "error-notifier", priority: 0 });
-}