agent-master-devsecops 3.9.0 → 5.1.0

package/scripts/bin/domain_idea_miner.js

@@ -0,0 +1,658 @@
+#!/usr/bin/env node
+/**
+ * scripts/bin/domain_idea_miner.js
+ * 
+ * Domain Idea Miner & Automated Codebase Opportunity Scanner (v5.1 Enterprise).
+ * Varredura inteligente de código-fonte de aplicação para identificar gargalos reais
+ * de performance, resiliência, arquitetura e documentação de contratos.
+ * Em conformidade estrita com a Regra 14 (Ideation Sanity Filter), Regra 6 (Suggestions),
+ * os 10 Princípios Canônicos de Engenharia e o Gate de Arquitetura do AGENT_QA.
+ */
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { createSarifReport } = require('../core/sarif_engine.js');
+
+// Diretórios ignorados durante a varredura recursiva (imutável)
+const IGNORED_DIRS = Object.freeze(new Set([
+  'node_modules',
+  '.git',
+  '.github',
+  'build',
+  'target',
+  'dist',
+  '.idea',
+  '.vscode',
+  'coverage',
+  '.gradle',
+  '.mvn',
+  'vendor',
+  '.agents'
+]));
+
+// Extensões de código analisadas (imutável)
+const CODE_EXTENSIONS = Object.freeze(new Set([
+  '.java',
+  '.kt',
+  '.ts',
+  '.js',
+  '.py',
+  '.go'
+]));
+
+/**
+ * Catálogo Canônico e Imutável de Regras de Oportunidade Técnica (Regra 14).
+ * Cada regra define um predicado funcional puro (match) e metadados de valor/custo.
+ */
+const IDEA_RULES = Object.freeze([
+  {
+    id: 'AGDEV-OPP-CACHE',
+    ruleId: 'AGDEV-OPP-CACHE',
+    name: 'Implementar Cache em Leituras Repetitivas',
+    category: 'SPEED',
+    severity: 'LOW',
+    cost: 'S',
+    priority: 85,
+    match: (ctx, line, lineNum) => {
+      if (ctx.isController && ctx.isJava) {
+        if (/@GetMapping/i.test(line) && !ctx.hasCache) {
+          return {
+            category: 'SPEED',
+            title: 'Implementar cache local em memória (Caffeine/Spring Cache) no endpoint de leitura',
+            evidence: `${ctx.relativePath}:${lineNum}`,
+            value: 'redução de latência p99 < 15ms em consultas repetitivas',
+            cost: 'S',
+            priority: 85,
+            line: lineNum,
+            filename: ctx.relativePath
+          };
+        }
+      } else if (ctx.isController && ctx.isJsTs) {
+        if (/(app|router)\.get\s*\(/i.test(line) && !ctx.hasCache) {
+          return {
+            category: 'SPEED',
+            title: 'Adicionar cache HTTP (ETag / Cache-Control) nas rotas de leitura',
+            evidence: `${ctx.relativePath}:${lineNum}`,
+            value: 'redução de requisições redundantes ao backend',
+            cost: 'S',
+            priority: 80,
+            line: lineNum,
+            filename: ctx.relativePath
+          };
+        }
+      }
+      return null;
+    }
+  },
+  {
+    id: 'AGDEV-OPP-PAGINATION',
+    ruleId: 'AGDEV-OPP-PAGINATION',
+    name: 'Suporte a Paginação em Consultas de Banco',
+    category: 'RISK',
+    severity: 'MEDIUM',
+    cost: 'S',
+    priority: 90,
+    match: (ctx, line, lineNum) => {
+      if (ctx.isRepository || ctx.isController) {
+        if (/List<[A-Za-z0-9_]+>\s+findAll\s*\(\s*\)/i.test(line) ||
+            (ctx.isJava && /List<[A-Za-z0-9_]+>\s+(get|find|list)[A-Za-z0-9_]*\s*\([^)]*\)/i.test(line) && !line.includes('Pageable'))) {
+          return {
+            category: 'RISK',
+            title: 'Adicionar suporte a paginação (Pageable / Page<T>) na listagem de dados',
+            evidence: `${ctx.relativePath}:${lineNum}`,
+            value: 'prevenção de OutOfMemoryError com crescimento da base de dados',
+            cost: 'S',
+            priority: 90,
+            line: lineNum,
+            filename: ctx.relativePath
+          };
+        }
+      }
+      return null;
+    }
+  },
+  {
+    id: 'AGDEV-OPP-RESILIENCE',
+    ruleId: 'AGDEV-OPP-RESILIENCE',
+    name: 'Circuit Breaker e Timeouts Downstream',
+    category: 'RISK',
+    severity: 'HIGH',
+    cost: 'M',
+    priority: 95,
+    match: (ctx, line, lineNum) => {
+      if (/RestTemplate|WebClient|HttpClient|fetch\(|axios\./i.test(line)) {
+        if (!ctx.hasCircuitBreaker) {
+          return {
+            category: 'RISK',
+            title: ctx.isJava
+              ? 'Configurar Circuit Breaker e Timeouts com Resilience4j em chamadas downstream'
+              : 'Configurar Timeouts (AbortSignal.timeout) e Circuit Breaker em chamadas HTTP downstream',
+            evidence: `${ctx.relativePath}:${lineNum}`,
+            value: 'isolamento de falhas em cascata entre serviços',
+            cost: 'M',
+            priority: 95,
+            line: lineNum,
+            filename: ctx.relativePath
+          };
+        }
+      }
+      return null;
+    }
+  },
+  {
+    id: 'AGDEV-OPP-CONTRACT',
+    ruleId: 'AGDEV-OPP-CONTRACT',
+    name: 'Especificação de Contratos OpenAPI',
+    category: 'CODE',
+    severity: 'LOW',
+    cost: 'S',
+    priority: 70,
+    match: (ctx, line, lineNum) => {
+      if (ctx.isController && ctx.isJava) {
+        if (/@(GetMapping|PostMapping|PutMapping|DeleteMapping)/i.test(line) && !ctx.hasOpenApi) {
+          return {
+            category: 'CODE',
+            title: 'Especificar anotações de contrato OpenAPI 3.0 no Controller',
+            evidence: `${ctx.relativePath}:${lineNum}`,
+            value: 'catálogo de APIs homologado e documentação viva',
+            cost: 'S',
+            priority: 70,
+            line: lineNum,
+            filename: ctx.relativePath
+          };
+        }
+      }
+      return null;
+    }
+  },
+  {
+    id: 'AGDEV-OPP-INDEX',
+    ruleId: 'AGDEV-OPP-INDEX',
+    name: 'Indexação em Colunas de Busca Frequente',
+    category: 'SPEED',
+    severity: 'LOW',
+    cost: 'S',
+    priority: 75,
+    match: (ctx, line, lineNum) => {
+      if (ctx.isEntity && ctx.isJava) {
+        if (/@Entity/i.test(line) && !ctx.hasIndexes && ctx.hasSearchableFields) {
+          return {
+            category: 'SPEED',
+            title: 'Configurar índices de banco de dados (@Index) em colunas de busca frequente',
+            evidence: `${ctx.relativePath}:${lineNum}`,
+            value: 'redução de Full Table Scans em consultas de texto e chaves',
+            cost: 'S',
+            priority: 75,
+            line: lineNum,
+            filename: ctx.relativePath
+          };
+        }
+      }
+      return null;
+    }
+  }
+]);
+
+/**
+ * Cria o contexto sintático do arquivo em O(1), evitando verificações repetidas.
+ * @param {string} filePath 
+ * @param {string} rootDir 
+ * @param {string} content 
+ * @returns {object}
+ */
+function createFileContext(filePath, rootDir, content) {
+  const safeRootDir = (typeof rootDir === 'string' && rootDir) ? rootDir : process.cwd();
+  const safeFilePath = (typeof filePath === 'string' && filePath) ? filePath : '';
+  const relativePath = safeFilePath ? path.relative(safeRootDir, safeFilePath).replace(/\\/g, '/') : 'unknown';
+  const ext = path.extname(safeFilePath).toLowerCase();
+
+  const isJava = ext === '.java' || ext === '.kt';
+  const isJsTs = ext === '.js' || ext === '.ts';
+  const isPython = ext === '.py';
+  const isGo = ext === '.go';
+
+  const isController = /controller|resource|router|endpoint/i.test(relativePath) || /@RestController|@Controller/i.test(content);
+  const isRepository = /repository|dao|mapper/i.test(relativePath) || /@Repository/i.test(content);
+  const isEntity = /entity|model|domain/i.test(relativePath) || /@Entity|@Table/i.test(content);
+
+  const hasCache = content.includes('@Cacheable') || content.includes('CacheControl') || content.includes('cache') || content.includes('etag');
+  const hasCircuitBreaker = content.includes('@CircuitBreaker') || content.includes('Resilience4j') || content.includes('timeout') || content.includes('AbortSignal');
+  const hasOpenApi = content.includes('@Operation') || content.includes('@Tag') || content.includes('swagger') || content.includes('OpenAPI');
+  const hasIndexes = content.includes('indexes =');
+  const hasSearchableFields = /(?:name|title|code|email|status|slug|identifier|titulo|nome|codigo)/i.test(content);
+
+  return Object.freeze({
+    filePath: safeFilePath,
+    relativePath,
+    ext,
+    isJava,
+    isJsTs,
+    isPython,
+    isGo,
+    isController,
+    isRepository,
+    isEntity,
+    hasCache,
+    hasCircuitBreaker,
+    hasOpenApi,
+    hasIndexes,
+    hasSearchableFields
+  });
+}
+
+/**
+ * Classe Canônica DomainIdeaMiner
+ */
+class DomainIdeaMiner {
+  static get IGNORED_DIRS() {
+    return IGNORED_DIRS;
+  }
+
+  static get CODE_EXTENSIONS() {
+    return CODE_EXTENSIONS;
+  }
+
+  static get IDEA_RULES() {
+    return IDEA_RULES;
+  }
+
+  constructor(options = {}) {
+    const safeOptions = (options && typeof options === 'object') ? options : {};
+    this.rootDir = path.resolve(safeOptions.rootDir || process.cwd());
+    this.maxOpenIdeas = Number.isInteger(safeOptions.maxOpenIdeas) && safeOptions.maxOpenIdeas > 0 
+      ? safeOptions.maxOpenIdeas 
+      : 10;
+  }
+
+  /**
+   * Coleta recursiva de arquivos de código relevantes com tolerância a falhas.
+   * @param {string} [targetDir] 
+   * @returns {string[]}
+   */
+  collectCodeFiles(targetDir) {
+    if (targetDir === null) return [];
+    const dirToScan = targetDir !== undefined ? targetDir : this.rootDir;
+    if (!dirToScan || typeof dirToScan !== 'string' || !fs.existsSync(dirToScan)) {
+      return [];
+    }
+    const safeDir = path.resolve(dirToScan);
+    const files = [];
+
+    const walk = (currentDir) => {
+      if (!fs.existsSync(currentDir)) return;
+      let entries = [];
+      try {
+        entries = fs.readdirSync(currentDir, { withFileTypes: true });
+      } catch (_) {
+        return;
+      }
+
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          if (!IGNORED_DIRS.has(entry.name)) {
+            walk(path.join(currentDir, entry.name));
+          }
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name).toLowerCase();
+          if (CODE_EXTENSIONS.has(ext)) {
+            files.push(path.join(currentDir, entry.name));
+          }
+        }
+      }
+    };
+
+    walk(safeDir);
+    return files;
+  }
+
+  /**
+   * Analisa um arquivo e extrai oportunidades de melhoria aplicando o catálogo funcional.
+   * @param {string} filePath 
+   * @param {string} [rootDir=this.rootDir] 
+   * @returns {object[]}
+   */
+  inspectFile(filePath, rootDir = this.rootDir) {
+    if (!filePath || typeof filePath !== 'string' || !fs.existsSync(filePath)) {
+      return [];
+    }
+
+    let content = '';
+    try {
+      content = fs.readFileSync(filePath, 'utf8');
+    } catch (_) {
+      return [];
+    }
+
+    const ctx = createFileContext(filePath, rootDir, content);
+    const lines = content.split('\n');
+    const opportunities = [];
+
+    for (let index = 0; index < lines.length; index++) {
+      const lineNum = index + 1;
+      const trimmed = lines[index].trim();
+
+      for (const rule of IDEA_RULES) {
+        const opp = rule.match(ctx, trimmed, lineNum);
+        if (opp) {
+          opportunities.push(opp);
+        }
+      }
+    }
+
+    return opportunities;
+  }
+
+  /**
+   * Executa varredura completa no projeto alvo.
+   * @param {string} [targetDir] 
+   * @returns {object[]}
+   */
+  mineIdeas(targetDir) {
+    if (targetDir === null) return [];
+    const dirToScan = targetDir !== undefined ? targetDir : this.rootDir;
+    if (!dirToScan || typeof dirToScan !== 'string' || !fs.existsSync(dirToScan)) {
+      return [];
+    }
+    const safeDir = path.resolve(dirToScan);
+    const files = this.collectCodeFiles(safeDir);
+    const allOpportunities = [];
+
+    for (const file of files) {
+      const opps = this.inspectFile(file, safeDir);
+      allOpportunities.push(...opps);
+    }
+
+    // Deduplicação determinística por categoria e título similar
+    const uniqueMap = new Map();
+    for (const opp of allOpportunities) {
+      const key = `${opp.category}:${opp.title}`;
+      if (!uniqueMap.has(key)) {
+        uniqueMap.set(key, opp);
+      }
+    }
+
+    // Ordenação por prioridade decrescente
+    return Array.from(uniqueMap.values()).sort((a, b) => b.priority - a.priority);
+  }
+
+  /**
+   * Exporta os resultados da mineração no padrão industrial OASIS SARIF v2.1.0.
+   * @param {string} [targetDir] 
+   * @returns {object} SARIF v2.1.0 report
+   */
+  mineToSarif(targetDir) {
+    const dirToScan = targetDir !== undefined ? targetDir : this.rootDir;
+    const opportunities = this.mineIdeas(dirToScan);
+    const findings = opportunities.map(opp => ({
+      ruleId: opp.ruleId || `OPP-${opp.category}`,
+      name: opp.title,
+      severity: opp.category === 'RISK' ? 'HIGH' : (opp.category === 'SPEED' ? 'MEDIUM' : 'LOW'),
+      message: `${opp.title} — Impacto: ${opp.value} (Custo: ${opp.cost})`,
+      filename: opp.filename || (opp.evidence ? opp.evidence.split(':')[0] : 'unknown'),
+      line: opp.line || (opp.evidence ? parseInt(opp.evidence.split(':')[1], 10) : 1),
+      column: 1
+    }));
+
+    const rules = IDEA_RULES.map(r => ({
+      id: r.id,
+      name: r.name,
+      severity: r.category === 'RISK' ? 'HIGH' : (r.category === 'SPEED' ? 'MEDIUM' : 'LOW'),
+      description: r.name,
+      remediation: 'Considere aplicar esta oportunidade de domínio para ganho de arquitetura e mitigação de risco.'
+    }));
+
+    return createSarifReport({
+      toolName: 'agent-master-domain-idea-miner',
+      toolVersion: '5.1.0',
+      rules,
+      findings,
+      properties: {
+        category: 'Domain Architectural Opportunities',
+        opportunitiesCount: opportunities.length
+      }
+    });
+  }
+
+  /**
+   * Lê as ideias existentes em IDEAS.md e extrai o maior ID numérico.
+   * @param {string} ideasFilePath 
+   * @returns {object}
+   */
+  getExistingIdeas(ideasFilePath) {
+    if (!ideasFilePath || typeof ideasFilePath !== 'string' || !fs.existsSync(ideasFilePath)) {
+      return { highestId: 0, openIdeas: [], content: '' };
+    }
+
+    let content = '';
+    try {
+      content = fs.readFileSync(ideasFilePath, 'utf8');
+    } catch (_) {
+      return { highestId: 0, openIdeas: [], content: '' };
+    }
+
+    const lines = content.split(/\r?\n/);
+    let highestId = 0;
+    const openIdeas = [];
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      const match = trimmed.match(/^- I-(\d+)/);
+      if (match) {
+        const idNum = parseInt(match[1], 10);
+        if (idNum > highestId) highestId = idNum;
+
+        // Verificar se é aberta
+        if (!/\[(CONCLUÍDO|EM PRODUÇÃO|DONE|DROP|REJEITAD[OA]|ARCHIVED)\]/i.test(trimmed)) {
+          openIdeas.push(trimmed);
+        }
+      }
+    }
+
+    return { highestId, openIdeas, content };
+  }
+
+  /**
+   * Formata uma oportunidade no formato canônico da Regra 14 / ENGINEERING_RULES.
+   * @param {number} idNum 
+   * @param {object} opp 
+   * @returns {string}
+   */
+  formatCanonicalIdea(idNum, opp) {
+    if (!opp || typeof opp !== 'object') return '';
+    return `- I-${idNum} [${opp.category || 'CODE'}] ${opp.title || ''} | evidence: ${opp.evidence || 'N/A'} | value: ${opp.value || 'N/A'} | cost: ${opp.cost || 'S'}`;
+  }
+
+  /**
+   * Sincroniza as ideias mineradas com docs/IDEAS.md.
+   * @param {object[]} minedIdeas 
+   * @param {string} ideasFilePath 
+   * @param {object} [options={}] 
+   * @returns {object}
+   */
+  syncWithIdeasFile(minedIdeas = [], ideasFilePath, options = {}) {
+    const safeIdeas = Array.isArray(minedIdeas) ? minedIdeas : [];
+    const safePath = (typeof ideasFilePath === 'string' && ideasFilePath) ? ideasFilePath : '';
+    const { highestId, openIdeas } = this.getExistingIdeas(safePath);
+    let nextId = highestId + 1;
+    const newlyAdded = [];
+
+    const existingNormalized = openIdeas.map(i => i.toLowerCase());
+
+    for (const opp of safeIdeas) {
+      if (openIdeas.length + newlyAdded.length >= this.maxOpenIdeas) {
+        break; // Limite de 10 ideias abertas estritamente respeitado (Regra 14)
+      }
+
+      // Evita duplicatas conceituais
+      const titleLower = String(opp.title || '').toLowerCase();
+      const evidenceLower = String(opp.evidence || '').toLowerCase();
+      const isDuplicate = existingNormalized.some(ex => 
+        (titleLower && ex.includes(titleLower)) || 
+        (evidenceLower && ex.includes(evidenceLower))
+      );
+
+      if (!isDuplicate) {
+        const canonicalLine = this.formatCanonicalIdea(nextId, opp);
+        newlyAdded.push(canonicalLine);
+        nextId++;
+      }
+    }
+
+    if (!safePath || options.dryRun || newlyAdded.length === 0) {
+      return {
+        applied: false,
+        newlyAdded,
+        totalOpenCount: openIdeas.length + newlyAdded.length
+      };
+    }
+
+    // Leitura e inserção atômica no arquivo IDEAS.md
+    let currentContent = fs.existsSync(safePath) ? fs.readFileSync(safePath, 'utf8') : '';
+    
+    // Se o arquivo tiver uma seção de backlog aberto, anexa nela
+    const sectionHeader = '## 🎯 Backlog Aberto de Domínio';
+    if (currentContent.includes(sectionHeader)) {
+      const parts = currentContent.split(sectionHeader);
+      const afterHeader = parts[1];
+      const nextDividerIndex = afterHeader.indexOf('\n---');
+
+      if (nextDividerIndex !== -1) {
+        const insertion = newlyAdded.join('\n') + '\n';
+        const sanitizedAfterContent = afterHeader.slice(0, nextDividerIndex) + '\n' + insertion + afterHeader.slice(nextDividerIndex);
+        currentContent = parts[0] + sectionHeader + sanitizedAfterContent;
+      } else {
+        currentContent += '\n' + newlyAdded.join('\n') + '\n';
+      }
+    } else {
+      // Cria template básico se não existir
+      currentContent = `# IDEAS (Backlog Vivo de Oportunidades & Inovação de Domínio)\n\n` +
+        `Este documento registra o backlog rotativo de melhorias e hipóteses técnicas em aberto, auditadas pelo **AGENT_QA (Shift-Left Gatekeeper)** e estritamente aderentes à **Regra 14 (Filtro de Sanidade Contextual)**.\n\n` +
+        `## 🎯 Backlog Aberto de Domínio (Até 10 Itens Ordenados por Valor)\n\n` +
+        newlyAdded.join('\n') + '\n';
+    }
+
+    try {
+      const parentDir = path.dirname(safePath);
+      if (!fs.existsSync(parentDir)) {
+        fs.mkdirSync(parentDir, { recursive: true });
+      }
+      fs.writeFileSync(safePath, currentContent, 'utf8');
+      return {
+        applied: true,
+        newlyAdded,
+        totalOpenCount: openIdeas.length + newlyAdded.length
+      };
+    } catch (_) {
+      return {
+        applied: false,
+        newlyAdded: [],
+        totalOpenCount: openIdeas.length
+      };
+    }
+  }
+
+  /**
+   * Formata relatório executivo em Markdown do escaneamento.
+   * @param {object} result 
+   * @returns {string}
+   */
+  formatReport(result) {
+    return formatReport(result);
+  }
+}
+
+/**
+ * Formata relatório executivo em Markdown da mineração de ideias.
+ * @param {object} result 
+ * @returns {string}
+ */
+function formatReport(result) {
+  if (!result || typeof result !== 'object') {
+    return '# 💡 Agent-Master DevSecOps — Domain Idea Miner Report\n\nNenhuma oportunidade minerada ou resultado indisponível.';
+  }
+
+  let output = '# 💡 Agent-Master DevSecOps — Domain Idea Miner Report\n\n';
+  output += `**Arquivos Analisados:** ${result.scannedFilesCount || 0}\n`;
+  output += `**Oportunidades Identificadas:** ${result.opportunitiesFound || (result.opportunities ? result.opportunities.length : 0)}\n\n`;
+
+  const opps = Array.isArray(result.opportunities) ? result.opportunities : [];
+  if (opps.length === 0) {
+    output += '✅ **Nenhum gargalo evidente detectado.** O código analisado atende aos padrões de resiliência, performance e contratos.\n';
+  } else {
+    output += '### 🎯 Oportunidades por Prioridade (Regra 14)\n\n';
+    opps.forEach((opp, idx) => {
+      output += `${idx + 1}. **[${opp.category}]** ${opp.title}\n`;
+      output += `   - **Evidência:** \`${opp.evidence}\`\n`;
+      output += `   - **Valor:** ${opp.value}\n`;
+      output += `   - **Custo:** \`${opp.cost}\` | **Prioridade:** \`${opp.priority}\`\n\n`;
+    });
+  }
+
+  if (result.syncResult) {
+    output += '### 📝 Sincronização com `docs/IDEAS.md`\n';
+    output += `- **Aplicado no Disco:** ${result.syncResult.applied ? 'SIM' : 'NÃO (Simulação / Sem novas ideias)'}\n`;
+    output += `- **Novas Ideias Adicionadas:** ${result.syncResult.newlyAdded ? result.syncResult.newlyAdded.length : 0}\n`;
+    output += `- **Total de Ideias Abertas:** ${result.syncResult.totalOpenCount || 0}/10\n`;
+  }
+
+  return output;
+}
+
+/**
+ * Helper direto para execução programática compatível com toda a suíte.
+ * @param {string} [targetDir=process.cwd()] 
+ * @param {object} [options={}] 
+ * @returns {object}
+ */
+function mineDomainIdeas(targetDir = process.cwd(), options = {}) {
+  const safeTargetDir = (typeof targetDir === 'string' && targetDir) ? targetDir : process.cwd();
+  const safeOptions = (options && typeof options === 'object') ? options : {};
+  const miner = new DomainIdeaMiner({ rootDir: safeTargetDir, maxOpenIdeas: safeOptions.maxOpenIdeas || 10 });
+  const opportunities = miner.mineIdeas(safeTargetDir);
+  const ideasFilePath = safeOptions.ideasFilePath || path.join(safeTargetDir, 'docs', 'IDEAS.md');
+
+  let syncResult = { applied: false, newlyAdded: [] };
+  if (safeOptions.autoApply) {
+    syncResult = miner.syncWithIdeasFile(opportunities, ideasFilePath, { dryRun: safeOptions.dryRun });
+  }
+
+  return {
+    scannedFilesCount: miner.collectCodeFiles(safeTargetDir).length,
+    opportunitiesFound: opportunities.length,
+    opportunities,
+    syncResult
+  };
+}
+
+module.exports = {
+  DomainIdeaMiner,
+  mineDomainIdeas,
+  formatReport,
+  IDEA_RULES,
+  IGNORED_DIRS,
+  CODE_EXTENSIONS
+};
+
+// Execução CLI direta quando chamado via terminal
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const autoApply = args.includes('--apply');
+  const dryRun = args.includes('--dry-run');
+  const targetDir = process.cwd();
+
+  console.log(`🔍 [Domain Idea Miner] Iniciando varredura em: ${targetDir}`);
+  const result = mineDomainIdeas(targetDir, { autoApply, dryRun });
+
+  console.log(`📊 Arquivos analisados: ${result.scannedFilesCount}`);
+  console.log(`💡 Oportunidades identificadas: ${result.opportunitiesFound}`);
+
+  result.opportunities.forEach((opp, i) => {
+    console.log(`  ${i + 1}. [${opp.category}] ${opp.title}`);
+    console.log(`     Evidência: ${opp.evidence} | Valor: ${opp.value}`);
+  });
+
+  if (autoApply) {
+    console.log(`📝 Ideias sincronizadas com IDEAS.md: ${result.syncResult.newlyAdded.length} adicionadas.`);
+  }
+}