@mocoto/mahoraga 0.14.0 → 0.14.1

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

@@ -2,6 +2,7 @@ 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,
@@ -16,14 +17,14 @@ const LIMITES = {
 const visitorFragil = {
     CatchClause(path, state) {
         const visitorState = state;
-        const fragilidades = visitorState.resultados.get('codigo-fragil') || [];
+        const fragilidades = visitorState.resultados.get('codigo-fragil') ?? [];
         const body = path.node.body.body;
-        const linha = path.node.loc?.start.line || 0;
+        const linha = path.node.loc?.start.line ?? 0;
         if (body.length === 0) {
             fragilidades.push({
                 tipo: 'catch-vazio',
                 linha,
-                coluna: path.node.loc?.start.column || 0,
+                coluna: path.node.loc?.start.column ?? 0,
                 severidade: 'media',
                 contexto: 'Bloco catch vazio'
             });
@@ -32,7 +33,7 @@ const visitorFragil = {
             fragilidades.push({
                 tipo: 'catch-apenas-log',
                 linha,
-                coluna: path.node.loc?.start.column || 0,
+                coluna: path.node.loc?.start.column ?? 0,
                 severidade: 'baixa',
                 contexto: 'Catch apenas com console.log'
             });
@@ -41,19 +42,20 @@ const visitorFragil = {
     },
     IfStatement(path, state) {
         const visitorState = state;
-        const fragilidades = visitorState.resultados.get('codigo-fragil') || [];
+        const fragilidades = visitorState.resultados.get('codigo-fragil') ?? [];
         let depth = 0;
         let current = path;
         while (current) {
-            if (current.isIfStatement())
+            if (current.isIfStatement()) {
                 depth++;
+            }
             current = current.parentPath;
         }
         if (depth > LIMITES.MAX_ANINHAMENTO_IF) {
             fragilidades.push({
                 tipo: 'if-muito-aninhado',
-                linha: path.node.loc?.start.line || 0,
-                coluna: path.node.loc?.start.column || 0,
+                linha: path.node.loc?.start.line ?? 0,
+                coluna: path.node.loc?.start.column ?? 0,
                 severidade: depth > LIMITES.MAX_ANINHAMENTO_IF + 1 ? 'alta' : 'media',
                 contexto: `Condicionais aninhadas demais (nível ${depth}, máx: ${LIMITES.MAX_ANINHAMENTO_IF})`
             });
@@ -62,18 +64,18 @@ const visitorFragil = {
     },
     FunctionDeclaration(path, state) {
         const visitorState = state;
-        const fragilidades = visitorState.resultados.get('codigo-fragil') || [];
-        const maxLinhas = config.ANALISE_LIMITES?.CODIGO_FRAGIL?.MAX_LINHAS_FUNCAO ?? LIMITES.LINHAS_FUNCAO;
+        const fragilidades = visitorState.resultados.get('codigo-fragil') ?? [];
+        const maxLinhas = config.ANALISE_LIMITES.CODIGO_FRAGIL.MAX_LINHAS_FUNCAO ?? LIMITES.LINHAS_FUNCAO;
         const node = path.node;
-        if (node.body?.type === 'BlockStatement') {
-            const inicio = node.loc?.start.line || 0;
-            const fim = node.loc?.end.line || 0;
+        if (node.body.type === 'BlockStatement') {
+            const inicio = node.loc?.start.line ?? 0;
+            const fim = node.loc?.end.line ?? 0;
             const numLinhas = fim - inicio;
             if (numLinhas > maxLinhas) {
                 fragilidades.push({
                     tipo: 'funcao-longa',
                     linha: inicio,
-                    coluna: node.loc?.start.column || 0,
+                    coluna: node.loc?.start.column ?? 0,
                     severidade: numLinhas > maxLinhas * 2 ? 'alta' : 'media',
                     contexto: `Função com ${numLinhas} linhas (máx: ${maxLinhas})`
                 });
@@ -83,19 +85,19 @@ const visitorFragil = {
     },
     NumericLiteral(path, state) {
         const visitorState = state;
-        const fragilidades = visitorState.resultados.get('codigo-fragil') || [];
+        const fragilidades = visitorState.resultados.get('codigo-fragil') ?? [];
         const value = path.node.value;
-        if (isInVariableDeclarator(path) || isInArrayIndex(path))
+        if (isInVariableDeclarator(path) || isInArrayIndex(path)) {
             return;
-        if (!frameworksDetectados) {
-            frameworksDetectados = detectarFrameworks(process.cwd()).map(arquivo => arquivo.name);
         }
-        if (isWhitelistedConstant(value, frameworksDetectados))
+        frameworksDetectados ??= detectarFrameworks(process.cwd()).map(arquivo => arquivo.name);
+        if (isWhitelistedConstant(value, frameworksDetectados)) {
             return;
+        }
         fragilidades.push({
             tipo: 'magic-number',
-            linha: path.node.loc?.start.line || 0,
-            coluna: path.node.loc?.start.column || 0,
+            linha: path.node.loc?.start.line ?? 0,
+            coluna: path.node.loc?.start.column ?? 0,
             severidade: 'baixa',
             contexto: `Número mágico '${value}' detectado`
         });
@@ -107,20 +109,24 @@ export const analistaCodigoFragil = {
     categoria: 'qualidade',
     descricao: 'Detecta padrões de código que podem levar a problemas futuros',
     limites: {
-        maxLinhasFuncao: config.ANALISE_LIMITES?.CODIGO_FRAGIL?.MAX_LINHAS_FUNCAO ?? LIMITES.LINHAS_FUNCAO,
-        maxParametros: config.ANALISE_LIMITES?.CODIGO_FRAGIL?.MAX_PARAMETROS ?? LIMITES.PARAMETROS_FUNCAO,
-        maxNestedCallbacks: config.ANALISE_LIMITES?.CODIGO_FRAGIL?.MAX_NESTED_CALLBACKS ?? LIMITES.CALLBACKS_ANINHADOS
+        maxLinhasFuncao: config.ANALISE_LIMITES.CODIGO_FRAGIL.MAX_LINHAS_FUNCAO ?? LIMITES.LINHAS_FUNCAO,
+        maxParametros: config.ANALISE_LIMITES.CODIGO_FRAGIL.MAX_PARAMETROS ?? LIMITES.PARAMETROS_FUNCAO,
+        maxNestedCallbacks: config.ANALISE_LIMITES.CODIGO_FRAGIL.MAX_NESTED_CALLBACKS ?? LIMITES.CALLBACKS_ANINHADOS
     },
     visitor: visitorFragil,
     test: (relPath) => {
-        if (/\.(deprecados?|abandonados?)\//i.test(relPath))
+        if (/\.(deprecados?|abandonados?)\//i.test(relPath)) {
             return false;
+        }
         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)
+        if (!ast || !src) {
             return [];
+        }
         const fragilidades = [];
+        // Detecções baseadas em texto
         detectarLogsDebug(src).forEach(log => {
             fragilidades.push({
                 tipo: 'console-log',
@@ -149,20 +155,23 @@ export const analistaCodigoFragil = {
                 contexto: `Arquivo com ${lines.length} linhas (máx sugerido: ${LIMITES.MAX_LINHAS_ARQUIVO})`
             });
         }
+        // Processamento AST: Otimizado (preColetado) ou Fallback
         if (ast.preColetado) {
             fragilidades.push(...ast.preColetado);
         }
         else {
-            const nodeToTraverse = ast.node || ast;
+            const nodeToTraverse = ast.node ?? ast;
             const stateMock = {
                 resultados: new Map([['codigo-fragil', []]])
             };
             traverse(nodeToTraverse, visitorFragil, undefined, stateMock);
-            fragilidades.push(...(stateMock.resultados.get('codigo-fragil') || []));
+            fragilidades.push(...(stateMock.resultados.get('codigo-fragil') ?? []));
         }
+        // Detecções de texto complementares (Heurísticas)
         detectarProblemasAvancados(src, fragilidades);
+        // Converter para ocorrências Mahoraga
         const ocorrencias = [];
-        const porSeveridade = agruparPor(fragilidades, arquivo => arquivo.severidade || 'media');
+        const porSeveridade = agruparPor(fragilidades, arquivo => arquivo.severidade ?? 'media');
         for (const [severidade, items] of Object.entries(porSeveridade)) {
             if (items.length > 0) {
                 const nivel = severidade === 'critica' || severidade === 'alta' ? 'erro' : severidade === 'media' ? 'aviso' : 'info';
@@ -189,10 +198,14 @@ export const analistaCodigoFragil = {
         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',
@@ -202,8 +215,9 @@ 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) {
+        if (regexMatch && regexMatch[0].length > LIMITES.REGEX_COMPLEXA_LENGTH && (regexMatch[0].match(/\(/g) ?? []).length > 3) {
             fragilidades.push({
                 tipo: 'regex-complexa',
                 linha: indice + 1,
@@ -213,6 +227,7 @@ function detectarProblemasAvancados(src, fragilidades) {
             });
         }
     }
+    // Complexidade Cognitiva
     detectarComplexidadeCognitiva(src, fragilidades);
 }
 function detectarComplexidadeCognitiva(src, fragilidades) {
@@ -221,12 +236,15 @@ function detectarComplexidadeCognitiva(src, fragilidades) {
     let nesting = 0;
     for (let indice = 0; indice < lines.length; indice++) {
         const line = lines[indice].trim();
-        if (/(if|while|for|switch|catch)/.test(line))
+        if (/(if|while|for|switch|catch)/.test(line)) {
             score += 1 + nesting;
-        if (line.includes('{'))
+        }
+        if (line.includes('{')) {
             nesting++;
-        if (line.includes('}'))
+        }
+        if (line.includes('}')) {
             nesting--;
+        }
         if (score > LIMITES.COMPLEXIDADE_COGNITIVA) {
             fragilidades.push({
                 tipo: 'complexidade-cognitiva',
@@ -235,12 +253,12 @@ function detectarComplexidadeCognitiva(src, fragilidades) {
                 severidade: 'alta',
                 contexto: `Complexidade cognitiva elevada (${score})`
             });
-            score = 0;
+            score = 0; // Reset para a próxima seção
         }
     }
 }
 function isSingleConsoleLog(stmt) {
-    return stmt.type === 'ExpressionStatement' && stmt.expression?.type === 'CallExpression' && stmt.expression.callee?.type === 'MemberExpression' && stmt.expression.callee.object.name === 'console';
+    return stmt.type === 'ExpressionStatement' && stmt.expression.type === 'CallExpression' && stmt.expression.callee.type === 'MemberExpression' && stmt.expression.callee.object.name === 'console';
 }
 function isInVariableDeclarator(path) {
     return !!path.findParent(caminho => caminho.isVariableDeclarator());
@@ -248,4 +266,3 @@ function isInVariableDeclarator(path) {
 function isInArrayIndex(path) {
     return !!path.findParent(caminho => caminho.isMemberExpression() && !!caminho.node.computed);
 }
-//# sourceMappingURL=detector-code-fragile.js.map

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)
+    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,8 +180,9 @@ 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 || [];
@@ -205,8 +252,9 @@ function processarImportDeclaration(caminho, state) {
 }
 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