@andre.buzeli/git-mcp 15.12.5

package/src/utils/hooks.js

@@ -0,0 +1,255 @@
+// 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

@@ -0,0 +1,198 @@
+// 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;
+}

package/src/utils/providerExec.js

@@ -0,0 +1,61 @@
+import { withRetry } from "./retry.js";
+
+/**
+ * Executa operações em GitHub e Gitea em PARALELO com retry automático
+ * @param {ProviderManager} pm - Provider manager
+ * @param {Object} handlers - { github: async (owner) => {}, gitea: async (owner) => {} }
+ * @param {Object} options - { retry: boolean, maxRetries: number, organization: string }
+ */
+export async function runBoth(pm, handlers, options = {}) {
+  const { retry = true, maxRetries = 3, organization } = options;
+  const out = { github: null, gitea: null };
+
+  // Se organization fornecida, usar como owner; senão buscar owners pessoais em paralelo
+  const [ghOwner, geOwner] = organization
+    ? [organization, organization]
+    : await Promise.all([
+      pm.getGitHubOwner().catch(() => ""),
+      pm.getGiteaOwner().catch(() => "")
+    ]);
+
+  // Preparar promises para execução paralela
+  const promises = [];
+
+  if (pm.github && ghOwner && handlers.github) {
+    const githubPromise = async () => {
+      const executor = () => handlers.github(ghOwner);
+      try {
+        const result = retry ? await withRetry(executor, { maxRetries }) : await executor();
+        return { provider: "github", result };
+      } catch (e) {
+        return { provider: "github", result: { ok: false, error: String(e?.message || e) } };
+      }
+    };
+    promises.push(githubPromise());
+  }
+
+  if (pm.giteaUrl && pm.giteaToken && geOwner && handlers.gitea) {
+    const giteaPromise = async () => {
+      const executor = () => handlers.gitea(geOwner);
+      try {
+        const result = retry ? await withRetry(executor, { maxRetries }) : await executor();
+        return { provider: "gitea", result };
+      } catch (e) {
+        return { provider: "gitea", result: { ok: false, error: String(e?.message || e) } };
+      }
+    };
+    promises.push(giteaPromise());
+  }
+
+  // Executar em paralelo
+  const results = await Promise.all(promises);
+
+  // Mapear resultados
+  for (const { provider, result } of results) {
+    out[provider] = result;
+  }
+
+  return out;
+}
+
+