@mocoto/mahoraga 0.14.7 → 0.14.9

package/dist/analysts/detectors/detector-code-fragile.js

@@ -2,7 +2,6 @@ import { config, LIMITES_PADRAO, traverse } from '../../core/config/index.js';
 import { messages } from '../../core/messages/index.js';
 import { agruparPor, detectarComentariosPendentes, detectarFrameworks, detectarLogsDebug, filtrarOcorrenciasSuprimidas, isWhitelistedConstant, splitLines } from '../../shared/helpers/index.js';
 import { criarOcorrencia } from '../../types/index.js';
-// Cache de frameworks detectados (evita múltiplas leituras do package.json)
 let frameworksDetectados = null;
 const LIMITES = {
     LINHAS_FUNCAO: LIMITES_PADRAO.CODIGO.MAX_LINHAS_FUNCAO,
@@ -149,13 +148,11 @@ export const analistaCodigoFragil = {
         }
         return /\.(js|jsx|ts|tsx|mjs|cjs)$/.test(relPath);
     },
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     aplicar: (src, relPath, ast) => {
         if (!ast || !src) {
             return [];
         }
         const fragilidades = [];
-        // Detecções baseadas em texto
         detectarLogsDebug(src).forEach(log => {
             fragilidades.push({
                 tipo: 'console-log',
@@ -184,7 +181,6 @@ export const analistaCodigoFragil = {
                 contexto: `Arquivo com ${lines.length} linhas (máx sugerido: ${LIMITES.MAX_LINHAS_ARQUIVO})`
             });
         }
-        // Processamento AST: Otimizado (preColetado) ou Fallback
         const astMeta = ast;
         if (astMeta?.preColetado) {
             fragilidades.push(...astMeta.preColetado);
@@ -197,20 +193,15 @@ export const analistaCodigoFragil = {
             traverse(nodeToTraverse, visitorFragil, undefined, stateMock);
             fragilidades.push(...(stateMock.resultados.get('codigo-fragil') ?? []));
         }
-        // Detecções de texto complementares (Heurísticas)
         detectarProblemasAvancados(src, fragilidades);
         const ocorrencias = converterFragilidadesParaOcorrencias(fragilidades, relPath);
         return filtrarOcorrenciasSuprimidas(ocorrencias, 'codigo-fragil', src);
     }
 };
-/**
- * Heurísticas avançadas baseadas em padrões de texto
- */
 function detectarProblemasAvancados(src, fragilidades) {
     const lines = splitLines(src);
     for (let indice = 0; indice < lines.length; indice++) {
         const line = lines[indice];
-        // .then() sem .catch()
         if (/\.then\s*\(/.test(line) && !line.includes('.catch') && !src.split('\n')[indice + 1]?.includes('.catch')) {
             fragilidades.push({
                 tipo: 'promise-sem-catch',
@@ -220,7 +211,6 @@ function detectarProblemasAvancados(src, fragilidades) {
                 contexto: 'Promise sem tratamento de erro (.catch)'
             });
         }
-        // Regex complexa
         const regexMatch = line.match(/\/([^\/\\]|\\.)+\/[gimuy]*/);
         if (regexMatch && regexMatch[0].length > LIMITES.REGEX_COMPLEXA_LENGTH && (regexMatch[0].match(/\(/g) ?? []).length > 3) {
             fragilidades.push({
@@ -232,7 +222,6 @@ function detectarProblemasAvancados(src, fragilidades) {
             });
         }
     }
-    // Complexidade Cognitiva
     detectarComplexidadeCognitiva(src, fragilidades);
 }
 function detectarComplexidadeCognitiva(src, fragilidades) {
@@ -258,7 +247,7 @@ function detectarComplexidadeCognitiva(src, fragilidades) {
                 severidade: 'alta',
                 contexto: `Complexidade cognitiva elevada (${score})`
             });
-            score = 0; // Reset para a próxima seção
+            score = 0;
         }
     }
 }

package/dist/analysts/detectors/detector-dependencies.js

@@ -1,15 +1,8 @@
-// @mahoraga-disable ml-deep-nesting react-hooks/regra
-// SPDX-License-Identifier: MIT
 import path from 'node:path';
 import { config, traverse } from '../../core/config/index.js';
 import { messages } from '../../core/messages/index.js';
 import { normalizarPosix, normalizePath, resolverModulo } from '../../shared/helpers/index.js';
 export const grafoDependencias = new Map();
-/**
- * Registro global de imports identificados como usados via registro dinâmico.
- * Chave: relPath do arquivo, Valor: Set de nomes de imports considerados usados.
- * Outros detectores podem consultar antes de reportar "import não usado".
- */
 export const importsUsadosDinamicamente = new Map();
 function ehImportSomenteTipo(node) {
     if (node.importKind === 'type') {
@@ -53,21 +46,6 @@ function verificarCicloConfirmado(ciclo, grafo, arquivosExistentes) {
     }
     return true;
 }
-/**
- * Detecta ciclos complexos no grafo de dependências usando DFS aprimorado
- *
- * Melhorias para reduzir falsos positivos:
- * - Normaliza caminhos antes de comparar
- * - Resolve caminhos relativos para absolutos
- * - Ignora dependências de tipo (type-only imports)
- * - Valida que o ciclo é real (todos os nós existem no grafo)
- * - Retorna caminho completo e limpo do ciclo
- *
- * @param inicio - Arquivo inicial para busca
- * @param grafo - Grafo de dependências completo
- * @param maxProfundidade - Profundidade máxima de busca (evita loops infinitos)
- * @returns Array com caminho do ciclo, ou vazio se não houver ciclo
- */
 function detectarCicloComplexo(inicio, grafo, maxProfundidade = 5) {
     const visitados = new Set();
     const pilha = new Set();
@@ -147,18 +125,6 @@ function detectarCicloComplexo(inicio, grafo, maxProfundidade = 5) {
     }
     return [];
 }
-/**
- * Verifica se um import é usado em padrões de registro dinâmico
- * (ex: registry.register, app.use, plugin.registerPlugin, client.on)
- *
- * Cobertura expandida para Discord.js, Express, Fastify, e outros frameworks:
- * - registry.register(handler) | register(handler)
- * - app.use(middleware) | router.use(handler)
- * - client.on('event', handler)
- * - app.get/post(path, handler)
- *
- * @public Exportada para reuso em outros detectores
- */
 export function isUsadoEmRegistroDinamico(src, importName) {
     const padroesRegistro = [
         `register\\(\\s*${importName}`, `\\.register\\(\\s*${importName}`, `use\\(\\s*${importName}`, `\\.use\\(\\s*${importName}`, `registerPlugin\\(\\s*${importName}`, `addPlugin\\(\\s*${importName}`, `apply\\(\\s*${importName}`, `\\.apply\\(\\s*${importName}`, `load\\(\\s*${importName}`, `\\.load\\(\\s*${importName}`,
@@ -363,10 +329,6 @@ function processarCicloDependencia(state, grafoDependencias) {
         contexto: `Ciclo completo: ${caminhoCompleto}`
     });
 }
-/**
- * Analisa dependências do arquivo (import/require), detecta padrões problemáticos e atualiza grafo global.
- * Retorna ocorrências para imports/require suspeitos, mistos, circulares, etc.
- */
 export const detectorDependencias = {
     nome: 'detector-dependencias',
     test(relPath) {

package/dist/analysts/detectors/detector-duplications.js

@@ -18,9 +18,7 @@ export const analistaDuplicacoes = {
             return [];
         }
         try {
-            // Extrair todas as funções do arquivo atual
             const funcoesAtuais = extrairFuncoes(ast, relPath, src);
-            // Extrair funções de outros arquivos para comparação
             let todasFuncoes = [];
             try {
                 todasFuncoes = extrairFuncoesDoContexto(contexto, relPath);
@@ -35,7 +33,6 @@ export const analistaDuplicacoes = {
                     })];
             }
             todasFuncoes.push(...funcoesAtuais);
-            // Detectar duplicações
             const duplicacoes = detectarDuplicacoes(funcoesAtuais, todasFuncoes);
             if (duplicacoes.length === 0) {
                 return [];
@@ -114,16 +111,12 @@ function extrairInfoFuncao(path, caminho, tipoFuncao, linhas) {
     const node = path.node;
     const inicio = node.loc?.start.line ?? 0;
     const fim = node.loc?.end.line ?? 0;
-    // Ignorar funções muito pequenas
     if (fim - inicio < 3) {
         return null;
     }
     const conteudo = linhas.slice(inicio - 1, fim).join('\n');
     const conteudoNormalizado = normalizarConteudo(conteudo);
-    // MD5 usado apenas para fingerprinting rápido de código (detecção de duplicação)
-    // Não é usado para segurança/criptografia - contexto: cache de análise estática
     const hash = createHash('md5').update(conteudoNormalizado).digest('hex');
-    // Extrair nome da função
     let nome = 'anonymous';
     if ('id' in node && node.id && 'name' in node.id) {
         nome = node.id.name;
@@ -135,14 +128,12 @@ function extrairInfoFuncao(path, caminho, tipoFuncao, linhas) {
         const parent = path.parentPath.node;
         nome = 'id' in parent && 'name' in parent.id ? parent.id.name : 'assigned';
     }
-    // Extrair parâmetros
     const parametros = ('params' in node && Array.isArray(node.params) ? node.params : []).map((param) => {
-        // Function parameter nodes
         if (param.type === 'Identifier' && 'name' in param) {
             return param.name;
-        } // Identifier node
+        }
         if (param.type === 'RestElement' && 'argument' in param && 'name' in param.argument) {
-            return `...${param.argument.name}`; // RestElement node
+            return `...${param.argument.name}`;
         }
         return param.type;
     });
@@ -160,11 +151,9 @@ function extrairInfoFuncao(path, caminho, tipoFuncao, linhas) {
 }
 function extrairFuncoesDoContexto(contexto, caminhoAtual) {
     const todasFuncoes = [];
-    // Limitar a análise a alguns arquivos para performance
-    const arquivosParaComparar = contexto.arquivos.filter(arq => arq.relPath !== caminhoAtual && arq.ast).slice(0, 20); // Limitar para evitar overhead
+    const arquivosParaComparar = contexto.arquivos.filter(arq => arq.relPath !== caminhoAtual && arq.ast).slice(0, 20);
     for (const arquivo of arquivosParaComparar) {
         if (arquivo.ast && arquivo.content) {
-            // Verificar se o AST é do tipo correto (NodePath<Node>)
             if ('parent' in arquivo.ast && 'node' in arquivo.ast) {
                 const funcoes = extrairFuncoes(arquivo.ast, arquivo.relPath, arquivo.content);
                 todasFuncoes.push(...funcoes);
@@ -177,7 +166,6 @@ function detectarDuplicacoes(funcoesAtuais, todasFuncoes) {
     const duplicacoes = [];
     for (const funcaoAtual of funcoesAtuais) {
         for (const outraFuncao of todasFuncoes) {
-            // Não comparar função consigo mesma
             if (funcaoAtual.caminho === outraFuncao.caminho && funcaoAtual.inicio === outraFuncao.inicio) {
                 continue;
             }
@@ -200,15 +188,12 @@ function detectarDuplicacoes(funcoesAtuais, todasFuncoes) {
     return duplicacoes;
 }
 function calcularSimilaridade(funcaoA, funcaoB) {
-    // Similaridade por hash (exata)
     if (funcaoA.hash === funcaoB.hash) {
         return 100;
     }
-    // Similaridade estrutural (tokens)
     const tokensA = tokenizar(funcaoA.conteudo ?? '');
     const tokensB = tokenizar(funcaoB.conteudo ?? '');
     const similaridadeJaccard = calcularJaccard(tokensA, tokensB);
-    // Bonus se parâmetros forem similares
     const similaridadeParametros = calcularSimilaridadeParametros(funcaoA.parametros ?? [], funcaoB.parametros ?? []);
     return (similaridadeJaccard * 0.8 + similaridadeParametros * 0.2) * 100;
 }
@@ -223,15 +208,12 @@ function determinarTipoSimilaridade(funcaoA, funcaoB, similaridade) {
 }
 function normalizarConteudo(conteudo) {
     return conteudo
-        // Remover comentários
         .replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '')
-        // Normalizar espaços
         .replace(/\s+/g, ' ')
-        // Remover espaços antes/depois de símbolos
         .replace(/\s*([{}();,])\s*/g, '$1').trim();
 }
 function tokenizar(texto) {
-    return texto.split(/[\s\(\)\{\}\[\];,\.]+/).filter(token => token.length > 0 && !/^[0-9]+$/.test(token)); // Remover números puros
+    return texto.split(/[\s\(\)\{\}\[\];,\.]+/).filter(token => token.length > 0 && !/^[0-9]+$/.test(token));
 }
 function calcularJaccard(tokensA, tokensB) {
     const conjuntoA = new Set(tokensA);

package/dist/analysts/detectors/detector-monorepo.js

@@ -1,5 +1,3 @@
-// @mahoraga-disable ml-deep-nesting
-// SPDX-License-Identifier: MIT
 import fs from 'node:fs';
 import path from 'node:path';
 export function detectarMonorepo(baseDir) {
@@ -14,14 +12,11 @@ export function detectarMonorepo(baseDir) {
     if (!rootPkg) {
         return info;
     }
-    // Detect package manager
     const pm = rootPkg.packageManager ?? '';
     if (pm) {
         info.packageManager = pm;
     }
-    // Detect workspace patterns
     let workspaceGlobs = [];
-    // pnpm-workspace.yaml
     const pnpmWorkspacePath = path.join(baseDir, 'pnpm-workspace.yaml');
     if (fs.existsSync(pnpmWorkspacePath)) {
         info.type = 'pnpm';
@@ -34,7 +29,6 @@ export function detectarMonorepo(baseDir) {
         }
         catch { }
     }
-    // lerna.json
     const lernaPath = path.join(baseDir, 'lerna.json');
     if (fs.existsSync(lernaPath)) {
         info.type = 'lerna';
@@ -46,7 +40,6 @@ export function detectarMonorepo(baseDir) {
         }
         catch { }
     }
-    // nx.json
     const nxPath = path.join(baseDir, 'nx.json');
     if (fs.existsSync(nxPath)) {
         info.type = 'nx';
@@ -62,12 +55,10 @@ export function detectarMonorepo(baseDir) {
         }
         catch { }
     }
-    // turbo.json
     const turboPath = path.join(baseDir, 'turbo.json');
     if (fs.existsSync(turboPath)) {
         info.type ??= 'turbo';
     }
-    // package.json workspaces
     if (rootPkg.workspaces) {
         if (!info.type) {
             const detectedPm = info.packageManager ?? '';
@@ -114,7 +105,6 @@ function resolverWorkspaces(rootDir, globs) {
     const workspaces = [];
     const seen = new Set();
     for (const glob of globs) {
-        // Expand simple globs like packages/* or apps/*
         const baseDir = glob.replace(/\/\*$/, '').replace(/\/\*\*$/, '');
         const fullPath = path.join(rootDir, baseDir);
         if (fs.existsSync(fullPath)) {
@@ -163,7 +153,6 @@ export const detectorMonorepo = {
             return [];
         }
         const ocorrencias = [];
-        // Report monorepo structure
         ocorrencias.push({
             tipo: 'monorepo-detectado',
             nivel: 'info',
@@ -172,7 +161,6 @@ export const detectorMonorepo = {
             relPath: '[monorepo]',
             linha: 0,
         });
-        // Check for missing root scripts
         const rootPkg = lerPackageJson(baseDir);
         if (rootPkg) {
             const scripts = rootPkg.scripts;
@@ -190,10 +178,8 @@ export const detectorMonorepo = {
                 }
             }
         }
-        // Per-workspace analysis
         for (const ws of info.workspaces) {
             const relDir = path.relative(baseDir, ws.dir);
-            // Check for missing package.json fields
             if (!ws.packageJson?.name) {
                 ocorrencias.push({
                     tipo: 'monorepo-workspace-sem-nome',
@@ -215,7 +201,6 @@ export const detectorMonorepo = {
                 });
             }
         }
-        // Cross-package dependency analysis
         const allDeps = new Map();
         for (const ws of info.workspaces) {
             const deps = new Set([
@@ -229,7 +214,6 @@ export const detectorMonorepo = {
                 allDeps.set(dep, depSet);
             }
         }
-        // Detect mismatched versions across workspaces
         const versionMap = new Map();
         for (const ws of info.workspaces) {
             for (const [dep, ver] of Object.entries(ws.dependencies)) {

package/dist/analysts/detectors/detector-performance.js

@@ -21,20 +21,15 @@ export const analistaDesempenho = {
         });
         const problemas = [];
         try {
-            // Detectar problemas por padrões de texto
             detectarPadroesPerformance(src, problemas, relPath);
-            // Detectar problemas via AST quando disponível
             if (ast) {
                 detectarProblemasPerformanceAST(ast, problemas, relPath);
             }
-            // Converter para ocorrências
             const ocorrencias = [];
-            // Agrupar por impacto
             const porImpacto = agruparPor(problemas, caminho => caminho.impacto ?? 'medio');
             for (const [impacto, items] of Object.entries(porImpacto)) {
                 if (items.length > 0) {
                     const nivel = mapearImpactoParaNivel(impacto);
-                    // Ser menos rigoroso com testes
                     const nivelAjustado = contextoArquivo.isTest && nivel === 'aviso' ? 'info' : nivel;
                     const resumo = items.slice(0, 3).map(caminho => caminho.tipo).join(', ');
                     ocorrencias.push(criarOcorrencia({
@@ -46,7 +41,6 @@ export const analistaDesempenho = {
                     }));
                 }
             }
-            // Aplicar supressões inline antes de retornar
             return filtrarOcorrenciasSuprimidas(ocorrencias, 'performance', src);
         }
         catch (erro) {
@@ -61,14 +55,12 @@ function detectarPadroesPerformance(src, problemas, relPath) {
     const loopClose = /^\s*\}/;
     linhas.forEach((linha, index) => {
         const numeroLinha = index + 1;
-        // Track loop nesting
         if (loopOpen.test(linha)) {
             dentroLoop++;
         }
         if (loopClose.test(linha) && dentroLoop > 0) {
             dentroLoop--;
         }
-        // Operações síncronas bloqueantes
         if (/\b(readFileSync|writeFileSync|execSync)\s*\(/.test(linha)) {
             problemas.push({
                 tipo: 'blocking-operation',
@@ -79,9 +71,7 @@ function detectarPadroesPerformance(src, problemas, relPath) {
                 sugestao: 'Use versões assíncronas: readFile, writeFile, exec'
             });
         }
-        // Event listeners sem cleanup
         if (/addEventListener\s*\(/.test(linha)) {
-            // Verificar se há removeEventListener no código (ignorando comentários)
             const srcSemComentarios = src.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
             if (!srcSemComentarios.includes('removeEventListener') && !srcSemComentarios.includes('cleanup') && !srcSemComentarios.includes('destroy')) {
                 problemas.push({
@@ -94,7 +84,6 @@ function detectarPadroesPerformance(src, problemas, relPath) {
                 });
             }
         }
-        // React: map sem key (detecção melhorada)
         if (/\.map\s*\([^)]*\)/.test(linha) && (/return\s*<|<\w+/.test(linha) || relPath.includes('.tsx') || relPath.includes('.jsx')) && !linha.includes('key=')) {
             problemas.push({
                 tipo: 'unnecessary-rerender',
@@ -105,7 +94,6 @@ function detectarPadroesPerformance(src, problemas, relPath) {
                 sugestao: 'Adicione key prop única para cada elemento da lista'
             });
         }
-        // N+1 queries pattern
         if (/\.forEach\s*\(.*\.(find|get|query|select)\s*\(/.test(linha)) {
             problemas.push({
                 tipo: 'n-plus-one',
@@ -116,7 +104,6 @@ function detectarPadroesPerformance(src, problemas, relPath) {
                 sugestao: 'Use join/include ou agrupe consultas para evitar N+1'
             });
         }
-        // Await em loops
         if (/\bawait\b/.test(linha) && dentroLoop > 0) {
             problemas.push({
                 tipo: 'sequential-await',
@@ -127,7 +114,6 @@ function detectarPadroesPerformance(src, problemas, relPath) {
                 sugestao: 'Considere usar Promise.all() para executar em paralelo'
             });
         }
-        // Large object spread in loops
         if (/\.\.\./.test(linha) && dentroLoop > 0 && /\{.*\.{3}.*\}/.test(linha)) {
             problemas.push({
                 tipo: 'expensive-spread',
@@ -138,10 +124,8 @@ function detectarPadroesPerformance(src, problemas, relPath) {
                 sugestao: 'Considere mutar um objeto local ou usar Map se o objeto for grande'
             });
         }
-        // React: missing memo/useCallback for expensive objects
         if (relPath.endsWith('.tsx') || relPath.endsWith('.jsx')) {
             if (/const\s+\w+\s*=\s*\[.*\]|const\s+\w+\s*=\s*\{.*\}|const\s+\w+\s*=\s*\(.*\)\s*=>/.test(linha) && !/useMemo|useCallback/.test(linha) && !/^\s*\/\//.test(linha)) {
-                // Heurística: se for dentro de um componente React (função que retorna JSX)
                 const totalLinhas = linhas.length;
                 const contextoPosterior = linhas.slice(index, Math.min(index + 20, totalLinhas)).join('\n');
                 if (/<[A-Z]|return\s*\(?\s*</.test(contextoPosterior)) {
@@ -156,7 +140,6 @@ function detectarPadroesPerformance(src, problemas, relPath) {
                 }
             }
         }
-        // Imports de bibliotecas grandes
         if (/import.*from\s+['"]lodash['"]|import.*from\s+['"]moment['"]/.test(linha)) {
             problemas.push({
                 tipo: 'large-bundle',
@@ -222,7 +205,6 @@ function detectarProblemasPerformanceAST(ast, problemas, relPath) {
         });
     }
     catch {
-        // Ignorar erros de traverse
     }
 }
 function mapearImpactoParaNivel(impacto) {

package/dist/analysts/detectors/detector-phantoms.js

@@ -1,4 +1,3 @@
-// SPDX-License-Identifier: MIT
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { config, isInsideSrc, LIMITES_PADRAO } from '../../core/config/index.js';
@@ -6,30 +5,20 @@ import { scanRepository } from '../../core/execution/index.js';
 import { isTestArquivo, normalizePath } from '../../shared/helpers/index.js';
 import { grafoDependencias } from './detector-dependencies.js';
 const EXTENSOES_ALVO = ['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs'];
-// Janela de inatividade mínima para considerar fantasma (default mais conservador)
 const INATIVIDADE_DIAS = Number(process.env.GHOST_DAYS) || LIMITES_PADRAO.GUARDIAN.DIAS_INATIVIDADE_GHOST;
 const MILIS_POR_DIA = 86_400_000;
-// Padrões de entrypoints comuns que NÃO devem ser considerados órfãos
 const ENTRYPOINT_PADROES = [/^(src\/)?index\.(ts|js|tsx|jsx|mjs|cjs)$/i, /^(src\/)?main\.(ts|js|tsx|jsx|mjs|cjs)$/i, /^(src\/)?server\.(ts|js|tsx|jsx|mjs|cjs)$/i, /^(src\/)?app\.(ts|js|tsx|jsx|mjs|cjs)$/i, /^(src\/)?cli\.(ts|js|tsx|jsx|mjs|cjs)$/i, /(^|\/)bin\/[^/]+\.(ts|js|mjs|cjs)$/i, /\/index\.(ts|js|tsx|jsx|mjs|cjs)$/i, /config\.(ts|js|cjs|mjs)$/i, /\.config\.(ts|js|cjs|mjs)$/i, /\.d\.ts$/i];
-/**
- * Verifica se é um entrypoint conhecido (bin, cli, main, index, etc.)
- */
 function isEntrypoint(relPath) {
     const normalized = normalizePath(relPath);
     return ENTRYPOINT_PADROES.some(caminho => caminho.test(normalized));
 }
-/**
- * Verifica se o arquivo está sendo referenciado por outro arquivo no grafo
- */
 function estaSendoReferenciado(relPath, grafo) {
     const normalized = normalizePath(relPath);
-    // Variações que podem existir no grafo (com/sem extensão, etc.)
     const variations = new Set([normalized]);
     const ext = path.posix.extname(normalized);
     if (ext) {
         variations.add(normalized.slice(0, -ext.length));
     }
-    // Adiciona variações com extensões comuns
     const base = ext ? normalized.slice(0, -ext.length) : normalized;
     for (const erro of ['.ts', '.js', '.tsx', '.jsx', '.mjs', '.cjs']) {
         variations.add(base + erro);
@@ -44,9 +33,6 @@ function estaSendoReferenciado(relPath, grafo) {
     }
     return false;
 }
-/**
- * Verifica se o arquivo importa outros (é um consumidor, não apenas consumido)
- */
 function importaOutros(relPath, grafo) {
     const normalized = normalizePath(relPath);
     for (const [chave, deps] of grafo.entries()) {
@@ -60,43 +46,35 @@ export async function detectarFantasmas(baseDir = process.cwd()) {
     const fileMap = await scanRepository(baseDir);
     const agora = Date.now();
     const fantasmas = [];
-    // Verifica se a config permite excluir testes da checagem de órfãos
     const testConfiguracao = config.testPadroes;
-    const excludeTestsFromOrphan = testConfiguracao?.excludeFromOrphanCheck !== false; // default true
+    const excludeTestsFromOrphan = testConfiguracao?.excludeFromOrphanCheck !== false;
     for (const entrada of Object.values(fileMap)) {
         const { relPath, fullCaminho } = entrada;
         const ext = path.extname(relPath).toLowerCase();
         if (!EXTENSOES_ALVO.includes(ext)) {
             continue;
         }
-        // 1. Ignora arquivos de teste (usando config centralizada)
         if (excludeTestsFromOrphan && isTestArquivo(relPath)) {
             continue;
         }
-        // 2. Ignora entrypoints conhecidos
         if (isEntrypoint(relPath)) {
             continue;
         }
         try {
             const stat = await fs.stat(fullCaminho);
             const diasInativo = Math.floor((agora - stat.mtimeMs) / MILIS_POR_DIA);
-            // Se o grafo ainda não foi populado (execução isolada da poda), não arrisca classificar
             if (grafoDependencias.size === 0) {
                 continue;
             }
             const referenciado = estaSendoReferenciado(relPath, grafoDependencias);
-            // 3. Arquivo que importa outros não é órfão (é um consumidor/entrypoint)
             if (importaOutros(relPath, grafoDependencias)) {
                 continue;
             }
-            // 4. Proteção extra para arquivos dentro de src/
             if (isInsideSrc(relPath)) {
-                // Arquivos recentes (menos de 7 dias) não são marcados como órfãos
                 if (diasInativo < 7) {
                     continue;
                 }
             }
-            // 5. Heurística final: somente é fantasma se (não referenciado) E (inativo acima do limiar)
             if (!referenciado && diasInativo > INATIVIDADE_DIAS) {
                 fantasmas.push({
                     arquivo: relPath,
@@ -106,7 +84,6 @@ export async function detectarFantasmas(baseDir = process.cwd()) {
             }
         }
         catch {
-            // Silenciosamente ignora arquivos inacessíveis
         }
     }
     return {