@mocoto/mahoraga 0.14.7 → 0.14.9

package/dist/core/execution/executor.js

@@ -1,5 +1,3 @@
-// @mahoraga-disable ml-deep-nesting
-// SPDX-License-Identifier: MIT
 import crypto from 'node:crypto';
 import path from 'node:path';
 import XXH from 'xxhashjs';
@@ -105,8 +103,6 @@ export async function executarInquisicao(fileEntriesComAst, tecnicas, baseDir, g
     };
     const reporter = createDefaultReporter();
     const inicioExecucao = performance.now();
-    // Cache de AST compartilhado entre analistas no mesmo escopo
-    // Parsing lazy: ASTs são parseados sob demanda via getOrParse
     const scopeAstCache = new ScopeAstCache();
     function hasNodeType(x) {
         if (typeof x !== 'object' || x === null) {
@@ -172,7 +168,6 @@ export async function executarInquisicao(fileEntriesComAst, tecnicas, baseDir, g
             }
         }
     }
-    // Incremental: carregar estado anterior (tipo importado de @types)
     let estadoIncremental = null;
     if (config.ANALISE_INCREMENTAL_ENABLED) {
         const lido = await lerEstado(config.ANALISE_INCREMENTAL_STATE_PATH).catch(() => null);
@@ -191,13 +186,9 @@ export async function executarInquisicao(fileEntriesComAst, tecnicas, baseDir, g
     };
     function hashConteudo(elem) {
         try {
-            // Usa xxhash64 (seed arbitrária) para performance
             return XXH.h64(elem, 0xabcd).toString(16);
         }
         catch {
-            // Fallback para SHA1 se algo der errado
-            // SHA1 usado apenas para cache de AST (fingerprinting de conteúdo)
-            // Não é usado para segurança/criptografia - contexto: deduplicação de parsing
             return crypto.createHash('sha1').update(elem).digest('hex');
         }
     }
@@ -225,7 +216,7 @@ export async function executarInquisicao(fileEntriesComAst, tecnicas, baseDir, g
                 novoEstado.estatisticas.ultimaDuracaoMs = duracao;
                 await salvarEstado(config.ANALISE_INCREMENTAL_STATE_PATH, novoEstado);
             }
-            catch { /* Ignora erro ao salvar cache */ }
+            catch { }
         }
         const metricasExecucao = {
             totalArquivos: fileEntriesComAst.length,
@@ -259,7 +250,6 @@ export async function executarInquisicao(fileEntriesComAst, tecnicas, baseDir, g
     if (usarWorkerPool && fileEntriesComAst.length > 0) {
         return processarWorkerPool();
     }
-    // Técnicas por arquivo (modo sequencial padrão)
     const contextoGlobal = {
         ...contextoGlobalBase,
         report: event => {
@@ -267,7 +257,6 @@ export async function executarInquisicao(fileEntriesComAst, tecnicas, baseDir, g
                 pushOcorrencia(reporter(event));
             }
             catch (erro) {
-                // Reporter nunca deve quebrar a análise; se falhar, emite ocorrência genérica.
                 pushOcorrencia(ocorrenciaErroAnalista({
                     mensagem: messages.ExecutorExtraMensagens.falhaReporter(erro instanceof Error ? erro.message : String(erro)),
                     relPath: event.relPath || '[report]',
@@ -279,12 +268,9 @@ export async function executarInquisicao(fileEntriesComAst, tecnicas, baseDir, g
     const visitorCombinado = combinarVisitors(tecnicas);
     let arquivoAtual = 0;
     const totalArquivos = fileEntriesComAst.length;
-    // Limiar para logs detalhados por arquivo
-    const LIMIAR_DETALHE_TOTAL = 100; // até aqui permite detalhar por arquivo
-    const LIMIAR_DETALHE_LIMITADO_MAX = 250; // até aqui permite "Arquivo X/Y" com throttle
-    // Define passo de logging quando em modo verbose para evitar spam massivo
+    const LIMIAR_DETALHE_TOTAL = 100;
+    const LIMIAR_DETALHE_LIMITADO_MAX = 250;
     function passoDeLog(total) {
-        // Assumimos faixas: até 100 => cada arquivo; 101-250 => a cada 10; 251-500 => a cada 25; >500 => a cada 100
         if (total <= 100) {
             return 1;
         }
@@ -300,9 +286,7 @@ export async function executarInquisicao(fileEntriesComAst, tecnicas, baseDir, g
     const stepVerbose = passoDeLog(totalArquivos);
     const detalharPorArquivo = (opts?.verbose ?? false) && totalArquivos <= LIMIAR_DETALHE_TOTAL;
     const permitirArquivoXY = (opts?.verbose ?? false) && totalArquivos <= LIMIAR_DETALHE_LIMITADO_MAX;
-    // Inicializa sistema de logs inteligente
     messages.logAnalistas.iniciarBatch(totalArquivos);
-    // Pool de objetos reutilizáveis entre arquivos (reduz GC pressure)
     const resultadosOtimizados = new Map();
     for (const entry of fileEntriesComAst) {
         arquivoAtual++;
@@ -313,7 +297,6 @@ export async function executarInquisicao(fileEntriesComAst, tecnicas, baseDir, g
             }
         }
         else if (opts?.verbose) {
-            // Em verbose: detalha por arquivo somente até o limiar; entre 101-250 mostra "Arquivo X/Y" com throttle; acima disso, só resumo de progresso.
             if (permitirArquivoXY) {
                 if (arquivoAtual === 1 || arquivoAtual % stepVerbose === 0 || arquivoAtual === totalArquivos) {
                     const seta = frames[arquivoAtual % frames.length];
@@ -327,27 +310,22 @@ export async function executarInquisicao(fileEntriesComAst, tecnicas, baseDir, g
             }
         }
         else if (arquivoAtual % 50 === 0 || arquivoAtual === totalArquivos) {
-            // Modo padrão: log apenas a cada 50 arquivos para reduzir ruído
             if (arquivoAtual === totalArquivos) {
                 infoDestaque(messages.ExecutorExtraMensagens.progresso.replace('{atual}', String(arquivoAtual)).replace('{total}', String(totalArquivos)));
             }
         }
-        // Resolve AST via cache compartilhado do escopo
         const ext = path.extname(entry.relPath);
         const astDoCache = await scopeAstCache.getOrParse(entry, ext);
         const astParaUso = astDoCache ?? entry.ast;
-        // Verifica incremento com fallback para diff estrutural
         const conteudo = entry.content ?? '';
         const hash = hashConteudo(conteudo);
         const cacheAnterior = estadoIncremental?.arquivos[entry.relPath];
         let reaproveitou = false;
         if (config.ANALISE_INCREMENTAL_ENABLED && cacheAnterior) {
             if (cacheAnterior.hash === hash) {
-                // Conteúdo exato igual → reuso total
                 reaproveitou = true;
             }
             else if (cacheAnterior.hashEstrutural) {
-                // Conteúdo mudou, verifica se apenas formatação/comentários mudaram
                 const hashEstrutural = calcularHashEstrutural(astParaUso, conteudo);
                 if (hashEstrutural && hashEstrutural === cacheAnterior.hashEstrutural) {
                     reaproveitou = true;
@@ -375,8 +353,7 @@ export async function executarInquisicao(fileEntriesComAst, tecnicas, baseDir, g
         }
         if (reaproveitou) {
             continue;
-        } // pula analistas
-        // Cache de análise entre execuções
+        }
         if (config.ANALISE_CACHE_ENABLED) {
             const cached = await analysisCache.get(entry.relPath, entry.content ?? '');
             if (cached !== null) {
@@ -395,14 +372,13 @@ export async function executarInquisicao(fileEntriesComAst, tecnicas, baseDir, g
                 continue;
             }
         }
-        // Otimização: Travessia única para analistas com visitor
         if (Object.keys(visitorCombinado).length > 0 && astParaUso) {
             try {
                 const astParam = hasNodeType(astParaUso) ? astParaUso.node : astParaUso;
                 traverse(astParam, visitorCombinado, undefined, {
                     relPath: entry.relPath,
                     contexto: contextoGlobal,
-                    resultados: resultadosOtimizados // Mapa de analista -> achados
+                    resultados: resultadosOtimizados
                 });
             }
             catch (err) {
@@ -416,11 +392,9 @@ export async function executarInquisicao(fileEntriesComAst, tecnicas, baseDir, g
             if (tecnica.test && !tecnica.test(entry.relPath)) {
                 continue;
             }
-            // início medido apenas por analista específico (inicioAnalista)
             const timeoutMs = config.ANALISE_TIMEOUT_POR_ANALISTA_MS;
             try {
                 const inicioAnalista = performance.now();
-                // Log adaptativo: início da análise
                 const tamanhoArquivo = entry.content ? Math.round(entry.content.length / 1024) : 0;
                 messages.logAnalistas.iniciandoAnalista(tecnica.nome ?? 'analista-desconhecido', entry.relPath, tamanhoArquivo);
                 let resultado;
@@ -449,7 +423,6 @@ export async function executarInquisicao(fileEntriesComAst, tecnicas, baseDir, g
                         global: false
                     });
                 }
-                // Log adaptativo: conclusão da análise
                 const ocorrenciasContagem = Array.isArray(resultado) ? resultado.length : resultado ? 1 : 0;
                 messages.logAnalistas.concluido(tecnica.nome ?? 'analista-desconhecido', entry.relPath, ocorrenciasContagem, duracaoMs);
                 if (detalharPorArquivo) {
@@ -470,7 +443,6 @@ export async function executarInquisicao(fileEntriesComAst, tecnicas, baseDir, g
                 const isTempoLimite = err.message.includes('Timeout: analista');
                 const nivelLog = isTempoLimite ? 'aviso' : 'erro';
                 const prefixo = isTempoLimite ? '[CLOCK]' : '[ERRO]';
-                // Log adaptativo para erros e timeouts
                 if (isTempoLimite) {
                     const duracaoEstimada = config.ANALISE_TIMEOUT_POR_ANALISTA_MS || 30000;
                     messages.logAnalistas.timeout(tecnica.nome ?? 'analista-desconhecido', duracaoEstimada);
@@ -478,13 +450,11 @@ export async function executarInquisicao(fileEntriesComAst, tecnicas, baseDir, g
                 else {
                     messages.logAnalistas.erro(tecnica.nome ?? 'analista-desconhecido', err.message);
                 }
-                // Log apropriado baseado no tipo de erro
                 if (nivelLog === 'aviso') {
                     messages.log.aviso(`${prefixo} ${err.message}`);
                 }
                 else {
                     messages.log.erro(`${prefixo} Erro em '${tecnica.nome}' para ${entry.relPath}: ${err.message}`);
-                    // Exibe stack trace em modo verbose ou debug
                     if (err.stack) {
                         if (opts?.verbose || config.DEV_MODE) {
                             messages.log.info(messages.ExecutorExtraMensagens.stackTrace);
@@ -492,7 +462,6 @@ export async function executarInquisicao(fileEntriesComAst, tecnicas, baseDir, g
                         }
                     }
                 }
-                // Registra ocorrência de erro/timeout com stack trace
                 pushOcorrencia(ocorrenciaErroAnalista({
                     mensagem: isTempoLimite ? `Timeout na técnica '${tecnica.nome}' para ${entry.relPath}: ${timeoutMs}ms excedido` : `Falha na técnica '${tecnica.nome}' para ${entry.relPath}: ${err.message}`,
                     relPath: entry.relPath,
@@ -501,15 +470,12 @@ export async function executarInquisicao(fileEntriesComAst, tecnicas, baseDir, g
                 }));
             }
         }
-        // Salva no cache de análise entre execuções
         if (config.ANALISE_CACHE_ENABLED) {
             const ocorrArquivoCache = ocorrencias.filter(o => o.relPath === entry.relPath);
             await analysisCache.set(entry.relPath, entry.content ?? '', ocorrArquivoCache);
         }
-        // Salva estado incremental do arquivo processado
         if (config.ANALISE_INCREMENTAL_ENABLED) {
             const ocorrArq = ocorrencias.filter(ocorrencia => ocorrencia.relPath === entry.relPath);
-            // Extrai métricas por analista específicas do arquivo
             const analistasArquivo = {};
             for (const metrica of metricasAnalistas.filter(metrica => !metrica.global)) {
                 analistasArquivo[metrica.nome] = {
@@ -528,7 +494,6 @@ export async function executarInquisicao(fileEntriesComAst, tecnicas, baseDir, g
             };
             novoEstado.estatisticas.totalArquivosProcessados = (novoEstado.estatisticas.totalArquivosProcessados || 0) + 1;
         }
-        // NOVO: Atualiza progresso por arquivo (não por analista)
         messages.logAnalistas.arquivoProcessado();
         if (emitter) {
             const ocorrArquivo = ocorrencias.filter(ocorrencia => ocorrencia.relPath === entry.relPath);
@@ -543,7 +508,7 @@ export async function executarInquisicao(fileEntriesComAst, tecnicas, baseDir, g
     messages.logAnalistas.finalizarBatch(ocorrencias.length, duracaoMs);
     let metricasExecucao = null;
     if (config.ANALISE_METRICAS_ENABLED) {
-        const metricasGlobais = getGlobalExec().__SUKUNA_METRICAS__ ?? { parsingTimeMs: 0, cacheHits: 0, cacheMiss: 0 };
+        const metricasGlobais = getGlobalExec().__MAHORAGA_METRICAS__ ?? { parsingTimeMs: 0, cacheHits: 0, cacheMiss: 0 };
         const astCacheMetrics = scopeAstCache.getMetrics();
         metricasExecucao = {
             totalArquivos: fileEntriesComAst.length,
@@ -599,9 +564,8 @@ export async function executarInquisicao(fileEntriesComAst, tecnicas, baseDir, g
 }
 export function registrarUltimasMetricas(metricas) {
     try {
-        getGlobalExec().__ULTIMAS_METRICAS_SUKUNA__ = metricas ?? null;
+        getGlobalExec().__ULTIMAS_METRICAS_MAHORAGA__ = metricas ?? null;
     }
     catch {
-        /* ignore */
     }
 }

package/dist/core/execution/fix-001.js

@@ -1,14 +1,5 @@
-// SPDX-License-Identifier: MIT
-/**
- * [CHAVE-INGLESA] Módulo de Autofix
- *
- * Aplica correções sugeridas automaticamente aos arquivos suportados.
- */
 import fs from 'node:fs';
 import { splitLines } from '../../shared/helpers/index.js';
-/**
- * Aplica correções estruturadas no conteúdo do arquivo.
- */
 export function aplicarCorrecoes(conteudo, ocorrencias) {
     const ocorrenciasComFix = ocorrencias.filter(ocorrencia => !!ocorrencia.correcao && ocorrencia.linha);
     if (ocorrenciasComFix.length === 0) {
@@ -23,7 +14,6 @@ export function aplicarCorrecoes(conteudo, ocorrencias) {
         }
         const idx = oc.linha - 1;
         if (idx >= 0 && idx < linhas.length && !modificadas.has(idx)) {
-            // Garantir que a linha ainda possui o trecho original esperado (para segurança)
             if (linhas[idx].includes(fix.original)) {
                 linhas[idx] = linhas[idx].replace(fix.original, fix.novo);
                 modificadas.add(idx);
@@ -32,9 +22,6 @@ export function aplicarCorrecoes(conteudo, ocorrencias) {
     }
     return linhas.join('\n');
 }
-/**
- * Grava o conteúdo corrigido no arquivo.
- */
 export function salvarArquivoCorrigido(absolutePath, novoConteudo) {
     fs.writeFileSync(absolutePath, novoConteudo, 'utf-8');
 }

package/dist/core/execution/index.js

@@ -1,7 +1,3 @@
-// SPDX-License-Identifier: MIT
-/**
- * @fileoverview Core execution: executor, inquisidor, scanner
- */
 export * from './ambiente.js';
 export * from './analysis-cache.js';
 export * from './ast-cache.js';

package/dist/core/execution/inquisitor.js

@@ -1,5 +1,3 @@
-// SPDX-License-Identifier: MIT
-// @mahoraga-disable ml-deep-nesting
 import pLimit from 'p-limit';
 import * as path from 'path';
 import { config, isMetaPath } from '../config/index.js';
@@ -62,7 +60,7 @@ function infoDestaque(mensagem) {
 }
 async function handleParseError(entry) {
     const g = getGlobal();
-    const lista = g.__SUKUNA_PARSE_ERROS__ ?? [];
+    const lista = g.__MAHORAGA_PARSE_ERROS__ ?? [];
     try {
         const babel = await import('@babel/parser');
         try {
@@ -95,7 +93,7 @@ async function handleParseError(entry) {
             origem: 'parser'
         }));
     }
-    g.__SUKUNA_PARSE_ERROS__ = lista;
+    g.__MAHORAGA_PARSE_ERROS__ = lista;
 }
 async function aplicarPriorizacao(entries, metaSet) {
     if (!config.ANALISE_PRIORIZACAO_ENABLED || !config.ANALISE_INCREMENTAL_STATE_PATH) {
@@ -159,13 +157,13 @@ async function aplicarPriorizacao(entries, metaSet) {
 const EXTENSOES_COM_AST = new Set(Array.isArray(config.SCANNER_EXTENSOES_COM_AST) ? config.SCANNER_EXTENSOES_COM_AST : ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']);
 export async function prepararComAst(entries, baseDir) {
     const g = getGlobal();
-    const cache = g.__SUKUNA_AST_CACHE__ ?? new Map();
-    g.__SUKUNA_AST_CACHE__ ??= cache;
-    const metricas = g.__SUKUNA_METRICAS__ ?? { parsingTimeMs: 0, cacheHits: 0, cacheMiss: 0 };
+    const cache = g.__MAHORAGA_AST_CACHE__ ?? new Map();
+    g.__MAHORAGA_AST_CACHE__ ??= cache;
+    const metricas = g.__MAHORAGA_METRICAS__ ?? { parsingTimeMs: 0, cacheHits: 0, cacheMiss: 0 };
     metricas.parsingTimeMs = 0;
     metricas.cacheHits = 0;
     metricas.cacheMiss = 0;
-    g.__SUKUNA_METRICAS__ = metricas;
+    g.__MAHORAGA_METRICAS__ = metricas;
     const CONCURRENCY = config.AUTOANALISE_CONCURRENCY;
     const limit = pLimit(CONCURRENCY);
     return Promise.all(entries.map(entry => limit(async () => {
@@ -208,13 +206,13 @@ export async function prepararComAst(entries, baseDir) {
             catch (erro) {
                 const err = erro instanceof Error ? erro : new Error(String(erro));
                 messages.log.erro(messages.InquisidorMensagens.falhaGerarAst(entry.relPath, err.message));
-                const lista = g.__SUKUNA_PARSE_ERROS__ ?? [];
+                const lista = g.__MAHORAGA_PARSE_ERROS__ ?? [];
                 lista.push(ocorrenciaParseErro({
                     mensagem: messages.InquisidorMensagens.parseErro(err.message),
                     relPath: entry.relPath,
                     origem: 'parser'
                 }));
-                g.__SUKUNA_PARSE_ERROS__ = lista;
+                g.__MAHORAGA_PARSE_ERROS__ = lista;
             }
         }
         return {
@@ -233,12 +231,12 @@ export async function iniciarInquisicao(baseDir = process.cwd(), options = {}, t
             const progressData = JSON.parse(msg);
             if (progressData.tipo === 'diretorio') {
                 const g = getGlobal();
-                g.__SUKUNA_DIR_COUNT__ = (g.__SUKUNA_DIR_COUNT__ ?? 0) + 1;
-                const samples = g.__SUKUNA_DIR_SAMPLES__ ?? [];
+                g.__MAHORAGA_DIR_COUNT__ = (g.__MAHORAGA_DIR_COUNT__ ?? 0) + 1;
+                const samples = g.__MAHORAGA_DIR_SAMPLES__ ?? [];
                 if (samples.length < 5) {
                     const caminho = progressData.caminho ?? '';
                     samples.push(caminho);
-                    g.__SUKUNA_DIR_SAMPLES__ = samples;
+                    g.__MAHORAGA_DIR_SAMPLES__ = samples;
                 }
             }
             else if (progressData.tipo === 'erro') {
@@ -259,7 +257,6 @@ export async function iniciarInquisicao(baseDir = process.cwd(), options = {}, t
         onProgress: onScanProgress
     });
     let entriesBase = Object.values(fileMap);
-    // Filtra arquivos meta com helper central: tudo fora de src/ é meta por padrão
     const metaSet = new Set(entriesBase.filter(erro => isMetaPath(erro.relPath)).map(erro => erro.relPath));
     entriesBase = await aplicarPriorizacao(entriesBase, metaSet);
     const fileEntries = entriesBase.map(entry => ({
@@ -269,8 +266,8 @@ export async function iniciarInquisicao(baseDir = process.cwd(), options = {}, t
     }));
     try {
         const g = getGlobal();
-        const totalDirs = g.__SUKUNA_DIR_COUNT__ ?? 0;
-        const amostra = Array.isArray(g.__SUKUNA_DIR_SAMPLES__) ? g.__SUKUNA_DIR_SAMPLES__ : [];
+        const totalDirs = g.__MAHORAGA_DIR_COUNT__ ?? 0;
+        const amostra = Array.isArray(g.__MAHORAGA_DIR_SAMPLES__) ? g.__MAHORAGA_DIR_SAMPLES__ : [];
         if (config.LOG_ESTRUTURADO) {
             messages.log.info(JSON.stringify({
                 tipo: 'varredura_preliminar',
@@ -280,14 +277,10 @@ export async function iniciarInquisicao(baseDir = process.cwd(), options = {}, t
         }
     }
     catch {
-        /* ignore */
     }
-    // Agora fileEntries é FileEntryWithAst[]
     let totalArquivos = fileEntries.length;
     let ocorrencias = [];
     if (!skipExec) {
-        // Inversão de Controle: tecnicas devem ser fornecidas pelo chamador sempre que skipExec=false.
-        // Para compatibilidade retroativa, se não vierem definidas carregamos dinamicamente o registro.
         let tecnicasEfetivas = tecnicas;
         if (!tecnicasEfetivas) {
             const mod = await import('../../analysts/registry/registry.js');
@@ -297,9 +290,9 @@ export async function iniciarInquisicao(baseDir = process.cwd(), options = {}, t
         totalArquivos = execRes.totalArquivos;
         ocorrencias = execRes.ocorrencias;
     }
-    const parseErros = getGlobal().__SUKUNA_PARSE_ERROS__ ?? [];
+    const parseErros = getGlobal().__MAHORAGA_PARSE_ERROS__ ?? [];
     if (parseErros.length) {
-        getGlobal().__SUKUNA_PARSE_ERROS_ORIGINAIS__ = parseErros.length;
+        getGlobal().__MAHORAGA_PARSE_ERROS_ORIGINAIS__ = parseErros.length;
         if (config.PARSE_ERRO_AGRUPAR) {
             const porArquivo = {};
             for (const pe of parseErros) {

package/dist/core/execution/linguagens.js

@@ -1,2 +1 @@
-// SPDX-License-Identifier: MIT
 export {};

package/dist/core/execution/parse-errors.js

@@ -1,2 +1 @@
-// SPDX-License-Identifier: MIT
 export {};

package/dist/core/execution/registry.js

@@ -1,5 +1 @@
-// SPDX-License-Identifier: MIT
-/**
- * Tipos para o file registry
- */
 export {};

package/dist/core/execution/results.js

@@ -1,2 +1 @@
-// SPDX-License-Identifier: MIT
 export {};

package/dist/core/execution/scanner.js

@@ -19,15 +19,12 @@ function ensureStringArray(val) {
     return val;
 }
 export async function scanRepository(baseDir, options = {}) {
-    // Log de início da varredura
     messages.logVarredor.iniciarVarredura(baseDir);
-    // Helpers locais de normalização (não exportados)
     const toPosix = (string) => string.replace(/\\+/g, '/');
     const trimDotSlash = (string) => string.replace(/^\.\/?/, '');
     const { includeContent = true, filter = () => true, onProgress = () => {
         return undefined;
     } } = options;
-    // Em modo scan-only, não devemos ler conteúdos de arquivos
     const efetivoIncluirConteudo = includeContent && !config.SCAN_ONLY;
     const fileMap = {};
     const statCache = new Map();
@@ -37,14 +34,10 @@ export async function scanRepository(baseDir, options = {}) {
     const includePadroes = ensureStringArray(config.CLI_INCLUDE_PATTERNS);
     const includePadroesNorm = includePadroes.map(caminho => toPosix(trimDotSlash((caminho || ''))));
     const excludePadroesNorm = ensureStringArray(config.CLI_EXCLUDE_PATTERNS).map(caminho => toPosix((caminho || '')));
-    // [PIN] ÚNICO PONTO DE EXCLUDE: globalExcludeGlob da configuração legacy ou campo simplificado
     const legacyExcludes = config.INCLUDE_EXCLUDE_RULES.globalExcludeGlob ?? [];
     const ignorePadroesNorm = ensureStringArray([...legacyExcludes]).map((caminho) => toPosix((caminho || '')));
     const hasIncluir = includeGroupsNorm.length > 0 || includePadroesNorm.length > 0;
-    // Sinaliza quando os includes pedem ocorrências em qualquer profundidade (ex.: '**/nome/**') ou quando
-    // o usuário forneceu nomes simples (que o expandIncludes converte em '**/nome/**').
     const pedeOcorrenciasGlobais = hasIncluir ? [...includePadroesNorm, ...includeGroupsNorm.flat()].some(caminho => caminho.startsWith('**/')) : false;
-    // node_modules explicitamente incluído em algum pattern ou grupo de include
     const includeNodeModulesExplicit = hasIncluir ? [...includePadroesNorm, ...includeGroupsNorm.flat()].some(caminho => /(^|\/)node_modules(\/|$)/.test((caminho || ''))) : false;
     function adicionarArquivoAoMapa(fullCaminho, relPath, content, mtimeMs) {
         fileMap[`$${relPath}`] = { fullCaminho, relPath, content, ultimaModificacao: mtimeMs };
@@ -52,7 +45,6 @@ export async function scanRepository(baseDir, options = {}) {
             onProgress(`[OK] Arquivo lido: ${relPath}`);
         }
     }
-    // Quando includes estão ativos, derivamos diretórios-raiz a partir dos prefixos antes do primeiro metacaractere
     function calcularIncludeRoots(padroes, grupos) {
         const roots = new Set();
         const candidatos = new Set();
@@ -67,7 +59,7 @@ export async function scanRepository(baseDir, options = {}) {
         if (candidatos.size === 0) {
             return [];
         }
-        const META = /[\\*\?\{\}\[\]]/; // caracteres meta de glob
+        const META = /[\\*\?\{\}\[\]]/;
         for (const raw of candidatos) {
             let caminho = raw.trim();
             if (!caminho) {
@@ -88,7 +80,6 @@ export async function scanRepository(baseDir, options = {}) {
                 anchor = '';
             }
             anchor = anchor.replace(/\/+/g, '/').replace(/\/$/, '');
-            // Ignora anchors inválidos: vazios, apenas '.', '**' ou contendo metacaracteres (ex.: '**/src')
             if (anchor && anchor !== '.' && anchor !== '**' && !META.test(anchor)) {
                 const baseNorm = toPosix(baseDir).replace(/\/$/, '');
                 const rootPosix = `${baseNorm}/${anchor}`.replace(/\/+/g, '/');
@@ -97,32 +88,26 @@ export async function scanRepository(baseDir, options = {}) {
         }
         return Array.from(roots);
     }
-    // Matcher de include considerando grupos: AND dentro do grupo, OR entre grupos
     function matchIncluir(relPath) {
-        // Função auxiliar: avalia se um padrão casa com o caminho relativo
         const matchesPadrao = (rp, caminho) => {
             if (!caminho) {
                 return false;
             }
-            // Casamento direto via micromatch
             if (micromatch.isMatch(rp, [caminho])) {
                 return true;
             }
-            // Compat extra: reconhece padrões simples com sufixo '/**' por prefixo
             if (caminho.endsWith('/**')) {
-                const base = caminho.slice(0, -3); // remove '/**'
+                const base = caminho.slice(0, -3);
                 if (base && rp.startsWith(base)) {
                     return true;
                 }
             }
-            // Quando o padrão não possui metacaracteres, trate como diretório/segmento
             const META = /[\\*\?\{\}\[\]]/;
             if (!META.test(caminho)) {
                 const pat = caminho.replace(/\/+$|\/+$|^\.\/?/g, '').replace(/\/+/g, '/');
                 if (!pat) {
                     return false;
                 }
-                // Se contém barra: trate como caminho base (prefixo)
                 if (pat.includes('/')) {
                     if (rp === pat) {
                         return true;
@@ -138,7 +123,6 @@ export async function scanRepository(baseDir, options = {}) {
                     }
                     return false;
                 }
-                // Segmento simples: casa em qualquer nível
                 if (rp === pat) {
                     return true;
                 }
@@ -155,19 +139,16 @@ export async function scanRepository(baseDir, options = {}) {
             }
             return false;
         };
-        // Função auxiliar: extrai a "base" do padrão (token original antes das ampliações)
         const baseFromPadrao = (caminho) => {
             let base = caminho.trim();
-            base = base.replace(/^\*\*\//, ''); // remove '**/' inicial
-            base = base.replace(/\/\*\*$/, ''); // remove '/**' final
-            base = base.replace(/^\.\/?/, ''); // remove './' inicial
+            base = base.replace(/^\*\*\//, '');
+            base = base.replace(/\/\*\*$/, '');
+            base = base.replace(/^\.\/?/, '');
             base = base.replace(/\/+/g, '/').replace(/\/$/, '');
             return base;
         };
-        // Quando houver grupos, aplica estritamente: OR entre grupos com AND dentro do grupo
         if (includeGroupsNorm.length > 0) {
             for (const grupo of includeGroupsNorm) {
-                // Agrupa padrões por base (permite OR entre variantes de um mesmo token e AND entre tokens)
                 const porBase = new Map();
                 for (const caminho of grupo) {
                     const base = baseFromPadrao(caminho);
@@ -180,14 +161,11 @@ export async function scanRepository(baseDir, options = {}) {
                     return true;
                 }
             }
-            // Sem correspondência em nenhum grupo -> não inclui
             return false;
         }
-        // Sem grupos: lista achatada (OR)
         if (includePadroesNorm.length && micromatch.isMatch(relPath, includePadroesNorm)) {
             return true;
         }
-        // Compat extra também para padrões simples quando não há grupos
         for (const caminho of includePadroesNorm) {
             if (matchesPadrao(relPath, caminho)) {
                 return true;
@@ -250,7 +228,6 @@ export async function scanRepository(baseDir, options = {}) {
             }));
             return;
         }
-        // Logar apenas diretórios sendo examinados
         onProgress(JSON.stringify({
             tipo: 'diretorio',
             acao: 'examinar',
@@ -259,10 +236,7 @@ export async function scanRepository(baseDir, options = {}) {
         for (const entry of entries) {
             const fullCaminho = path.join(sanitizedDir, entry.name);
             const relPathRaw = path.relative(baseDir, fullCaminho);
-            // Normaliza para separador POSIX para que micromatch funcione de forma consistente no Windows
             const relPath = toPosix(relPathRaw);
-            // Regra fixa do Mahoraga: não analisar testes (deixa para o runner, ex.: Vitest)
-            // Arquivos auto-gerados / terceiros — pular sempre
             const isThirdParty = (caminho) => {
                 const rp = toPosix(caminho);
                 if (/^THIRD-PARTY[-_]/.test(rp)) {
@@ -360,7 +334,7 @@ export async function scanRepository(baseDir, options = {}) {
                 await scanFn(norm);
                 continue;
             }
-            catch { /* not a dir */ }
+            catch { }
             try {
                 let st = statC.get(norm);
                 if (!st) {
@@ -373,7 +347,7 @@ export async function scanRepository(baseDir, options = {}) {
                         await fs.readdir(norm);
                         isDir = true;
                     }
-                    catch { /* file */ }
+                    catch { }
                 }
                 if (isDir) {
                     await scanFn(norm);
@@ -410,18 +384,13 @@ export async function scanRepository(baseDir, options = {}) {
         }
     }
     let startDirs = hasIncluir ? calcularIncludeRoots(config.CLI_INCLUDE_PATTERNS, cliIncludeGroups) : [];
-    // Quando o include pede ocorrências em qualquer profundidade, adicionamos também a base do repo para
-    // garantir que diretórios-alvo apareçam em níveis arbitrários (ex.: packages/*/node_modules).
     if (hasIncluir && pedeOcorrenciasGlobais) {
         const baseNorm = toPosix(baseDir).replace(/\/$/, '');
         if (!startDirs.includes(baseNorm)) {
             startDirs = [baseNorm, ...startDirs];
         }
     }
-    // Se nenhum root foi derivado (ex.: includes somente de arquivos como 'a.txt'), varremos a base inteira
-    // para permitir que o filtro de includes atue nos arquivos diretamente.
     if (hasIncluir && startDirs.length === 0) {
-        // Sem roots deriváveis (ex.: include apenas 'a.txt'): varre só a raiz para permitir filtro
         await scan(baseDir);
         return fileMap;
     }
@@ -431,7 +400,6 @@ export async function scanRepository(baseDir, options = {}) {
     else {
         await processarStartDirs(startDirs, baseDir, hasIncluir, efetivoIncluirConteudo, scan, matchIncluir, filter, onProgress, excludePadroesNorm, ignorePadroesNorm, statCache);
     }
-    // Log de conclusão da varredura
     const totalArquivos = Object.keys(fileMap).length;
     const totalDiretorios = new Set(Object.values(fileMap).map(arquivo => path.dirname(arquivo.relPath))).size;
     messages.logVarredor.completo(totalArquivos, totalDiretorios);

package/dist/core/execution/schema.js

@@ -1,6 +1 @@
-// SPDX-License-Identifier: MIT
-/**
- * Tipos centralizados para sistema de versionamento de schema
- * Consolidação de: src/core/schema/version.ts e versão anterior
- */
 export {};

package/dist/core/execution/structure-json.js

@@ -1,2 +1 @@
-// SPDX-License-Identifier: MIT
 export {};

package/dist/core/execution/workers.js

@@ -1,5 +1 @@
-// SPDX-License-Identifier: MIT
-/**
- * Tipos para sistema de Worker Pool
- */
 export {};

package/dist/core/formatters/index.js

@@ -1,3 +1,2 @@
-// SPDX-License-Identifier: MIT
 export { inicializarFormattersBuiltin } from './registro-builtin.js';
 export * from './registry.js';