@andrebuzeli/git-mcp 15.8.4 → 15.8.6

package/src/utils/hooks.js

@@ -1,255 +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 });
-}
+// 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 });
+}