@mocoto/mahoraga 0.14.2 → 0.14.3

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

@@ -104,6 +104,35 @@ const visitorFragil = {
         visitorState.resultados.set('codigo-fragil', fragilidades);
     }
 };
+function converterFragilidadesParaOcorrencias(fragilidades, relPath) {
+    const ocorrencias = [];
+    const porSeveridade = agruparPor(fragilidades, arquivo => arquivo.severidade ?? 'media');
+    for (const [severidade, items] of Object.entries(porSeveridade)) {
+        if (items.length === 0) {
+            continue;
+        }
+        const nivel = severidade === 'critica' || severidade === 'alta' ? 'erro' : severidade === 'media' ? 'aviso' : 'info';
+        const tipos = {};
+        for (const it of items) {
+            tipos[it.tipo] = (tipos[it.tipo] || 0) + 1;
+        }
+        const resumo = items.slice(0, 3).map(caminho => caminho.tipo).join(', ');
+        const amostra = items.slice(0, 5).map(it => `${it.tipo} (L${it.linha})`);
+        ocorrencias.push(criarOcorrencia({
+            tipo: 'codigo-fragil',
+            nivel,
+            mensagem: messages.DetectorCodigoFragilMensagens.fragilidadesResumo(severidade, resumo, {
+                severidade,
+                total: items.length,
+                tipos,
+                amostra
+            }),
+            relPath,
+            linha: items[0].linha
+        }));
+    }
+    return ocorrencias;
+}
 export const analistaCodigoFragil = {
     nome: 'codigo-fragil',
     categoria: 'qualidade',
@@ -170,32 +199,7 @@ export const analistaCodigoFragil = {
         }
         // 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');
-        for (const [severidade, items] of Object.entries(porSeveridade)) {
-            if (items.length > 0) {
-                const nivel = severidade === 'critica' || severidade === 'alta' ? 'erro' : severidade === 'media' ? 'aviso' : 'info';
-                const resumo = items.slice(0, 3).map(caminho => caminho.tipo).join(', ');
-                const tipos = {};
-                for (const it of items) {
-                    tipos[it.tipo] = (tipos[it.tipo] || 0) + 1;
-                }
-                const amostra = items.slice(0, 5).map(it => `${it.tipo} (L${it.linha})`);
-                ocorrencias.push(criarOcorrencia({
-                    tipo: 'codigo-fragil',
-                    nivel,
-                    mensagem: messages.DetectorCodigoFragilMensagens.fragilidadesResumo(severidade, resumo, {
-                        severidade,
-                        total: items.length,
-                        tipos,
-                        amostra
-                    }),
-                    relPath,
-                    linha: items[0].linha
-                }));
-            }
-        }
+        const ocorrencias = converterFragilidadesParaOcorrencias(fragilidades, relPath);
         return filtrarOcorrenciasSuprimidas(ocorrencias, 'codigo-fragil', src);
     }
 };

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

@@ -40,24 +40,7 @@ export const analistaDuplicacoes = {
             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(', ');
-                    ocorrencias.push(criarOcorrencia({
-                        tipo: 'codigo_duplicado',
-                        nivel,
-                        mensagem: messages.DetectorAgregadosMensagens.duplicacoesResumo(tipo, resumo, dups.length),
-                        relPath,
-                        linha: primeiraFunc?.inicio ?? 1
-                    }));
-                }
-            }
-            return ocorrencias;
+            return agruparEConverterDuplicacoes(duplicacoes, relPath);
         }
         catch (erro) {
             return [criarOcorrencia({
@@ -70,6 +53,26 @@ export const analistaDuplicacoes = {
         }
     }
 };
+function agruparEConverterDuplicacoes(duplicacoes, relPath) {
+    const porTipo = agruparPorTipoSimilaridade(duplicacoes);
+    const ocorrencias = [];
+    for (const [tipo, dups] of Object.entries(porTipo)) {
+        if (dups.length === 0) {
+            continue;
+        }
+        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(', ');
+        ocorrencias.push(criarOcorrencia({
+            tipo: 'codigo_duplicado',
+            nivel,
+            mensagem: messages.DetectorAgregadosMensagens.duplicacoesResumo(tipo, resumo, dups.length),
+            relPath,
+            linha: primeiraFunc?.inicio ?? 1
+        }));
+    }
+    return ocorrencias;
+}
 function extrairFuncoes(ast, caminho, src) {
     const funcoes = [];
     const linhas = src.split('\n');

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

@@ -14,7 +14,7 @@ export function detectarMonorepo(baseDir) {
         return info;
     }
     // Detect package manager
-    const pm = rootPkg.packageManager || '';
+    const pm = rootPkg.packageManager ?? '';
     if (pm) {
         info.packageManager = pm;
     }
@@ -237,47 +237,52 @@ export const detectorMonorepo = {
                 versionMap.set(dep, verMap);
             }
         }
-        for (const [dep, versions] of versionMap) {
-            if (versions.size > 1) {
-                const uniqueVersions = new Set(versions.values());
-                if (uniqueVersions.size > 1) {
-                    ocorrencias.push({
-                        tipo: 'monorepo-versao-mismatch',
-                        nivel: 'aviso',
-                        mensagem: `Dependência ${dep} com versões diferentes entre workspaces: ${Array.from(versions.entries()).map(([w, v]) => `${w}@${v}`).join(', ')}`,
-                        origem: 'detector-monorepo',
-                        relPath: '[monorepo]',
-                        linha: 0,
-                    });
-                }
+        detectarVersionMismatch(versionMap, ocorrencias);
+        detectarDependenciasInternasFaltando(info, ocorrencias);
+        return ocorrencias;
+    },
+};
+function detectarVersionMismatch(versionMap, ocorrencias) {
+    for (const [dep, versions] of versionMap) {
+        if (versions.size > 1) {
+            const uniqueVersions = new Set(versions.values());
+            if (uniqueVersions.size > 1) {
+                ocorrencias.push({
+                    tipo: 'monorepo-versao-mismatch',
+                    nivel: 'aviso',
+                    mensagem: `Dependência ${dep} com versões diferentes entre workspaces: ${Array.from(versions.entries()).map(([w, v]) => `${w}@${v}`).join(', ')}`,
+                    origem: 'detector-monorepo',
+                    relPath: '[monorepo]',
+                    linha: 0,
+                });
             }
         }
-        // Detect missing internal dependencies (workspace A uses workspace B but B isn't in A's deps)
-        const workspaceNames = new Set(info.workspaces.map(w => w.name));
-        for (const ws of info.workspaces) {
-            const imports = coletarImports(ws.dir);
-            for (const imp of imports) {
-                for (const wsName of workspaceNames) {
-                    if (imp.includes(wsName) && wsName !== ws.name) {
-                        const isDep = ws.dependencies[wsName] || ws.devDependencies[wsName] || ws.peerDependencies[wsName];
-                        if (!isDep) {
-                            ocorrencias.push({
-                                tipo: 'monorepo-dependencia-interna-faltando',
-                                nivel: 'aviso',
-                                mensagem: `${ws.name} importa ${wsName} mas não o declara como dependência`,
-                                origem: 'detector-monorepo',
-                                relPath: `[${ws.name}]`,
-                                linha: 0,
-                            });
-                        }
-                        break;
+    }
+}
+function detectarDependenciasInternasFaltando(info, ocorrencias) {
+    const workspaceNames = new Set(info.workspaces.map(w => w.name));
+    for (const ws of info.workspaces) {
+        const imports = coletarImports(ws.dir);
+        for (const imp of imports) {
+            for (const wsName of workspaceNames) {
+                if (imp.includes(wsName) && wsName !== ws.name) {
+                    const isDep = ws.dependencies[wsName] || ws.devDependencies[wsName] || ws.peerDependencies[wsName];
+                    if (!isDep) {
+                        ocorrencias.push({
+                            tipo: 'monorepo-dependencia-interna-faltando',
+                            nivel: 'aviso',
+                            mensagem: `${ws.name} importa ${wsName} mas não o declara como dependência`,
+                            origem: 'detector-monorepo',
+                            relPath: `[${ws.name}]`,
+                            linha: 0,
+                        });
                     }
+                    break;
                 }
             }
         }
-        return ocorrencias;
-    },
-};
+    }
+}
 function coletarImports(dir) {
     const imports = [];
     try {

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

@@ -169,6 +169,27 @@ function detectarPadroesPerformance(src, problemas, relPath) {
         }
     });
 }
+function detectarTimerSemCleanup(path, ast, problemas, relPath) {
+    if (path.node.callee.type !== 'Identifier') {
+        return;
+    }
+    if (path.node.callee.name !== 'setTimeout' && path.node.callee.name !== 'setInterval') {
+        return;
+    }
+    const parentFunction = path.getFunctionParent();
+    const context = parentFunction ? parentFunction.toString() : ast.toString();
+    if (context.includes('clear') || relPath.includes('test')) {
+        return;
+    }
+    problemas.push({
+        tipo: 'memory-leak',
+        descricao: `${path.node.callee.name} sem cleanup pode causar vazamento`,
+        impacto: 'medio',
+        linha: path.node.loc?.start.line ?? 0,
+        coluna: path.node.loc?.start.column ?? 0,
+        sugestao: `Use clear${path.node.callee.name.replace('set', '')} para limpar`
+    });
+}
 function detectarProblemasPerformanceAST(ast, problemas, relPath) {
     try {
         const isLoop = (type) => ['ForStatement', 'WhileStatement', 'DoWhileStatement', 'ForInStatement', 'ForOfStatement'].includes(type);
@@ -195,23 +216,8 @@ function detectarProblemasPerformanceAST(ast, problemas, relPath) {
             DoWhileStatement: checkNesting,
             ForInStatement: checkNesting,
             ForOfStatement: checkNesting,
-            // Detectar função setTimeout/setInterval sem cleanup
             CallExpression(path) {
-                if (path.node.callee.type === 'Identifier' && (path.node.callee.name === 'setTimeout' || path.node.callee.name === 'setInterval')) {
-                    // Heurística simples: se não há clear* na mesma função/arquivo
-                    const parentFunction = path.getFunctionParent();
-                    const context = parentFunction ? parentFunction.toString() : ast.toString();
-                    if (!context.includes('clear') && !relPath.includes('test')) {
-                        problemas.push({
-                            tipo: 'memory-leak',
-                            descricao: `${path.node.callee.name} sem cleanup pode causar vazamento`,
-                            impacto: 'medio',
-                            linha: path.node.loc?.start.line ?? 0,
-                            coluna: path.node.loc?.start.column ?? 0,
-                            sugestao: `Use clear${path.node.callee.name.replace('set', '')} para limpar`
-                        });
-                    }
-                }
+                detectarTimerSemCleanup(path, ast, problemas, relPath);
             }
         });
     }

package/dist/analysts/detectors/detector-recommendation-architecture.js

@@ -3,6 +3,43 @@ import { criarOcorrencia } from '../../types/index.js';
  * Analista global que analisa o projeto completo e recomenda
  * a melhor arquitetura (Clean Architecture, Microsserviços, MVC, etc.)
  */
+const CONFIANCA_SIMPLES = 60;
+function adicionarOcorrenciasRecomendacao(ocorrencias, _relPath, sinaisCleanArch, sinaisDistributed, recomendacoes, arquiteturaRecomendada, confianca) {
+    ocorrencias.push(criarOcorrencia({
+        tipo: 'recomendacao-arquitetura',
+        nivel: 'info',
+        relPath: _relPath,
+        linha: 1,
+        mensagem: `[TARGET] Arquitetura recomendada: ${arquiteturaRecomendada} (${confianca}% confiança)`
+    }));
+    if (sinaisCleanArch.length > 0) {
+        ocorrencias.push(criarOcorrencia({
+            tipo: 'sinais-clean-arch',
+            nivel: 'info',
+            relPath: _relPath,
+            linha: 1,
+            mensagem: `Sinais de Clean Architecture: ${sinaisCleanArch.join(', ')}`
+        }));
+    }
+    if (sinaisDistributed.length > 0) {
+        ocorrencias.push(criarOcorrencia({
+            tipo: 'sinais-distributed-arch',
+            nivel: 'info',
+            relPath: _relPath,
+            linha: 1,
+            mensagem: `Sinais de Arquitetura Distribuída: ${sinaisDistributed.join(', ')}`
+        }));
+    }
+    for (const rec of recomendacoes.slice(0, 5)) {
+        ocorrencias.push(criarOcorrencia({
+            tipo: 'recomendacao-arquitetura-item',
+            nivel: 'info',
+            relPath: _relPath,
+            linha: 1,
+            mensagem: `[IDEA] ${rec}`
+        }));
+    }
+}
 export const analistaRecomendacaoArquitetura = {
     nome: 'recomendacao-arquitetura',
     categoria: 'arquitetura',
@@ -221,7 +258,7 @@ export const analistaRecomendacaoArquitetura = {
         if (melhorScore === 0) {
             if (complexidadeBaixa) {
                 arquiteturaRecomendada = 'Arquitetura Simples / Monolítica';
-                confianca = 60;
+                confianca = CONFIANCA_SIMPLES;
                 recomendacoes.push('Projeto de baixa complexidade - comece com uma estrutura simples');
                 recomendacoes.push('Considere evoluir para Clean Architecture conforme o projeto crescer');
             }
@@ -243,40 +280,7 @@ export const analistaRecomendacaoArquitetura = {
         if (totalArquivos > 100 && servicosSet.size === 0) {
             recomendacoes.push('Projeto grande e monolítico - considere dividir em serviços menores');
         }
-        ocorrencias.push(criarOcorrencia({
-            tipo: 'recomendacao-arquitetura',
-            nivel: 'info',
-            relPath: _relPath,
-            linha: 1,
-            mensagem: `[TARGET] Arquitetura recomendada: ${arquiteturaRecomendada} (${confianca}% confiança)`
-        }));
-        if (sinaisCleanArch.length > 0) {
-            ocorrencias.push(criarOcorrencia({
-                tipo: 'sinais-clean-arch',
-                nivel: 'info',
-                relPath: _relPath,
-                linha: 1,
-                mensagem: `Sinais de Clean Architecture: ${sinaisCleanArch.join(', ')}`
-            }));
-        }
-        if (sinaisDistributed.length > 0) {
-            ocorrencias.push(criarOcorrencia({
-                tipo: 'sinais-distributed-arch',
-                nivel: 'info',
-                relPath: _relPath,
-                linha: 1,
-                mensagem: `Sinais de Arquitetura Distribuída: ${sinaisDistributed.join(', ')}`
-            }));
-        }
-        for (const rec of recomendacoes.slice(0, 5)) {
-            ocorrencias.push(criarOcorrencia({
-                tipo: 'recomendacao-arquitetura-item',
-                nivel: 'info',
-                relPath: _relPath,
-                linha: 1,
-                mensagem: `[IDEA] ${rec}`
-            }));
-        }
+        adicionarOcorrenciasRecomendacao(ocorrencias, _relPath, sinaisCleanArch, sinaisDistributed, recomendacoes, arquiteturaRecomendada, confianca);
         return ocorrencias;
     }
 };

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

@@ -322,6 +322,47 @@ function detectarAsyncSemTryCatch(src, problemas) {
         }
     }
 }
+function detectarCookieInseguro(callee, args, path, problemas) {
+    if (callee.type === 'MemberExpression' && callee.property.type === 'Identifier' && callee.property.name === 'cookie') {
+        const object = callee.object;
+        const isRequest = object.type === 'Identifier' && (object.name === 'req' || object.name === 'request');
+        if (!isRequest) {
+            const options = args[2];
+            let hasHttpOnly = false;
+            if (options.type === 'ObjectExpression') {
+                hasHttpOnly = options.properties.some((prop) => prop.type === 'ObjectProperty' && prop.key.type === 'Identifier' && prop.key.name === 'httpOnly' && (prop.value.type === 'BooleanLiteral' ? prop.value.value : false));
+            }
+            if (!hasHttpOnly) {
+                problemas.push({
+                    tipo: 'insecure-cookie',
+                    descricao: 'Cookie configurado sem a flag httpOnly',
+                    severidade: 'media',
+                    linha: path.node.loc?.start.line ?? 0,
+                    sugestao: 'Sempre use httpOnly: true para evitar acesso via JavaScript (XSS)'
+                });
+            }
+        }
+    }
+}
+function detectarSQLInjectionAST(callee, args, path, problemas) {
+    if (callee.type === 'MemberExpression' && callee.property.type === 'Identifier' && ['query', 'execute', 'raw', 'queryRaw', 'executeRaw'].includes(callee.property.name)) {
+        const firstArg = args[0];
+        const isUnsafe = firstArg.type === 'TemplateLiteral' && firstArg.expressions.length > 0 || firstArg.type === 'BinaryExpression' && firstArg.operator === '+';
+        if (isUnsafe) {
+            const code = firstArg.type === 'TemplateLiteral' ? firstArg.quasis.map((delimitadorString) => delimitadorString.value.raw).join('') : '';
+            const temParametros = /['"`].*(\?|\$\d|:\w+).*['"`]/.test(code);
+            if (!temParametros) {
+                problemas.push({
+                    tipo: 'sql-injection',
+                    descricao: 'Possível SQL Injection detectada via AST (concatenação no primeiro argumento)',
+                    severidade: 'critica',
+                    linha: path.node.loc?.start.line ?? 0,
+                    sugestao: 'Use queries parametrizadas ao invés de concatenar strings ou template literals com variáveis'
+                });
+            }
+        }
+    }
+}
 function detectarProblemasAST(ast, problemas) {
     try {
         traverse(ast.node, {
@@ -351,48 +392,8 @@ function detectarProblemasAST(ast, problemas) {
                         sugestao: 'Use função ao invés de string'
                     });
                 }
-                // 2. res.cookie() sem httpOnly
-                if (callee.type === 'MemberExpression' && callee.property.type === 'Identifier' && callee.property.name === 'cookie') {
-                    const object = callee.object;
-                    const isRequest = object.type === 'Identifier' && (object.name === 'req' || object.name === 'request');
-                    if (!isRequest) {
-                        // Heurística: assume-se que se não é req/request, é provável ser a resposta (res)
-                        const options = args[2];
-                        let hasHttpOnly = false;
-                        if (options.type === 'ObjectExpression') {
-                            hasHttpOnly = options.properties.some(prop => prop.type === 'ObjectProperty' && prop.key.type === 'Identifier' && prop.key.name === 'httpOnly' && (prop.value.type === 'BooleanLiteral' ? prop.value.value : false));
-                        }
-                        if (!hasHttpOnly) {
-                            problemas.push({
-                                tipo: 'insecure-cookie',
-                                descricao: 'Cookie configurado sem a flag httpOnly',
-                                severidade: 'media',
-                                linha: path.node.loc?.start.line ?? 0,
-                                sugestao: 'Sempre use httpOnly: true para evitar acesso via JavaScript (XSS)'
-                            });
-                        }
-                    }
-                }
-                // 3. SQL Injection (básico via AST)
-                if (callee.type === 'MemberExpression' && callee.property.type === 'Identifier' && ['query', 'execute', 'raw', 'queryRaw', 'executeRaw'].includes(callee.property.name)) {
-                    const firstArg = args[0];
-                    // Se o primeiro argumento é uma TemplateLiteral com expressões ou uma BinaryExpression (+)
-                    const isUnsafe = firstArg.type === 'TemplateLiteral' && firstArg.expressions.length > 0 || firstArg.type === 'BinaryExpression' && firstArg.operator === '+';
-                    if (isUnsafe) {
-                        // Verificar se parece usar parâmetros de qualquer forma
-                        const code = firstArg.type === 'TemplateLiteral' ? firstArg.quasis.map(delimitadorString => delimitadorString.value.raw).join('') : '';
-                        const temParametros = /['"`].*(\?|\$\d|:\w+).*['"`]/.test(code);
-                        if (!temParametros) {
-                            problemas.push({
-                                tipo: 'sql-injection',
-                                descricao: 'Possível SQL Injection detectada via AST (concatenação no primeiro argumento)',
-                                severidade: 'critica',
-                                linha: path.node.loc?.start.line ?? 0,
-                                sugestao: 'Use queries parametrizadas ao invés de concatenar strings ou template literals com variáveis'
-                            });
-                        }
-                    }
-                }
+                detectarCookieInseguro(callee, args, path, problemas);
+                detectarSQLInjectionAST(callee, args, path, problemas);
             }
         });
     }

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

@@ -4,6 +4,32 @@ import { config, getAllExpectedDirNames, getDirVariantPattern, getNameConvention
 import { messages } from '../../core/messages/index.js';
 import { grafoDependencias } from './detector-dependencies.js';
 export const sinaisDetectados = {};
+function verificarConvencoesNomesDiretorios(ocorrencias, caminhosNorm) {
+    const expectedDirs = getAllExpectedDirNames();
+    if (expectedDirs.length === 0) {
+        return;
+    }
+    const topLevelDirs = new Set(caminhosNorm.filter(caminho => caminho.includes('/') && !caminho.startsWith('node_modules/') && !caminho.startsWith('dist/')).map(caminho => caminho.split('/')[0]));
+    const configuredNames = new Set(Object.values(getNameConventions()).filter((valor) => typeof valor === 'string' && valor.trim().length > 0).map(valor => valor.trim().toLowerCase()));
+    for (const { key, expected } of expectedDirs) {
+        const expectedLower = expected.toLowerCase();
+        const match = [...topLevelDirs].find(diretorio => diretorio.toLowerCase() === expectedLower);
+        if (!match) {
+            const variantPattern = getDirVariantPattern(key);
+            const foundVariant = [...topLevelDirs].find(diretorio => variantPattern.test(diretorio));
+            if (foundVariant && !configuredNames.has(foundVariant.toLowerCase())) {
+                ocorrencias.push({
+                    tipo: 'name-convention',
+                    nivel: 'aviso',
+                    mensagem: messages.DetectorEstruturaMensagens.nomeDiretorioNaoConforme(foundVariant, expected),
+                    origem: 'detector-estrutura',
+                    relPath: `[raiz do projeto]`,
+                    linha: 0
+                });
+            }
+        }
+    }
+}
 /**
  * Analisa a estrutura do projeto e detecta padrões como monorepo, fullstack, mistura de src/packages, etc.
  * Retorna ocorrências para cada sinal relevante encontrado.
@@ -24,7 +50,7 @@ export const detectorEstrutura = {
         // Conjuntos para buscas O(1) e deduplicação implícita
         const setCaminhos = new Set(caminhos);
         // Detecta contexto geral do projeto para análise inteligente
-        const arquivoPrincipal = caminhos?.find(caminho => /package\.json$/.test(caminho)) ?? caminhos?.[0];
+        const arquivoPrincipal = caminhos?.find(caminho => /package\.json$/.test(caminho)) ?? caminhos[0];
         const conteudoPrincipal = contexto.arquivos?.find(arquivo => arquivo.relPath === arquivoPrincipal)?.content ?? '';
         const contextoProjeto = detectarContextoProjeto({
             arquivo: arquivoPrincipal,
@@ -160,7 +186,7 @@ export const detectorEstrutura = {
         // Múltiplos entrypoints
         // Lista de entrypoints potencialmente grande em repositórios com dependências; filtra ignorados
         const entrypointsAll = caminhosNorm.filter(caminho => /(^|[\\/])(cli|index|main)\.(ts|js)$/.test(caminho));
-        const ignoredDyn = config.INCLUDE_EXCLUDE_RULES.globalExcludeGlob ?? [];
+        const ignoredDyn = config.INCLUDE_EXCLUDE_RULES.globalExcludeGlob;
         const entrypoints = entrypointsAll.filter(caminho => !micromatch.isMatch(caminho, ignoredDyn)).sort();
         if (entrypoints.length > 1) {
             const MAX_LIST = 20;
@@ -220,30 +246,7 @@ export const detectorEstrutura = {
                 linha: 0
             });
         }
-        // Verifica convenções de nomes de diretórios
-        const expectedDirs = getAllExpectedDirNames();
-        if (expectedDirs.length > 0) {
-            const topLevelDirs = new Set(caminhosNorm.filter(caminho => caminho.includes('/') && !caminho.startsWith('node_modules/') && !caminho.startsWith('dist/')).map(caminho => caminho.split('/')[0]));
-            const configuredNames = new Set(Object.values(getNameConventions()).filter((valor) => typeof valor === 'string' && valor.trim().length > 0).map(valor => valor.trim().toLowerCase()));
-            for (const { key, expected } of expectedDirs) {
-                const expectedLower = expected.toLowerCase();
-                const match = [...topLevelDirs].find(diretorio => diretorio.toLowerCase() === expectedLower);
-                if (!match) {
-                    const variantPattern = getDirVariantPattern(key);
-                    const foundVariant = [...topLevelDirs].find(diretorio => variantPattern.test(diretorio));
-                    if (foundVariant && !configuredNames.has(foundVariant.toLowerCase())) {
-                        ocorrencias.push({
-                            tipo: 'name-convention',
-                            nivel: 'aviso',
-                            mensagem: messages.DetectorEstruturaMensagens.nomeDiretorioNaoConforme(foundVariant, expected),
-                            origem: 'detector-estrutura',
-                            relPath: `[raiz do projeto]`,
-                            linha: 0
-                        });
-                    }
-                }
-            }
-        }
+        verificarConvencoesNomesDiretorios(ocorrencias, caminhosNorm);
         return Array.isArray(ocorrencias) ? ocorrencias : [];
     }
 };

package/dist/analysts/js-ts/detectors/detector-anti-patterns-async.js

@@ -276,7 +276,10 @@ export const analistaAntiPadroesAsync = {
         traverse(nodeToTraverse, visitorAsync, undefined, stateObj);
         // Top-level await detection via text
         if (/^\s*await\s+/m.test(src)) {
-            const topLevelAwaitLine = src.match(/^\s*await\s+/m) ? src.substring(0, src.match(/^\s*await\s+/m).index).split('\n').length : 1;
+            const topLevelAwaitLine = (() => {
+                const m = src.match(/^\s*await\s+/m);
+                return m ? src.substring(0, m.index).split('\n').length : 1;
+            })();
             const fnParentLines = new Set();
             const fnVisitor = {
                 Function(path) {

package/dist/analysts/js-ts/detectors/detector-constructions-syntactic.js

@@ -208,23 +208,20 @@ export const analistaConstrucoesSintaticas = {
             });
             // Text-based detection for ES2025/ES2026 patterns
             const esPatterns = [
-                [/\busing\s+\w+\s*=\s*new\s+/g, 'explicit-resource-management', (linha) => pushExtra('explicit-resource-management', 'info', 'Explicit Resource Management with "using" (ES2026)', linha)],
-                [/\bawait\s+using\s+/g, 'explicit-resource-management-async', (linha) => pushExtra('explicit-resource-management-async', 'info', 'Async Resource Management with "await using" (ES2026)', linha)],
-                [/\bTemporal\.\w+/g, 'temporal-api-usage', (linha) => pushExtra('temporal-api-usage', 'info', 'Temporal API usage (ES2026)', linha)],
-                [/Promise\.withResolvers\s*\(/g, 'promise-with-resolvers', (linha) => pushExtra('promise-with-resolvers', 'info', 'Promise.withResolvers() (ES2025)', linha)],
-                [/Promise\.try\s*\(/g, 'promise-try', (linha) => pushExtra('promise-try', 'info', 'Promise.try() (ES2025)', linha)],
-                [/RegExp\.escape\s*\(/g, 'regexp-escape', (linha) => pushExtra('regexp-escape', 'info', 'RegExp.escape() (ES2025)', linha)],
-                [/Error\.isError\s*\(/g, 'error-is-error', (linha) => pushExtra('error-is-error', 'info', 'Error.isError() (ES2026)', linha)],
-                [/Array\.fromAsync\s*\(/g, 'array-from-async', (linha) => pushExtra('array-from-async', 'info', 'Array.fromAsync() (ES2026)', linha)],
-                [/\bIterator\.from\s*\(/g, 'iterator-from', (linha) => pushExtra('iterator-from', 'info', 'Iterator.from() (ES2025)', linha)],
+                [/\busing\s+\w+\s*=\s*new\s+/g, 'explicit-resource-management', (linha) => { pushExtra('explicit-resource-management', 'info', 'Explicit Resource Management with "using" (ES2026)', linha); }],
+                [/\bawait\s+using\s+/g, 'explicit-resource-management-async', (linha) => { pushExtra('explicit-resource-management-async', 'info', 'Async Resource Management with "await using" (ES2026)', linha); }],
+                [/\bTemporal\.\w+/g, 'temporal-api-usage', (linha) => { pushExtra('temporal-api-usage', 'info', 'Temporal API usage (ES2026)', linha); }],
+                [/Promise\.withResolvers\s*\(/g, 'promise-with-resolvers', (linha) => { pushExtra('promise-with-resolvers', 'info', 'Promise.withResolvers() (ES2025)', linha); }],
+                [/Promise\.try\s*\(/g, 'promise-try', (linha) => { pushExtra('promise-try', 'info', 'Promise.try() (ES2025)', linha); }],
+                [/RegExp\.escape\s*\(/g, 'regexp-escape', (linha) => { pushExtra('regexp-escape', 'info', 'RegExp.escape() (ES2025)', linha); }],
+                [/Error\.isError\s*\(/g, 'error-is-error', (linha) => { pushExtra('error-is-error', 'info', 'Error.isError() (ES2026)', linha); }],
+                [/Array\.fromAsync\s*\(/g, 'array-from-async', (linha) => { pushExtra('array-from-async', 'info', 'Array.fromAsync() (ES2026)', linha); }],
+                [/\bIterator\.from\s*\(/g, 'iterator-from', (linha) => { pushExtra('iterator-from', 'info', 'Iterator.from() (ES2025)', linha); }],
             ];
             for (const [pattern, , fn] of esPatterns) {
                 let m;
                 while ((m = pattern.exec(src)) !== null) {
                     const position = m.index;
-                    if (position == null) {
-                        continue;
-                    }
                     if (!isInStringOrComment(src, position)) {
                         const linha = src.substring(0, position).split('\n').length;
                         fn(linha);
@@ -237,10 +234,7 @@ export const analistaConstrucoesSintaticas = {
             while ((match = templateLiteralPadrao.exec(src)) !== null) {
                 const content = match[1];
                 if (content && !content.includes('${') && content.length < 10) {
-                    const position = match.index;
-                    if (position == null) {
-                        continue;
-                    }
+                    const position = match.index ?? 0;
                     if (!isInStringOrComment(src, position)) {
                         const linha = src.substring(0, position).split('\n').length;
                         pushExtra('template-literal-overuse', 'info', messages.DetectorConstrucoesSintaticasMensagens.templateLiteralOveruse, linha);

package/dist/analysts/plugins/detector-documentation.js

@@ -173,6 +173,7 @@ function detectarPadroesDocumentacao(src, problemas, relPath) {
     // 2. Tem exportações públicas E
     // 3. Não tem nenhum JSDoc E
     // 4. Não é arquivo de teste/config/setup
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- vars mutated inside forEach closure; TS can't track
     if (isLibraryArquivo && temExportacaoPublica && !temJSDoc && !isInternalArquivo && src.length > 200) {
         // Arquivo grande o suficiente para justificar documentação
         problemas.push({

package/dist/analysts/react/analysts/analyst-react-hooks.js

@@ -114,6 +114,7 @@ function collectHookIssues(src, relPath) {
     for (const match of src.matchAll(/\buse\s*\(/g)) {
         const line = lineOf(match.index);
         // Avoid matching "useState", "useEffect", etc.
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- runtime safety for match.index === 0
         if (src[match.index - 1]?.match(/[a-zA-Z]/)) {
             continue;
         }
@@ -145,7 +146,7 @@ function parseHooksWithBabel(src, relPath) {
         if (isJsxLike) {
             plugins.unshift('jsx');
         }
-        const ast = babelParse(src, { sourceType: 'unambiguous', errorRecovery: true, plugins });
+        const ast = babelParse(src, { sourceType: 'unambiguous', errorRecovery: true, plugins: plugins });
         const out = [];
         const seen = new Set();
         const pushOnce = (m) => {
@@ -161,8 +162,9 @@ function parseHooksWithBabel(src, relPath) {
             if (t.isIdentifier(callee)) {
                 const name = callee.name;
                 // React 19: use() is a special case (not prefixed with use but still a hook)
-                if (name === 'use')
+                if (name === 'use') {
                     return { name };
+                }
                 return /^use[A-Z0-9_]/.test(name) ? { name } : null;
             }
             if (t.isMemberExpression(callee)) {