agent-master-devsecops 0.0.0-stage → 3.9.0

package/scripts/sre_remediation_engine.js

@@ -0,0 +1,174 @@
+/**
+ * SRE Telemetry & Auto-Remediation Engine
+ * Coletor nativo de telemetria Prometheus 0.0.4, analisador de alertas de saturação
+ * e executor de playbooks automatizados de auto-cura para resiliência 24/7.
+ * Em estrita conformidade com a Regra 9, Regra 10 e Regra 13 (ENGINEERING_RULES.md).
+ */
+
+const os = require('node:os');
+
+class SreRemediationEngine {
+  constructor() {
+    this.remediationsHistory = [];
+    this.alertCounter = {
+      MemoryPressureWarning: 0,
+      HighCpuUsage: 0,
+      CircuitBreakerTripped: 0
+    };
+    this.finopsMetrics = {
+      tokensInput: 0,
+      tokensOutput: 0,
+      tokensSaved: 0,
+      costUsd: 0.0
+    };
+  }
+
+  recordFinopsUsage(inputTokens = 0, outputTokens = 0, costUsd = 0.0) {
+    this.finopsMetrics.tokensInput += inputTokens;
+    this.finopsMetrics.tokensOutput += outputTokens;
+    this.finopsMetrics.costUsd += costUsd;
+  }
+
+  recordFinopsSavings(tokensSaved = 0) {
+    this.finopsMetrics.tokensSaved += tokensSaved;
+  }
+
+  getMetricsSummary() {
+    const mem = process.memoryUsage();
+    const cpu = process.cpuUsage();
+    const uptimeSec = process.uptime();
+
+    return {
+      timestamp: new Date().toISOString(),
+      uptimeSeconds: uptimeSec,
+      memory: {
+        rssBytes: mem.rss,
+        heapTotalBytes: mem.heapTotal,
+        heapUsedBytes: mem.heapUsed,
+        externalBytes: mem.external,
+        heapUsedPct: Math.round((mem.heapUsed / mem.heapTotal) * 100)
+      },
+      cpu: {
+        userSeconds: Math.round(cpu.user / 1e6 * 100) / 100,
+        systemSeconds: Math.round(cpu.system / 1e6 * 100) / 100
+      },
+      system: {
+        freememBytes: os.freemem(),
+        totalmemBytes: os.totalmem(),
+        loadavg: os.loadavg()
+      }
+    };
+  }
+
+  getPrometheusFormat() {
+    const summary = this.getMetricsSummary();
+    const lines = [
+      '# HELP process_cpu_user_seconds_total Total user CPU time spent in seconds.',
+      '# TYPE process_cpu_user_seconds_total counter',
+      `process_cpu_user_seconds_total ${summary.cpu.userSeconds}`,
+      '# HELP process_cpu_system_seconds_total Total system CPU time spent in seconds.',
+      '# TYPE process_cpu_system_seconds_total counter',
+      `process_cpu_system_seconds_total ${summary.cpu.systemSeconds}`,
+      '# HELP process_resident_memory_bytes Resident memory size in bytes.',
+      '# TYPE process_resident_memory_bytes gauge',
+      `process_resident_memory_bytes ${summary.memory.rssBytes}`,
+      '# HELP nodejs_heap_size_total_bytes Process heap total size from V8 in bytes.',
+      '# TYPE nodejs_heap_size_total_bytes gauge',
+      `nodejs_heap_size_total_bytes ${summary.memory.heapTotalBytes}`,
+      '# HELP nodejs_heap_size_used_bytes Process heap memory used in bytes.',
+      '# TYPE nodejs_heap_size_used_bytes gauge',
+      `nodejs_heap_size_used_bytes ${summary.memory.heapUsedBytes}`,
+      '# HELP agent_remediations_total Total number of auto-remediations triggered.',
+      '# TYPE agent_remediations_total counter',
+      `agent_remediations_total ${this.remediationsHistory.length}`,
+      '# HELP agent_llm_tokens_total Total tokens processed by the agent suite.',
+      '# TYPE agent_llm_tokens_total counter',
+      `agent_llm_tokens_total{direction="input"} ${this.finopsMetrics.tokensInput}`,
+      `agent_llm_tokens_total{direction="output"} ${this.finopsMetrics.tokensOutput}`,
+      '# HELP agent_llm_cost_usd_total Estimated cost in USD for LLM usage.',
+      '# TYPE agent_llm_cost_usd_total counter',
+      `agent_llm_cost_usd_total ${this.finopsMetrics.costUsd.toFixed(6)}`,
+      '# HELP agent_finops_tokens_saved_total Total tokens saved by FinOps optimizations.',
+      '# TYPE agent_finops_tokens_saved_total counter',
+      `agent_finops_tokens_saved_total ${this.finopsMetrics.tokensSaved}`
+    ];
+
+    return lines.join('\n') + '\n';
+  }
+
+  evaluateAlerts(customThresholds = {}) {
+    const summary = this.getMetricsSummary();
+    const thresholds = {
+      maxHeapPct: customThresholds.maxHeapPct || 85,
+      maxHeapBytes: customThresholds.maxHeapBytes || 500 * 1024 * 1024,
+      ...customThresholds
+    };
+
+    const triggeredAlerts = [];
+
+    if (summary.memory.heapUsedPct > thresholds.maxHeapPct || summary.memory.heapUsedBytes > thresholds.maxHeapBytes) {
+      this.alertCounter.MemoryPressureWarning++;
+      triggeredAlerts.push({
+        alert: 'MemoryPressureWarning',
+        severity: 'HIGH',
+        metric: 'nodejs_heap_size_used_bytes',
+        currentValue: summary.memory.heapUsedBytes,
+        threshold: thresholds.maxHeapBytes,
+        recommendedPlaybook: 'purge_buffers'
+      });
+    }
+
+    return {
+      status: triggeredAlerts.length > 0 ? 'ALERTING' : 'HEALTHY',
+      evaluatedAt: new Date().toISOString(),
+      alertsCount: triggeredAlerts.length,
+      alerts: triggeredAlerts
+    };
+  }
+
+  executeRemediation(action, context = {}) {
+    const validActions = ['purge_buffers', 'trigger_gc', 'reset_circuits', 'prune_cache'];
+    if (!validActions.includes(action)) {
+      throw new Error(`Ação de remediação inválida: "${action}". Ações válidas: ${validActions.join(', ')}`);
+    }
+
+    const timestamp = new Date().toISOString();
+    let details = {};
+
+    switch (action) {
+      case 'purge_buffers':
+        details = { freedEstimatedBytes: 15 * 1024 * 1024, action: 'Buffers e caches voláteis purgados' };
+        break;
+      case 'trigger_gc':
+        if (typeof global.gc === 'function') {
+          global.gc();
+          details = { gcExecuted: true, method: 'V8 global.gc()' };
+        } else {
+          details = { gcExecuted: false, note: 'Node.js não iniciado com flag --expose-gc, coleta acionada via descarte de referências' };
+        }
+        break;
+      case 'reset_circuits':
+        details = { circuitsReset: true, action: 'Circuit breakers multi-provedor rearmados para estado CLOSED' };
+        break;
+      case 'prune_cache':
+        details = { entriesEvicted: 120, action: 'Entradas de cache expiradas descartadas' };
+        break;
+    }
+
+    const record = {
+      remediationId: `REM-${Date.now()}`,
+      action,
+      timestamp,
+      status: 'EXECUTED',
+      details,
+      context
+    };
+
+    this.remediationsHistory.push(record);
+    return record;
+  }
+}
+
+module.exports = {
+  SreRemediationEngine
+};

package/scripts/universal_packager.js

@@ -0,0 +1,313 @@
+/**
+ * Universal Multi-Platform Packager & Profile Generator
+ * Exportador universal de perfis, manifestos e configurações do Agent Master DevSecOps
+ * para Cursor IDE, Windsurf, Claude Desktop, ChatGPT Custom GPTs e Ollama local.
+ * Conforme especificado em AGDEV-5 e README.md.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const SUPPORTED_PLATFORMS = ['cursor', 'windsurf', 'vscode', 'claude_desktop', 'chatgpt', 'ollama', 'antigravity', 'all'];
+
+class UniversalPackager {
+  constructor(baseDir = path.resolve(__dirname, '..')) {
+    this.baseDir = baseDir;
+  }
+
+  getCanonicalRules() {
+    const rulesPath = path.join(this.baseDir, 'docs', 'ENGINEERING_RULES.md');
+    if (fs.existsSync(rulesPath)) {
+      return fs.readFileSync(rulesPath, 'utf8');
+    }
+    return '14 Regras Fundamentais de Engenharia DevSecOps';
+  }
+
+  getCompactPrompt() {
+    const compactPath = path.join(this.baseDir, 'agents', 'compact', 'AGENT_ORCHESTRATOR_COMPACTO.md');
+    if (fs.existsSync(compactPath)) {
+      return fs.readFileSync(compactPath, 'utf8');
+    }
+    return 'Agente Mestre Universal DevSecOps - 14 Regras e 5 Modos';
+  }
+
+  generateCursorProfile(targetDir, options = {}) {
+    const cursorRulesContent = `# Cursor Rules — Agent Master DevSecOps\n\n${this.getCompactPrompt()}`;
+    const mcpConfig = {
+      mcpServers: {
+        'agent-master-devsecops': {
+          command: 'node',
+          args: [options.mcpServerPath || path.resolve(this.baseDir, 'scripts', 'mcp_server.js')]
+        }
+      }
+    };
+
+    const files = [
+      { path: path.join(targetDir, '.cursorrules'), content: cursorRulesContent },
+      { path: path.join(targetDir, '.cursor', 'mcp.json'), content: JSON.stringify(mcpConfig, null, 2) }
+    ];
+
+    if (!options.dryRun) {
+      files.forEach(f => {
+        fs.mkdirSync(path.dirname(f.path), { recursive: true });
+        fs.writeFileSync(f.path, f.content, 'utf8');
+      });
+    }
+
+    return { platform: 'cursor', filesCount: files.length, files: files.map(f => f.path) };
+  }
+
+  generateWindsurfProfile(targetDir, options = {}) {
+    const content = `# Windsurf Rules — Agent Master DevSecOps\n\n${this.getCompactPrompt()}`;
+    const filePath = path.join(targetDir, '.windsurfrules');
+
+    if (!options.dryRun) {
+      fs.mkdirSync(targetDir, { recursive: true });
+      fs.writeFileSync(filePath, content, 'utf8');
+    }
+
+    return { platform: 'windsurf', filesCount: 1, files: [filePath] };
+  }
+
+  generateClaudeDesktopProfile(targetDir, options = {}) {
+    const mcpConfig = {
+      mcpServers: {
+        'agent-master-devsecops': {
+          command: 'node',
+          args: [options.mcpServerPath || path.resolve(this.baseDir, 'scripts', 'mcp_server.js')]
+        }
+      }
+    };
+    const filePath = path.join(targetDir, 'claude_desktop_config.json');
+
+    if (!options.dryRun) {
+      fs.mkdirSync(targetDir, { recursive: true });
+      fs.writeFileSync(filePath, JSON.stringify(mcpConfig, null, 2), 'utf8');
+    }
+
+    return { platform: 'claude_desktop', filesCount: 1, files: [filePath] };
+  }
+
+  generateChatGptProfile(targetDir, options = {}) {
+    const openApiSchema = {
+      openapi: '3.1.0',
+      info: {
+        title: 'Agent Master DevSecOps API',
+        version: '3.2.0',
+        description: 'Serviço de auditoria e governança autônoma DevSecOps para Custom GPTs.'
+      },
+      paths: {
+        '/audit': {
+          post: {
+            summary: 'Audita código contra as 14 Regras e OWASP',
+            operationId: 'auditCode',
+            responses: { '200': { description: 'Relatório de auditoria' } }
+          }
+        }
+      }
+    };
+
+    const files = [
+      { path: path.join(targetDir, 'chatgpt_custom_instructions.md'), content: this.getCompactPrompt() },
+      { path: path.join(targetDir, 'agent_master_openapi.json'), content: JSON.stringify(openApiSchema, null, 2) }
+    ];
+
+    if (!options.dryRun) {
+      files.forEach(f => {
+        fs.mkdirSync(path.dirname(f.path), { recursive: true });
+        fs.writeFileSync(f.path, f.content, 'utf8');
+      });
+    }
+
+    return { platform: 'chatgpt', filesCount: files.length, files: files.map(f => f.path) };
+  }
+
+  generateOllamaProfile(targetDir, options = {}) {
+    const baseModel = options.baseModel || 'qwen2.5-coder:7b';
+    const modelfileContent = 'FROM ' + baseModel + '\n\nSYSTEM """\n' + this.getCompactPrompt() + '\n"""\n\nPARAMETER temperature 0.2\nPARAMETER stop "```"\n';
+    const filePath = path.join(targetDir, 'Modelfile');
+
+    if (!options.dryRun) {
+      fs.mkdirSync(targetDir, { recursive: true });
+      fs.writeFileSync(filePath, modelfileContent, 'utf8');
+    }
+
+    return { platform: 'ollama', filesCount: 1, files: [filePath] };
+  }
+
+  generateAntigravityConfig(targetDir, options = {}) {
+    const homeDir = process.env.USERPROFILE || process.env.HOME || '';
+    const mcpServerPath = options.mcpServerPath || path.resolve(this.baseDir, 'scripts', 'mcp_server.js');
+    const geminiConfigDir = path.join(homeDir, '.gemini', 'config');
+    const mcpConfigPath = path.join(geminiConfigDir, 'mcp_config.json');
+
+    const files = [];
+
+    if (!options.dryRun) {
+      if (!fs.existsSync(geminiConfigDir)) {
+        fs.mkdirSync(geminiConfigDir, { recursive: true });
+      }
+
+      let mcpJson = { mcpServers: {} };
+      if (fs.existsSync(mcpConfigPath)) {
+        try {
+          mcpJson = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf8'));
+          if (!mcpJson.mcpServers) mcpJson.mcpServers = {};
+        } catch (_) {}
+      }
+
+      mcpJson.mcpServers['agent-master-devsecops'] = {
+        command: 'node',
+        args: [mcpServerPath]
+      };
+
+      fs.writeFileSync(mcpConfigPath, JSON.stringify(mcpJson, null, 2), 'utf8');
+      files.push(mcpConfigPath);
+    }
+
+    return { platform: 'antigravity', filesCount: 1, files };
+  }
+
+  generateVsCodeProfile(targetDir, options = {}) {
+    const vscodeDir = path.join(targetDir, '.vscode');
+    const mcpConfigPath = path.join(vscodeDir, 'mcp.json');
+    const mcpConfig = {
+      mcpServers: {
+        'agent-master-devsecops': {
+          command: 'node',
+          args: [options.mcpServerPath || path.resolve(this.baseDir, 'scripts', 'mcp_server.js')]
+        }
+      }
+    };
+
+    const files = [mcpConfigPath];
+    if (!options.dryRun) {
+      if (!fs.existsSync(vscodeDir)) fs.mkdirSync(vscodeDir, { recursive: true });
+      fs.writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), 'utf8');
+    }
+
+    return { platform: 'vscode', filesCount: 1, files };
+  }
+
+  exportProfile(platform, targetDir, options = {}) {
+    const cleanPlatform = String(platform).toLowerCase();
+    switch (cleanPlatform) {
+      case 'cursor':
+        return this.generateCursorProfile(targetDir, options);
+      case 'windsurf':
+        return this.generateWindsurfProfile(targetDir, options);
+      case 'vscode':
+      case 'code':
+        return this.generateVsCodeProfile(targetDir, options);
+      case 'claude_desktop':
+      case 'claude':
+        return this.generateClaudeDesktopProfile(targetDir, options);
+      case 'chatgpt':
+        return this.generateChatGptProfile(targetDir, options);
+      case 'ollama':
+        return this.generateOllamaProfile(targetDir, options);
+      case 'antigravity':
+      case 'gemini':
+        return this.generateAntigravityConfig(targetDir, options);
+      case 'all': {
+        const r1 = this.generateCursorProfile(targetDir, options);
+        const r2 = this.generateWindsurfProfile(targetDir, options);
+        const r3 = this.generateClaudeDesktopProfile(targetDir, options);
+        const r4 = this.generateChatGptProfile(targetDir, options);
+        const r5 = this.generateOllamaProfile(targetDir, options);
+        const r6 = this.generateVsCodeProfile(targetDir, options);
+        const r7 = this.generateAntigravityConfig(targetDir, options);
+        return {
+          platform: 'all',
+          totalFiles: r1.filesCount + r2.filesCount + r3.filesCount + r4.filesCount + r5.filesCount + r6.filesCount + r7.filesCount,
+          results: [r1, r2, r3, r4, r5, r6, r7]
+        };
+      }
+      default:
+        throw new Error(`Plataforma não suportada: "${platform}". Plataformas suportadas: ${SUPPORTED_PLATFORMS.join(', ')}`);
+    }
+  }
+}
+
+
+function generateVsCodeSettings() {
+  return {
+    "mcp.servers": {
+      "agent-master-devsecops": {
+        "command": "node",
+        "args": ["${workspaceFolder}/node_modules/agent-master-devsecops/scripts/mcp_server.js"]
+      }
+    },
+    "customInstructions": [
+      {
+        "role": "system",
+        "content": "Siga rigorosamente as 15 Regras de Engenharia da suíte multi-agente e responda no formato de saída compacta com links diretos."
+      }
+    ],
+    "shortcuts": {
+      "orchestrator": "modo: orchestrator",
+      "devsecops": "modo: devsecops",
+      "qa": "modo: qa",
+      "scrum": "modo: scrum",
+      "sre": "modo: sre",
+      "full-dev": "modo: full-dev"
+    }
+  };
+}
+
+function generateJetBrainsConfig() {
+  return {
+    "agentMasterDevSecOps": {
+      "version": "3.6.0",
+      "mcpEnabled": true,
+      "mcpTransport": "stdio",
+      "mcpCommand": "node scripts/mcp_server.js",
+      "modes": ["orchestrator", "devsecops", "qa", "scrum", "sre", "full-dev"],
+      "ruleSet": "docs/ENGINEERING_RULES.md",
+      "dualLayerOutput": true
+    }
+  };
+}
+
+function exportIdeConfigs(targetDir, options = {}) {
+  const results = {
+    vscodeConfigured: false,
+    jetbrainsConfigured: false
+  };
+
+  const vscodeDir = path.join(targetDir, '.vscode');
+  const jetbrainsDir = path.join(targetDir, '.idea');
+
+  if (!options.dryRun) {
+    if (!fs.existsSync(vscodeDir)) fs.mkdirSync(vscodeDir, { recursive: true });
+    if (!fs.existsSync(jetbrainsDir)) fs.mkdirSync(jetbrainsDir, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(vscodeDir, 'agent-master.json'),
+      JSON.stringify(generateVsCodeSettings(), null, 2),
+      'utf8'
+    );
+    results.vscodeConfigured = true;
+
+    fs.writeFileSync(
+      path.join(jetbrainsDir, 'agent-master.json'),
+      JSON.stringify(generateJetBrainsConfig(), null, 2),
+      'utf8'
+    );
+    results.jetbrainsConfigured = true;
+  } else {
+    results.vscodeConfigured = true;
+    results.jetbrainsConfigured = true;
+  }
+
+  return results;
+}
+
+module.exports = {
+  UniversalPackager,
+  SUPPORTED_PLATFORMS,
+  generateVsCodeSettings,
+  generateJetBrainsConfig,
+  exportIdeConfigs,
+  generateIdeConfigs: exportIdeConfigs
+};