agent-master-devsecops 0.0.0-stage → 3.9.0

package/scripts/circuit_breaker.js

@@ -0,0 +1,330 @@
+#!/usr/bin/env node
+/**
+ * scripts/circuit_breaker.js
+ * 
+ * Circuit Breaker Inteligente Multi-Provedor para LLMs (AGDEV-9 / I-10).
+ * Abstração de resiliência e auto-cura (CLOSED, OPEN, HALF_OPEN) com fallback automático
+ * entre provedores de IA (Anthropic, OpenAI, Groq, Ollama) diante de erros HTTP 429/5xx ou timeouts.
+ */
+
+const STATES = {
+  CLOSED: 'CLOSED',       // Operação normal
+  OPEN: 'OPEN',           // Circuito rompido; chamadas desviadas para fallback
+  HALF_OPEN: 'HALF_OPEN'  // Sonda de teste para verificar recuperação
+};
+
+class CircuitBreaker {
+  constructor(name, options = {}) {
+    this.name = name;
+    this.failureThreshold = options.failureThreshold || 3;
+    this.recoveryTimeoutMs = options.recoveryTimeoutMs || 30000;
+    this.state = STATES.CLOSED;
+    this.failureCount = 0;
+    this.successCount = 0;
+    this.lastFailureTime = null;
+    this.lastStateChange = Date.now();
+  }
+
+  isOpen() {
+    if (this.state === STATES.OPEN) {
+      const now = Date.now();
+      if (now - this.lastFailureTime >= this.recoveryTimeoutMs) {
+        this.state = STATES.HALF_OPEN;
+        this.lastStateChange = now;
+        return false;
+      }
+      return true;
+    }
+    return false;
+  }
+
+  recordSuccess() {
+    this.failureCount = 0;
+    this.successCount++;
+    if (this.state === STATES.HALF_OPEN) {
+      this.state = STATES.CLOSED;
+      this.lastStateChange = Date.now();
+    }
+  }
+
+  recordFailure(error) {
+    this.failureCount++;
+    this.lastFailureTime = Date.now();
+
+    if (this.state === STATES.HALF_OPEN || this.failureCount >= this.failureThreshold) {
+      this.state = STATES.OPEN;
+      this.lastStateChange = Date.now();
+    }
+  }
+
+  async execute(primaryFn, fallbackFn = null) {
+    if (this.isOpen()) {
+      if (fallbackFn) {
+        return {
+          result: await fallbackFn(new Error(`Circuito ${this.name} está ABERTO (OPEN). Redirecionando para fallback.`)),
+          circuit: this.name,
+          state: this.state,
+          fallbackExecuted: true
+        };
+      }
+      throw new Error(`Circuito ${this.name} está ABERTO (OPEN). Nenhuma chamada permitida.`);
+    }
+
+    try {
+      const result = await primaryFn();
+      this.recordSuccess();
+      return {
+        result,
+        circuit: this.name,
+        state: this.state,
+        fallbackExecuted: false
+      };
+    } catch (err) {
+      this.recordFailure(err);
+      if (fallbackFn) {
+        return {
+          result: await fallbackFn(err),
+          circuit: this.name,
+          state: this.state,
+          fallbackExecuted: true,
+          error: err.message
+        };
+      }
+      throw err;
+    }
+  }
+
+  executeSync(primaryFn, fallbackFn = null) {
+    if (this.isOpen()) {
+      if (fallbackFn) {
+        return {
+          result: fallbackFn(new Error(`Circuito ${this.name} está ABERTO (OPEN). Redirecionando para fallback.`)),
+          circuit: this.name,
+          state: this.state,
+          fallbackExecuted: true
+        };
+      }
+      throw new Error(`Circuito ${this.name} está ABERTO (OPEN). Nenhuma chamada permitida.`);
+    }
+
+    try {
+      const result = primaryFn();
+      this.recordSuccess();
+      return {
+        result,
+        circuit: this.name,
+        state: this.state,
+        fallbackExecuted: false
+      };
+    } catch (err) {
+      this.recordFailure(err);
+      if (fallbackFn) {
+        return {
+          result: fallbackFn(err),
+          circuit: this.name,
+          state: this.state,
+          fallbackExecuted: true,
+          error: err.message
+        };
+      }
+      throw err;
+    }
+  }
+
+  reset() {
+    this.state = STATES.CLOSED;
+    this.failureCount = 0;
+    this.successCount = 0;
+    this.lastFailureTime = null;
+    this.lastStateChange = Date.now();
+  }
+
+  getStatus() {
+    return {
+      name: this.name,
+      state: this.state,
+      failureCount: this.failureCount,
+      failureThreshold: this.failureThreshold,
+      recoveryTimeoutMs: this.recoveryTimeoutMs,
+      isOpen: this.isOpen()
+    };
+  }
+}
+
+class MultiProviderRouter {
+  constructor(providers = ['anthropic', 'openai', 'groq', 'ollama'], options = {}) {
+    this.circuits = new Map();
+    providers.forEach(p => {
+      this.circuits.set(p, new CircuitBreaker(p, options));
+    });
+    this.providerChain = providers;
+  }
+
+  async dispatch(taskFnMap) {
+    const attempted = [];
+
+    for (const provider of this.providerChain) {
+      const circuit = this.circuits.get(provider);
+      attempted.push(provider);
+
+      if (!circuit.isOpen()) {
+        const fn = taskFnMap[provider] || taskFnMap['default'];
+        if (!fn) continue;
+
+        try {
+          const res = await circuit.execute(fn);
+          return {
+            success: true,
+            providerUsed: provider,
+            attempted,
+            result: res.result,
+            circuitStates: this.getAllStatuses()
+          };
+        } catch (err) {
+          // Erro registrado pelo circuit breaker; continua para o próximo provedor na cadeia
+          continue;
+        }
+      }
+    }
+
+    return {
+      success: false,
+      error: 'Todos os provedores de IA estão indisponíveis ou com circuito ABERTO.',
+      attempted,
+      circuitStates: this.getAllStatuses()
+    };
+  }
+
+  dispatchSync(taskFnMap) {
+    const attempted = [];
+
+    for (const provider of this.providerChain) {
+      const circuit = this.circuits.get(provider);
+      attempted.push(provider);
+
+      if (!circuit.isOpen()) {
+        const fn = taskFnMap[provider] || taskFnMap['default'];
+        if (!fn) continue;
+
+        try {
+          const res = circuit.executeSync(fn);
+          return {
+            success: true,
+            providerUsed: provider,
+            attempted,
+            result: res.result,
+            circuitStates: this.getAllStatuses()
+          };
+        } catch (err) {
+          continue;
+        }
+      }
+    }
+
+    return {
+      success: false,
+      error: 'Todos os provedores de IA estão indisponíveis ou com circuito ABERTO.',
+      attempted,
+      circuitStates: this.getAllStatuses()
+    };
+  }
+
+  getAllStatuses() {
+    const statuses = {};
+    for (const [name, circuit] of this.circuits.entries()) {
+      statuses[name] = circuit.getStatus();
+    }
+    return statuses;
+  }
+
+  resetAll() {
+    for (const circuit of this.circuits.values()) {
+      circuit.reset();
+    }
+  }
+}
+
+async function runCli() {
+  console.log('=== Simulação de Resiliência Multi-Provedor com Circuit Breaker (I-10) ===');
+  const router = new MultiProviderRouter(['anthropic', 'openai', 'groq', 'ollama'], { failureThreshold: 2 });
+
+  // Simula indisponibilidade em anthropic e openai
+  const taskMap = {
+    anthropic: async () => { throw new Error('HTTP 429: Too Many Requests (Rate limit exceeded)'); },
+    openai: async () => { throw new Error('HTTP 503: Service Unavailable'); },
+    groq: async () => { return 'Resposta gerada com sucesso via Groq (Llama 3.3 70B)'; },
+    ollama: async () => { return 'Resposta local via Ollama'; }
+  };
+
+  const dispatch1 = await router.dispatch(taskMap);
+  console.log('\nDespacho 1 (Anthropic & OpenAI falham -> Fallback para Groq):');
+  console.log(`Provedor Utilizado: ${dispatch1.providerUsed}`);
+  console.log(`Tentativas: ${dispatch1.attempted.join(' -> ')}`);
+  console.log(`Resultado: ${dispatch1.result}`);
+
+  console.log('\nStatus dos Circuitos:');
+  console.log(JSON.stringify(dispatch1.circuitStates, null, 2));
+}
+
+if (require.main === module) {
+  runCli().catch(console.error);
+}
+
+
+class AntiThrashingGuard {
+  constructor(options = {}) {
+    this.maxIdenticalFailures = options.maxIdenticalFailures || 2;
+    this.history = [];
+    this.thrashingTripped = false;
+  }
+
+  normalizeError(error) {
+    if (!error) return 'unknown_error';
+    const msg = typeof error === 'string' ? error : (error.message || String(error));
+    return msg
+      .replace(/:\d+:\d+/g, '')
+      .replace(/\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\b/g, '')
+      .replace(/0x[0-9a-fA-F]+/g, '')
+      .trim();
+  }
+
+  recordAttempt(error = null) {
+    if (!error) {
+      this.history = [];
+      this.thrashingTripped = false;
+      return { isThrashing: false, count: 0 };
+    }
+
+    const norm = this.normalizeError(error);
+    this.history.push({ signature: norm, timestamp: Date.now() });
+
+    if (this.history.length >= this.maxIdenticalFailures) {
+      const recent = this.history.slice(-this.maxIdenticalFailures);
+      const allIdentical = recent.every(h => h.signature === norm);
+      if (allIdentical) {
+        this.thrashingTripped = true;
+        return {
+          isThrashing: true,
+          count: this.history.length,
+          signature: norm,
+          message: `[ANTI-THRASHING FINOPS VETO]: Detectadas ${this.maxIdenticalFailures} falhas consecutivas com erro idêntico ("${norm.substring(0, 80)}..."). Execução autônoma interrompida para evitar queima descontrolada de tokens.`
+        };
+      }
+    }
+
+    return { isThrashing: false, count: this.history.length, signature: norm };
+  }
+
+  reset() {
+    this.history = [];
+    this.thrashingTripped = false;
+  }
+}
+
+
+module.exports = {
+  STATES,
+  CircuitBreaker,
+  MultiProviderRouter,
+  AntiThrashingGuard
+};

package/scripts/code_quality_auditor.js

@@ -0,0 +1,142 @@
+/**
+ * Code Quality & Cyclomatic Complexity Auditor
+ * Auditoria independente de qualidade de software, complexidade ciclomática,
+ * profundidade de aninhamento e detecção de anti-patterns de código.
+ * Em conformidade com a Regra 13 (Estrutura de Código) e Matriz de Severidade.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+class CodeQualityAuditor {
+  constructor(options = {}) {
+    this.maxComplexity = options.maxComplexity || 15;
+    this.maxNesting = options.maxNesting || 4;
+    this.maxFileLines = options.maxFileLines || 300;
+  }
+
+  auditCode(code, filename = 'snippet.js') {
+    const lines = code.split('\n');
+    const totalLines = lines.length;
+    let commentLines = 0;
+    let blankLines = 0;
+    let maxNestingObserved = 0;
+    let currentNesting = 0;
+    const issues = [];
+
+    // Contadores de decisão para complexidade ciclomática
+    let complexityScore = 1;
+    const decisionPatterns = [
+      /\bif\s*\(/g,
+      /\belse\s+if\s*\(/g,
+      /\bfor\s*\(/g,
+      /\bwhile\s*\(/g,
+      /\bcatch\s*\(/g,
+      /\bcase\s+[^:]+:/g,
+      /&&/g,
+      /\|\|/g,
+      /\?[^:]+:/g
+    ];
+
+    lines.forEach((line, index) => {
+      const lineNum = index + 1;
+      const trimmed = line.trim();
+
+      if (!trimmed) {
+        blankLines++;
+        return;
+      }
+
+      if (trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*')) {
+        commentLines++;
+        return;
+      }
+
+      // Análise de aninhamento de chaves
+      for (const char of trimmed) {
+        if (char === '{') currentNesting++;
+        if (char === '}') currentNesting = Math.max(0, currentNesting - 1);
+        if (currentNesting > maxNestingObserved) {
+          maxNestingObserved = currentNesting;
+        }
+      }
+
+      // Contagem de complexidade ciclomática
+      for (const pattern of decisionPatterns) {
+        const matches = trimmed.match(pattern);
+        if (matches) {
+          complexityScore += matches.length;
+        }
+      }
+
+      // Detecção de empty catch block (anti-pattern de engolir exceções)
+      if (/catch\s*\([^\)]*\)\s*\{\s*\}/.test(trimmed)) {
+        issues.push({
+          type: 'EMPTY_CATCH',
+          line: lineNum,
+          severity: 'HIGH',
+          message: 'Bloco catch vazio detectado: erros não devem ser suprimidos silenciosamente (Regra 5).'
+        });
+      }
+
+      // Detecção de comentários TODO ou código comentado
+      if (/\b(?:TODO|FIXME|HACK)\b/i.test(trimmed)) {
+        issues.push({
+          type: 'PENDING_TODO',
+          line: lineNum,
+          severity: 'LOW',
+          message: `Marcação pendente detectada: "${trimmed}". Código pronto não deve deixar TODOs (Regra 7).`
+        });
+      }
+    });
+
+    // Verificação de limites
+    if (totalLines > this.maxFileLines) {
+      issues.push({
+        type: 'FILE_TOO_LONG',
+        line: totalLines,
+        severity: 'MEDIUM',
+        message: `Arquivo possui ${totalLines} linhas (limite canônico recomendado: ${this.maxFileLines} linhas - Regra 13).`
+      });
+    }
+
+    if (maxNestingObserved > this.maxNesting) {
+      issues.push({
+        type: 'DEEP_NESTING',
+        line: 1,
+        severity: 'MEDIUM',
+        message: `Nível máximo de aninhamento (${maxNestingObserved}) excede o limiar tolerado (${this.maxNesting}).`
+      });
+    }
+
+    if (complexityScore > this.maxComplexity) {
+      issues.push({
+        type: 'HIGH_CYCLOMATIC_COMPLEXITY',
+        line: 1,
+        severity: 'MEDIUM',
+        message: `Complexidade ciclomática (${complexityScore}) excede o limite aceitável de ${this.maxComplexity}.`
+      });
+    }
+
+    const isClean = issues.filter(i => i.severity === 'HIGH' || i.severity === 'CRITICAL').length === 0;
+
+    return {
+      filename,
+      status: isClean ? (issues.length === 0 ? 'OPTIMAL' : 'ACCEPTABLE_WITH_NOTES') : 'REFACTOR_REQUIRED',
+      metrics: {
+        totalLines,
+        codeLines: totalLines - commentLines - blankLines,
+        commentLines,
+        blankLines,
+        cyclomaticComplexity: complexityScore,
+        maxNestingDepth: maxNestingObserved
+      },
+      qualityScore: Math.max(0, 100 - (issues.length * 10) - (complexityScore > this.maxComplexity ? 15 : 0)),
+      issues
+    };
+  }
+}
+
+module.exports = {
+  CodeQualityAuditor
+};