@andre.buzeli/git-mcp 16.0.8 → 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",
@@ -963,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;
@@ -1032,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 });
-}

package/src/utils/metrics.js

@@ -1,198 +0,0 @@
-// Sistema de Métricas/Telemetria para git-mcp
-// Opt-in via variável de ambiente ENABLE_METRICS=true
-
-const metricsEnabled = process.env.ENABLE_METRICS === "true";
-
-// Armazena métricas em memória
-const metricsStore = {
-  operations: [],
-  errors: [],
-  startTime: Date.now(),
-  summary: {
-    totalOperations: 0,
-    successfulOperations: 0,
-    failedOperations: 0,
-    totalDurationMs: 0,
-    operationsByType: {}
-  }
-};
-
-/**
- * Registra início de uma operação
- * @param {string} operation - Nome da operação (ex: "git-workflow:push")
- * @param {Object} metadata - Metadados adicionais
- * @returns {string} - ID da operação para tracking
- */
-export function startOperation(operation, metadata = {}) {
-  if (!metricsEnabled) return null;
-  
-  const id = `${operation}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  
-  metricsStore.operations.push({
-    id,
-    operation,
-    startTime: Date.now(),
-    endTime: null,
-    duration: null,
-    status: "running",
-    metadata,
-    error: null
-  });
-  
-  return id;
-}
-
-/**
- * Finaliza uma operação
- * @param {string} id - ID da operação
- * @param {string} status - "success" ou "error"
- * @param {Error|null} error - Erro se houver
- */
-export function endOperation(id, status = "success", error = null) {
-  if (!metricsEnabled || !id) return;
-  
-  const op = metricsStore.operations.find(o => o.id === id);
-  if (!op) return;
-  
-  op.endTime = Date.now();
-  op.duration = op.endTime - op.startTime;
-  op.status = status;
-  
-  if (error) {
-    op.error = {
-      message: error.message || String(error),
-      code: error.code || "UNKNOWN"
-    };
-    metricsStore.errors.push({
-      timestamp: Date.now(),
-      operation: op.operation,
-      error: op.error
-    });
-    metricsStore.summary.failedOperations++;
-  } else {
-    metricsStore.summary.successfulOperations++;
-  }
-  
-  metricsStore.summary.totalOperations++;
-  metricsStore.summary.totalDurationMs += op.duration;
-  
-  // Atualiza contagem por tipo
-  const opType = op.operation.split(":")[0];
-  metricsStore.summary.operationsByType[opType] = 
-    (metricsStore.summary.operationsByType[opType] || 0) + 1;
-}
-
-/**
- * Wrapper para medir tempo de execução de uma função
- * @param {string} operation - Nome da operação
- * @param {Function} fn - Função async para executar
- * @param {Object} metadata - Metadados adicionais
- */
-export async function withMetrics(operation, fn, metadata = {}) {
-  const id = startOperation(operation, metadata);
-  
-  try {
-    const result = await fn();
-    endOperation(id, "success");
-    return result;
-  } catch (error) {
-    endOperation(id, "error", error);
-    throw error;
-  }
-}
-
-/**
- * Retorna resumo das métricas
- */
-export function getMetricsSummary() {
-  if (!metricsEnabled) {
-    return { enabled: false, message: "Métricas desabilitadas. Use ENABLE_METRICS=true para habilitar." };
-  }
-  
-  const uptimeMs = Date.now() - metricsStore.startTime;
-  const avgDuration = metricsStore.summary.totalOperations > 0
-    ? metricsStore.summary.totalDurationMs / metricsStore.summary.totalOperations
-    : 0;
-  
-  return {
-    enabled: true,
-    uptime: {
-      ms: uptimeMs,
-      formatted: formatDuration(uptimeMs)
-    },
-    operations: {
-      total: metricsStore.summary.totalOperations,
-      successful: metricsStore.summary.successfulOperations,
-      failed: metricsStore.summary.failedOperations,
-      successRate: metricsStore.summary.totalOperations > 0
-        ? ((metricsStore.summary.successfulOperations / metricsStore.summary.totalOperations) * 100).toFixed(2) + "%"
-        : "N/A"
-    },
-    performance: {
-      totalDurationMs: metricsStore.summary.totalDurationMs,
-      avgDurationMs: avgDuration.toFixed(2),
-      operationsPerMinute: uptimeMs > 0
-        ? ((metricsStore.summary.totalOperations / uptimeMs) * 60000).toFixed(2)
-        : 0
-    },
-    byType: metricsStore.summary.operationsByType,
-    recentErrors: metricsStore.errors.slice(-10)
-  };
-}
-
-/**
- * Retorna operações recentes
- * @param {number} limit - Número máximo de operações
- */
-export function getRecentOperations(limit = 20) {
-  if (!metricsEnabled) return [];
-  return metricsStore.operations.slice(-limit);
-}
-
-/**
- * Limpa métricas antigas
- * @param {number} maxAgeMs - Idade máxima em ms (default: 1 hora)
- */
-export function pruneMetrics(maxAgeMs = 3600000) {
-  if (!metricsEnabled) return;
-  
-  const cutoff = Date.now() - maxAgeMs;
-  metricsStore.operations = metricsStore.operations.filter(o => o.startTime > cutoff);
-  metricsStore.errors = metricsStore.errors.filter(e => e.timestamp > cutoff);
-}
-
-/**
- * Reseta todas as métricas
- */
-export function resetMetrics() {
-  metricsStore.operations = [];
-  metricsStore.errors = [];
-  metricsStore.startTime = Date.now();
-  metricsStore.summary = {
-    totalOperations: 0,
-    successfulOperations: 0,
-    failedOperations: 0,
-    totalDurationMs: 0,
-    operationsByType: {}
-  };
-}
-
-/**
- * Formata duração em formato legível
- */
-function formatDuration(ms) {
-  const seconds = Math.floor(ms / 1000);
-  const minutes = Math.floor(seconds / 60);
-  const hours = Math.floor(minutes / 60);
-  
-  if (hours > 0) return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
-  if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
-  return `${seconds}s`;
-}
-
-/**
- * Verifica se métricas estão habilitadas
- */
-export function isMetricsEnabled() {
-  return metricsEnabled;
-}