@mocoto/mahoraga 0.14.8 → 0.15.0

package/dist/core/config/filters.js

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

package/dist/core/config/format.js

@@ -1,10 +1,3 @@
-// SPDX-License-Identifier: MIT
-/**
- * Utilitários de formatação padronizada para métricas e valores numéricos
- */
-/**
- * Formata milissegundos em string legível
- */
 export function formatMs(valor) {
     if (valor === null || valor === undefined || Number.isNaN(valor)) {
         return '-';

package/dist/core/config/include-exclude.js

@@ -1,15 +1,9 @@
 import micromatch from 'micromatch';
-/**
- * Avalia se um caminho deve ser incluído conforme config simplificada.
- * Hierarquia: CLI flags > globalExcludeGlob > inclui por padrão
- */
 export function shouldInclude(relPath, entry, config) {
-    // APENAS globalExcludeGlob é considerado - outros campos são ignorados
     if (Array.isArray(config.globalExcludeGlob) &&
         config.globalExcludeGlob.length > 0 &&
         micromatch.isMatch(relPath, config.globalExcludeGlob)) {
         return false;
     }
-    // Default: inclui se não excluído
     return true;
 }

package/dist/core/config/index.js

@@ -1,4 +1,3 @@
-// Default export
 export * from './chalk-safe.js';
 export * from './config.js';
 export * from './config-defaults.js';

package/dist/core/config/limites.js

@@ -1,10 +1,4 @@
-// SPDX-License-Identifier: MIT
-/**
- * Limites e thresholds padrão para análise de código e detectores.
- * Centraliza "números mágicos" para facilitar a configuração e overrides.
- */
 export const LIMITES_PADRAO = {
-    // Limites de código para detector-codigo-fragil e analista-funcoes-longas
     CODIGO: {
         MAX_LINHAS_FUNCAO: 30,
         MAX_PARAMETROS_FUNCAO: 4,
@@ -15,21 +9,17 @@ export const LIMITES_PADRAO = {
         MAX_ANINHAMENTO_IF: 3,
         MAX_LINHAS_ARQUIVO: 300
     },
-    // Limites para detecção de arquivos fantasmas (ghost files)
     GUARDIAN: {
         DIAS_INATIVIDADE_GHOST: 45
     },
-    // Thresholds de segurança e entropia
     SEGURANCA: {
         ENTROPIA_SHANNON_ALTA: 3.5
     },
-    // Configurações de auto-fix
     AUTO_FIX: {
         CONFIANCA_MINIMA: 75,
         TIMEOUT_PADRAO_MS: 60000,
         TIMEOUT_TESTE_MS: 1000
     },
-    // Timeouts globais
     TIMEOUTS: {
         ANALISTA_PADRAO_MS: 30000,
         ARQUETIPO_DETECCAO_MS: 30000

package/dist/core/config/paths.js

@@ -1,20 +1,13 @@
-// SPDX-License-Identifier: MIT
-// Centraliza padrões e utilidades de caminhos para evitar hardcodes dispersos
 export const SRC_RAIZ = 'src';
 export const SRC_GLOB = 'src/**';
-// Diretórios sempre tratados como meta (independente de SRC)
 export const META_DIRS = ['.github', '.vscode', '.mahoraga'];
-// Normaliza para separador POSIX
 export function toPosix(caminho) {
     return (caminho || '').replace(/\\+/g, '/');
 }
-// Caminho relativo (POSIX) está dentro de src?
 export function isInsideSrc(relPath) {
     const raiz = toPosix(relPath);
-    // Considera qualquer segmento que case com src, source ou codigo: (^|/)(src|source|codigo)(/|$)
     return /(?:^|\/)(?:src|source|codigo)(?:\/|$)/i.test(raiz);
 }
-// Heurística de meta: tudo fora de src é meta, além dos diretórios explícitos
 export function isMetaPath(relPath) {
     const raiz = toPosix(relPath);
     if (META_DIRS.some(diretorio => raiz === diretorio || raiz.startsWith(`${diretorio}/`))) {

package/dist/core/config/security.js

@@ -1,11 +1,4 @@
-// SPDX-License-Identifier: MIT
 import path from 'node:path';
-/**
- * Sanitiza um caminho relativo, eliminando tentativas de escape (..),
- * barras duplicadas e separadores inconsistentes.
- * @param rel - Caminho relativo a sanitizar
- * @returns Caminho normalizado e seguro
- */
 export function sanitizarRelPath(rel) {
     if (!rel) {
         return '';
@@ -14,30 +7,15 @@ export function sanitizarRelPath(rel) {
     const norm = safe.replace(/\\+/g, '/');
     const collapsed = path.posix.normalize(norm);
     if (collapsed.startsWith('..')) {
-        // remove todos os prefixos de ../ e ./ e barras iniciais resultantes
         const semDots = collapsed.replace(new RegExp('^(\\.\\.\\/?|\\.\\/)+'), '');
         return semDots.replace(/^\/+/, '');
     }
     return collapsed.replace(/^\/+/, '');
 }
-/**
- * Verifica se um caminho alvo está contido dentro do diretório base.
- * Impede acesso a caminhos fora da raiz do projeto.
- * @param baseDir - Diretório base de referência
- * @param alvo - Caminho absoluto do alvo a verificar
- * @returns `true` se o alvo está dentro do baseDir
- */
 export function estaDentro(baseDir, alvo) {
     const rel = path.relative(baseDir, alvo);
     return !!rel && !rel.startsWith('..') && !path.isAbsolute(rel);
 }
-/**
- * Resolve o caminho de um plugin de forma segura, verificando se está
- * dentro da raiz do projeto e se possui extensão permitida.
- * @param baseDir - Diretório raiz do projeto
- * @param pluginRel - Caminho relativo do plugin
- * @returns Objeto com `caminho` resolvido ou `erro` descritivo
- */
 export function resolverPluginSeguro(baseDir, pluginRel) {
     try {
         if (typeof pluginRel !== 'string' || !pluginRel.trim()) {
@@ -51,7 +29,6 @@ export function resolverPluginSeguro(baseDir, pluginRel) {
                 erro: 'plugin fora da raiz do projeto (bloqueado)'
             };
         }
-        // Restringe extensões para reduzir risco de execução arbitrária
         const permitido = [/\.(c|m)?js$/i, /\.ts$/i];
         if (!permitido.some(raiz => raiz.test(resolvido))) {
             return {
@@ -68,28 +45,16 @@ export function resolverPluginSeguro(baseDir, pluginRel) {
         };
     }
 }
-/**
- * Valida se um padrão glob é seguro para uso, bloqueando
- * padrões excessivamente longos ou com muitos wildcards recursivos.
- * @param padrao - Padrão glob a validar
- * @returns `true` se o padrão é considerado seguro
- */
 export function validarGlobBasico(padrao) {
     if (padrao.length > 300) {
         return false;
     }
-    // Bloqueia mais de 4 ocorrências de '**' mesmo não consecutivas
     const ocorrencias = (padrao.match(/\*\*/g) ?? []).length;
     if (ocorrencias >= 5) {
         return false;
     }
     return true;
 }
-/**
- * Filtra uma lista de padrões glob, retornando apenas os que são seguros.
- * @param padroes - Lista de padrões glob a filtrar
- * @returns Lista contendo apenas os padrões que passaram na validação
- */
 export function filtrarGlobSeguros(padroes) {
     return padroes.filter(caminho => validarGlobBasico(caminho));
 }

package/dist/core/config/traverse.js

@@ -1,7 +1,5 @@
-// SPDX-License-Identifier: MIT
 import traverseModule from '@babel/traverse';
 let _traverseModule = traverseModule;
-// Setter usado apenas em testes para injetar variações do módulo
 export function __setTraverseModule(modulo) {
     _traverseModule = modulo;
 }

package/dist/core/corrections/auto-fix.js

@@ -1,5 +1 @@
-// SPDX-License-Identifier: MIT
-/**
- * Tipos para sistema de quick fixes de configuração automática
- */
 export {};

package/dist/core/execution/ambiente.js

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

package/dist/core/execution/analysis-cache.js

@@ -1,20 +1,10 @@
-// SPDX-License-Identifier: MIT
-// Cache de análise persistente entre execuções
 import XXH from 'xxhashjs';
 import { config } from '../config/index.js';
 import { lerEstado, salvarEstado } from '../../shared/persistence/index.js';
-/**
- * Cache de análise entre execuções.
- * Armazena resultados de análise por hash de conteúdo de arquivo,
- * permitindo reuso em execuções subsequentes.
- */
 export class AnalysisCache {
     cache = {};
     loaded = false;
     loadingPromise = null;
-    /**
-     * Carrega o cache do disco com proteção contra re-entrância
-     */
     async load() {
         if (this.loaded) {
             return;
@@ -36,16 +26,12 @@ export class AnalysisCache {
             }
         }
         catch {
-            // usa estado vazio
         }
         finally {
             this.loaded = true;
             this.loadingPromise = null;
         }
     }
-    /**
-     * Obtém resultado em cache para um arquivo
-     */
     async get(relPath, conteudo) {
         if (!config.ANALISE_CACHE_ENABLED) {
             return null;
@@ -56,7 +42,6 @@ export class AnalysisCache {
         if (entry?.hash !== hash) {
             return null;
         }
-        // Verifica TTL
         if (config.ANALISE_CACHE_TTL_MS > 0) {
             const idade = Date.now() - entry.timestamp;
             if (idade > config.ANALISE_CACHE_TTL_MS) {
@@ -64,12 +49,8 @@ export class AnalysisCache {
                 return null;
             }
         }
-        // Verifica se o arquivo ainda existe e tem o mesmo tamanho
         return entry.ocorrencias;
     }
-    /**
-     * Armazena resultado de análise no cache
-     */
     async set(relPath, conteudo, ocorrencias) {
         if (!config.ANALISE_CACHE_ENABLED) {
             return;
@@ -82,23 +63,14 @@ export class AnalysisCache {
             count: ocorrencias.length
         };
     }
-    /**
-     * Remove entrada do cache
-     */
     async invalidate(relPath) {
         await this.load();
         Reflect.deleteProperty(this.cache, relPath);
     }
-    /**
-     * Limpa todo o cache
-     */
     async clear() {
         this.cache = {};
         await this.persistir();
     }
-    /**
-     * Salva cache no disco
-     */
     async persistir() {
         if (!config.ANALISE_CACHE_ENABLED) {
             return;
@@ -110,9 +82,6 @@ export class AnalysisCache {
         };
         await salvarEstado(config.ANALISE_CACHE_STATE_PATH, data);
     }
-    /**
-     * Retorna estatísticas do cache
-     */
     estatisticas() {
         const entradas = Object.keys(this.cache);
         const totalOcorrencias = entradas.reduce((acc, key) => acc + this.cache[key].count, 0);
@@ -137,5 +106,4 @@ export class AnalysisCache {
         }
     }
 }
-// Singleton
 export const analysisCache = new AnalysisCache();

package/dist/core/execution/ast-cache.js

@@ -1,18 +1,5 @@
 import { decifrarSintaxe, TEM_PARSER } from '../parsing/parser.js';
 const AST_SENTINEL = {};
-/**
- * Cache de AST com escopo de execução.
- *
- * Compartilha ASTs entre analistas que processam o mesmo arquivo
- * durante uma única execução de análise. Elimina re-parsing
- * desnecessário quando múltiplas técnicas atuam sobre o mesmo arquivo.
- *
- * Funciona em conjunto com o cache global (process-level) mantido
- * pelo inquisidor, mas adiciona uma camada por escopo que:
- * - Garante consistência dentro da mesma execução
- * - Prepara o terreno para parsing lazy (parsear sob demanda)
- * - Coleta métricas granulares por escopo
- */
 export class ScopeAstCache {
     cache = new Map();
     metrics = {
@@ -21,34 +8,25 @@ export class ScopeAstCache {
         parseTimeMs: 0,
         cachedFiles: 0,
     };
-    /**
-     * Obtém ou faz parse do AST para um arquivo.
-     * Primeiro verifica o cache do escopo, depois o cache global
-     * (process-level), e por fim faz o parsing do conteúdo.
-     */
     async getOrParse(entry, ext) {
         const key = entry.relPath;
-        // 1) Cache do escopo atual
         const cached = this.cache.get(key);
         if (cached !== undefined) {
             this.metrics.hits++;
             return cached;
         }
-        // Pula extensões sem parser registrado
         if (!TEM_PARSER(ext)) {
             this.cache.set(key, null);
             return null;
         }
-        // 2) Cache global (process-level) do inquisidor
         const globalStore = globalThis;
-        const globalCache = globalStore.__SUKUNA_AST_CACHE__;
+        const globalCache = globalStore.__MAHORAGA_AST_CACHE__;
         const globalEntry = globalCache?.get(key);
         if (globalEntry?.ast) {
             this.cache.set(key, globalEntry.ast);
             this.metrics.hits++;
             return globalEntry.ast;
         }
-        // 3) Parsing sob demanda
         this.metrics.misses++;
         const inicio = performance.now();
         let ast = null;
@@ -65,21 +43,12 @@ export class ScopeAstCache {
         this.metrics.cachedFiles = this.cache.size;
         return ast;
     }
-    /**
-     * Verifica se um arquivo já está em cache neste escopo
-     */
     has(relPath) {
         return this.cache.has(relPath);
     }
-    /**
-     * Retorna métricas acumuladas do escopo atual
-     */
     getMetrics() {
         return { ...this.metrics };
     }
-    /**
-     * Limpa o cache do escopo
-     */
     clear() {
         this.cache.clear();
         this.metrics = { hits: 0, misses: 0, parseTimeMs: 0, cachedFiles: 0 };

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';