@mocoto/mahoraga 0.14.0 → 0.14.2

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

@@ -1,43 +1,72 @@
+// 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')
+    if (node.importKind === 'type') {
         return true;
-    const specifiers = node.specifiers || [];
-    if (specifiers.length === 0)
+    }
+    const specifiers = node.specifiers;
+    if (specifiers.length === 0) {
         return false;
+    }
     return specifiers.every(s => {
-        if (s.type === 'ImportSpecifier')
+        if (s.type === 'ImportSpecifier') {
             return s.importKind === 'type';
+        }
         return false;
     });
 }
 function verificarCicloConfirmado(ciclo, grafo, arquivosExistentes) {
-    if (ciclo.length < 2)
+    if (ciclo.length < 2) {
         return false;
-    if (!arquivosExistentes)
+    }
+    if (!arquivosExistentes) {
         return true;
+    }
     for (const node of ciclo) {
         const normalized = normalizarPosix(node);
-        if (!arquivosExistentes.has(normalized))
+        if (!arquivosExistentes.has(normalized)) {
             return false;
+        }
     }
     for (let indice = 0; indice < ciclo.length - 1; indice++) {
         const origem = normalizarPosix(ciclo[indice]);
         const destino = normalizarPosix(ciclo[indice + 1]);
         const deps = grafo.get(origem);
-        if (!deps)
+        if (!deps) {
             return false;
+        }
         const depsNorm = new Set(Array.from(deps).map(diretorio => normalizarPosix(diretorio)));
-        if (!depsNorm.has(destino))
+        if (!depsNorm.has(destino)) {
             return false;
+        }
     }
     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();
@@ -53,10 +82,12 @@ function detectarCicloComplexo(inicio, grafo, maxProfundidade = 5) {
     }
     function buscarDependencias(arquivo) {
         const normalizado = normalizePath(arquivo, true);
-        if (grafo.has(arquivo))
+        if (grafo.has(arquivo)) {
             return grafo.get(arquivo);
-        if (grafo.has(normalizado))
+        }
+        if (grafo.has(normalizado)) {
             return grafo.get(normalizado);
+        }
         for (const [chave, deps] of grafo.entries()) {
             if (normalizePath(chave, true) === normalizado) {
                 return deps;
@@ -65,8 +96,9 @@ function detectarCicloComplexo(inicio, grafo, maxProfundidade = 5) {
         return undefined;
     }
     function dfs(atual, profundidade) {
-        if (profundidade > maxProfundidade)
+        if (profundidade > maxProfundidade) {
             return false;
+        }
         const atualNormalizado = normalizePath(atual, true);
         if (pilha.has(atualNormalizado)) {
             const indiceCiclo = caminho.findIndex(caminho => normalizePath(caminho, true) === atualNormalizado);
@@ -76,16 +108,18 @@ function detectarCicloComplexo(inicio, grafo, maxProfundidade = 5) {
             }
             return false;
         }
-        if (visitados.has(atualNormalizado))
+        if (visitados.has(atualNormalizado)) {
             return false;
+        }
         visitados.add(atualNormalizado);
         pilha.add(atualNormalizado);
         caminho.push(atualNormalizado);
         const dependencias = buscarDependencias(atual);
         if (dependencias) {
             for (const dep of dependencias) {
-                if (!dep.startsWith('.') && !dep.startsWith('/') && !dep.startsWith('src'))
+                if (!dep.startsWith('.') && !dep.startsWith('/') && !dep.startsWith('src')) {
                     continue;
+                }
                 const depResolvida = resolverCaminho(atualNormalizado, dep);
                 if (dfs(depResolvida, profundidade + 1)) {
                     return true;
@@ -112,6 +146,18 @@ 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}`,
@@ -134,16 +180,17 @@ function getVerifyCycles() {
 }
 function processarImportDeclaration(caminho, state) {
     const somenteTipo = ehImportSomenteTipo(caminho.node);
-    if (!somenteTipo)
+    if (!somenteTipo) {
         state.tiposImport.add('import');
+    }
     const val = caminho.node.source.value;
     if (somenteTipo) {
-        const specifiers = caminho.node.specifiers || [];
+        const specifiers = caminho.node.specifiers;
         for (const s of specifiers) {
             if (s.type === 'ImportDefaultSpecifier' || s.type === 'ImportSpecifier') {
                 state.importsDeclarados.add(s.local.name);
             }
-            else if (s.type === 'ImportNamespaceSpecifier') {
+            else {
                 state.importsDeclarados.add(s.local.name);
             }
         }
@@ -193,20 +240,21 @@ function processarImportDeclaration(caminho, state) {
             });
         }
     }
-    const specifiers = caminho.node.specifiers || [];
+    const specifiers = caminho.node.specifiers;
     for (const s of specifiers) {
         if (s.type === 'ImportDefaultSpecifier' || s.type === 'ImportSpecifier') {
             state.importsDeclarados.add(s.local.name);
         }
-        else if (s.type === 'ImportNamespaceSpecifier') {
+        else {
             state.importsDeclarados.add(s.local.name);
         }
     }
 }
 function processarCallExpression(caminho, state) {
     const { callee, arguments: args } = caminho.node;
-    if (callee.type !== 'Identifier' || callee.name !== 'require' || args[0]?.type !== 'StringLiteral')
+    if (callee.type !== 'Identifier' || callee.name !== 'require' || args[0]?.type !== 'StringLiteral') {
         return;
+    }
     state.tiposImport.add('require');
     const val = args[0].value;
     const resolved = resolverModulo(val, state.relPath, state.arquivosExistentes);
@@ -255,12 +303,14 @@ function processarCallExpression(caminho, state) {
     }
 }
 function processarImportsUsadosDinamicamente(src, state) {
-    if (state.importsDeclarados.size === 0)
+    if (state.importsDeclarados.size === 0) {
         return;
+    }
     let usadosDinamicos = importsUsadosDinamicamente.get(state.relPath);
     for (const nome of Array.from(state.importsDeclarados)) {
-        if (!isUsadoEmRegistroDinamico(src, nome))
+        if (!isUsadoEmRegistroDinamico(src, nome)) {
             continue;
+        }
         if (!usadosDinamicos) {
             usadosDinamicos = new Set();
             importsUsadosDinamicamente.set(state.relPath, usadosDinamicos);
@@ -276,8 +326,9 @@ function processarImportsUsadosDinamicamente(src, state) {
     }
 }
 function processarMisturaRequireImport(state) {
-    if (state.tiposImport.size <= 1)
+    if (state.tiposImport.size <= 1) {
         return;
+    }
     state.ocorrencias.push({
         tipo: 'aviso',
         mensagem: messages.DetectorDependenciasMensagens.usoMistoRequireImport,
@@ -293,8 +344,9 @@ function processarCicloDependencia(state, grafoDependencias) {
         });
     }
     const ciclo = detectarCicloComplexo(state.relPath, grafoDependencias, getMaxProfundidade());
-    if (ciclo.length <= 1)
+    if (ciclo.length <= 1) {
         return;
+    }
     if (getVerifyCycles() && !verificarCicloConfirmado(ciclo, grafoDependencias, state.arquivosExistentes)) {
         return;
     }
@@ -310,14 +362,19 @@ 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) {
         return relPath.endsWith('.ts') || relPath.endsWith('.js');
     },
     aplicar(src, relPath, ast, _fullPath, contexto) {
-        if (!ast)
+        if (!ast) {
             return [];
+        }
         const state = {
             ocorrencias: [],
             tiposImport: new Set(),
@@ -340,4 +397,3 @@ export const detectorDependencias = {
         return state.ocorrencias;
     }
 };
-//# sourceMappingURL=detector-dependencies.js.map

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

@@ -1,6 +1,6 @@
+import { createHash } from 'crypto';
 import { traverse } from '../../core/config/index.js';
 import { messages } from '../../core/messages/index.js';
-import { createHash } from 'crypto';
 import { criarOcorrencia } from '../../types/index.js';
 export const analistaDuplicacoes = {
     nome: 'detector-duplicacoes',
@@ -13,15 +13,17 @@ export const analistaDuplicacoes = {
     test: (relPath) => {
         return /\.(js|jsx|ts|tsx|mjs|cjs)$/.test(relPath);
     },
-    aplicar: async (src, relPath, ast, fullCaminho, contexto) => {
+    aplicar: (src, relPath, ast, fullCaminho, contexto) => {
         if (!ast || !src || !contexto) {
             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 = await extrairFuncoesDoContexto(contexto, relPath);
+                todasFuncoes = extrairFuncoesDoContexto(contexto, relPath);
             }
             catch (erro) {
                 return [criarOcorrencia({
@@ -33,23 +35,25 @@ export const analistaDuplicacoes = {
                     })];
             }
             todasFuncoes.push(...funcoesAtuais);
+            // Detectar duplicações
             const duplicacoes = detectarDuplicacoes(funcoesAtuais, todasFuncoes);
             if (duplicacoes.length === 0) {
                 return [];
             }
+            // Agrupar por tipo de similaridade
             const porTipo = agruparPorTipoSimilaridade(duplicacoes);
             const ocorrencias = [];
             for (const [tipo, dups] of Object.entries(porTipo)) {
                 if (dups.length > 0) {
                     const nivel = tipo === 'identica' ? 'aviso' : 'info';
                     const primeiraFunc = dups[0]?.funcaoA;
-                    const resumo = dups.map(diretorio => `${diretorio.funcaoA?.nome || 'unknown'} ≈ ${diretorio.funcaoB?.nome || 'unknown'} (${diretorio.similaridade.toFixed(0)}%)`).slice(0, 3).join(', ');
+                    const resumo = dups.map(diretorio => `${diretorio.funcaoA?.nome ?? 'unknown'} ≈ ${diretorio.funcaoB?.nome ?? 'unknown'} (${diretorio.similaridade.toFixed(0)}%)`).slice(0, 3).join(', ');
                     ocorrencias.push(criarOcorrencia({
                         tipo: 'codigo_duplicado',
                         nivel,
                         mensagem: messages.DetectorAgregadosMensagens.duplicacoesResumo(tipo, resumo, dups.length),
                         relPath,
-                        linha: primeiraFunc?.inicio || 1
+                        linha: primeiraFunc?.inicio ?? 1
                     }));
                 }
             }
@@ -72,58 +76,70 @@ function extrairFuncoes(ast, caminho, src) {
     traverse(ast.node, {
         FunctionDeclaration(path) {
             const func = extrairInfoFuncao(path, caminho, 'declaration', linhas);
-            if (func)
+            if (func) {
                 funcoes.push(func);
+            }
         },
         FunctionExpression(path) {
             const func = extrairInfoFuncao(path, caminho, 'expression', linhas);
-            if (func)
+            if (func) {
                 funcoes.push(func);
+            }
         },
         ArrowFunctionExpression(path) {
             const func = extrairInfoFuncao(path, caminho, 'arrow', linhas);
-            if (func)
+            if (func) {
                 funcoes.push(func);
+            }
         },
         ObjectMethod(path) {
             const func = extrairInfoFuncao(path, caminho, 'method', linhas);
-            if (func)
+            if (func) {
                 funcoes.push(func);
+            }
         },
         ClassMethod(path) {
             const func = extrairInfoFuncao(path, caminho, 'method', linhas);
-            if (func)
+            if (func) {
                 funcoes.push(func);
+            }
         }
     });
     return funcoes;
 }
 function extrairInfoFuncao(path, caminho, tipoFuncao, linhas) {
     const node = path.node;
-    const inicio = node.loc?.start.line || 0;
-    const fim = node.loc?.end.line || 0;
+    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;
     }
-    else if ('key' in node && node.key && 'name' in node.key) {
+    else if ('key' in node && 'name' in node.key) {
         nome = node.key.name;
     }
-    else if (path.parentPath?.isVariableDeclarator()) {
+    else if (path.parentPath.isVariableDeclarator()) {
         const parent = path.parentPath.node;
-        nome = 'id' in parent && parent.id && 'name' in parent.id ? parent.id.name : 'assigned';
+        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) => {
-        if (param.type === 'Identifier' && 'name' in param)
+        // Function parameter nodes
+        if (param.type === 'Identifier' && 'name' in param) {
             return param.name;
-        if (param.type === 'RestElement' && 'argument' in param && param.argument && 'name' in param.argument) {
-            return `...${param.argument.name}`;
+        } // Identifier node
+        if (param.type === 'RestElement' && 'argument' in param && 'name' in param.argument) {
+            return `...${param.argument.name}`; // RestElement node
         }
         return param.type;
     });
@@ -139,11 +155,13 @@ function extrairInfoFuncao(path, caminho, tipoFuncao, linhas) {
         codigo: conteudoNormalizado
     };
 }
-async function extrairFuncoesDoContexto(contexto, caminhoAtual) {
+function extrairFuncoesDoContexto(contexto, caminhoAtual) {
     const todasFuncoes = [];
-    const arquivosParaComparar = contexto.arquivos.filter(arq => arq.relPath !== caminhoAtual && arq.ast).slice(0, 20);
+    // 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
     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);
@@ -156,6 +174,7 @@ 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;
             }
@@ -167,8 +186,8 @@ function detectarDuplicacoes(funcoesAtuais, todasFuncoes) {
                     funcaoB: outraFuncao,
                     similaridade,
                     tipoSimilaridade,
-                    arquivo1: funcaoAtual.caminho || '',
-                    arquivo2: outraFuncao.caminho || '',
+                    arquivo1: funcaoAtual.caminho ?? '',
+                    arquivo2: outraFuncao.caminho ?? '',
                     bloco1: funcaoAtual,
                     bloco2: outraFuncao
                 });
@@ -178,30 +197,38 @@ function detectarDuplicacoes(funcoesAtuais, todasFuncoes) {
     return duplicacoes;
 }
 function calcularSimilaridade(funcaoA, funcaoB) {
+    // Similaridade por hash (exata)
     if (funcaoA.hash === funcaoB.hash) {
         return 100;
     }
-    const tokensA = tokenizar(funcaoA.conteudo || '');
-    const tokensB = tokenizar(funcaoB.conteudo || '');
+    // Similaridade estrutural (tokens)
+    const tokensA = tokenizar(funcaoA.conteudo ?? '');
+    const tokensB = tokenizar(funcaoB.conteudo ?? '');
     const similaridadeJaccard = calcularJaccard(tokensA, tokensB);
-    const similaridadeParametros = calcularSimilaridadeParametros(funcaoA.parametros || [], funcaoB.parametros || []);
+    // Bonus se parâmetros forem similares
+    const similaridadeParametros = calcularSimilaridadeParametros(funcaoA.parametros ?? [], funcaoB.parametros ?? []);
     return (similaridadeJaccard * 0.8 + similaridadeParametros * 0.2) * 100;
 }
 function determinarTipoSimilaridade(funcaoA, funcaoB, similaridade) {
-    if (similaridade >= 95)
+    if (similaridade >= 95) {
         return 'identica';
-    if (similaridade >= 85)
+    }
+    if (similaridade >= 85) {
         return 'estrutural';
+    }
     return 'semantica';
 }
 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));
+    return texto.split(/[\s\(\)\{\}\[\];,\.]+/).filter(token => token.length > 0 && !/^[0-9]+$/.test(token)); // Remover números puros
 }
 function calcularJaccard(tokensA, tokensB) {
     const conjuntoA = new Set(tokensA);
@@ -211,10 +238,12 @@ function calcularJaccard(tokensA, tokensB) {
     return uniao.size === 0 ? 0 : intersecao.size / uniao.size;
 }
 function calcularSimilaridadeParametros(paramsA, paramsB) {
-    if (paramsA.length === 0 && paramsB.length === 0)
+    if (paramsA.length === 0 && paramsB.length === 0) {
         return 1;
-    if (paramsA.length === 0 || paramsB.length === 0)
+    }
+    if (paramsA.length === 0 || paramsB.length === 0) {
         return 0;
+    }
     const maxLength = Math.max(paramsA.length, paramsB.length);
     let matches = 0;
     for (let indice = 0; indice < maxLength; indice++) {
@@ -228,12 +257,8 @@ function agruparPorTipoSimilaridade(duplicacoes) {
     return duplicacoes.reduce((acc, dup) => {
         const tipo = dup.tipoSimilaridade;
         if (tipo) {
-            if (!acc[tipo]) {
-                acc[tipo] = [];
-            }
-            acc[tipo].push(dup);
+            (acc[tipo] ??= []).push(dup);
         }
         return acc;
     }, {});
 }
-//# sourceMappingURL=detector-duplications.js.map