@mocoto/mahoraga 0.14.0 → 0.14.2

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

@@ -1,18 +1,25 @@
 import { criarOcorrencia } from '../../types/index.js';
+/**
+ * Analista global que analisa o projeto completo e recomenda
+ * a melhor arquitetura (Clean Architecture, Microsserviços, MVC, etc.)
+ */
 export const analistaRecomendacaoArquitetura = {
     nome: 'recomendacao-arquitetura',
     categoria: 'arquitetura',
     descricao: 'Analisa o projeto e recomenda a melhor arquitetura a ser aplicada',
     global: true,
     test: () => true,
-    aplicar: async (_src, _relPath, _ast, _fullCaminho, contexto) => {
-        if (!contexto)
+    aplicar: (_src, _relPath, _ast, _fullCaminho, contexto) => {
+        if (!contexto) {
             return [];
+        }
         const ocorrencias = [];
         const caminhos = contexto.arquivos.map(a => a.relPath.toLowerCase());
-        const conteudos = contexto.arquivos.map(a => a.content?.toLowerCase() || '');
+        const conteudos = contexto.arquivos.map(a => a.content?.toLowerCase() ?? '');
+        // === SINAIS PARA CLEAN ARCHITECTURE ===
         let scoreCleanArch = 0;
         const sinaisCleanArch = [];
+        // Domain layer
         const temEntities = caminhos.some(c => c.includes('/entities/') || c.endsWith('entity.ts') || c.endsWith('entity.js'));
         const temValueObjects = caminhos.some(c => c.includes('value-object') || c.includes('value_object'));
         const temDomainServices = caminhos.some(c => c.includes('/domain/') && c.includes('service'));
@@ -33,6 +40,7 @@ export const analistaRecomendacaoArquitetura = {
             scoreCleanArch += 10;
             sinaisCleanArch.push('Eventos de domínio');
         }
+        // Application layer
         const temUseCases = caminhos.some(c => c.includes('/use-cases') || c.includes('/usecases') || c.includes('/application/'));
         const temPorts = caminhos.some(c => c.includes('/ports/') || c.includes('/application/port'));
         const temDtos = caminhos.some(c => c.includes('/dto/') || c.endsWith('.dto.ts') || c.endsWith('.dto.js'));
@@ -48,6 +56,7 @@ export const analistaRecomendacaoArquitetura = {
             scoreCleanArch += 10;
             sinaisCleanArch.push('DTOs');
         }
+        // Infrastructure layer
         const temInfra = caminhos.some(c => c.includes('/infrastructure/') || c.includes('/infra/'));
         const temRepositories = caminhos.some(c => c.includes('/repositories/') || c.endsWith('.repository.ts'));
         const temGateways = caminhos.some(c => c.includes('/gateways/'));
@@ -63,6 +72,7 @@ export const analistaRecomendacaoArquitetura = {
             scoreCleanArch += 5;
             sinaisCleanArch.push('Gateways');
         }
+        // Presentation layer
         const temControllers = caminhos.some(c => c.includes('/controllers/') || c.endsWith('.controller.ts'));
         const temPresenters = caminhos.some(c => c.includes('/presenters/') || c.endsWith('.presenter.ts'));
         if (temControllers) {
@@ -73,18 +83,22 @@ export const analistaRecomendacaoArquitetura = {
             scoreCleanArch += 5;
             sinaisCleanArch.push('Presenters');
         }
+        // DI Container
         const temDI = conteudos.some(c => c.includes('tsyringe') || c.includes('inversify') || c.includes('awilix') || c.includes('typedi'));
         if (temDI) {
             scoreCleanArch += 5;
             sinaisCleanArch.push('Container DI');
         }
+        // === SINAIS PARA ARQUITETURA DISTRIBUÍDA ===
         let scoreDistributed = 0;
         const sinaisDistributed = [];
+        // Múltiplos serviços
         const servicosSet = new Set();
         for (const c of caminhos) {
             const match = c.match(/services\/([^/]+)/);
-            if (match)
+            if (match) {
                 servicosSet.add(match[1]);
+            }
         }
         if (servicosSet.size >= 2) {
             scoreDistributed += 20;
@@ -94,6 +108,7 @@ export const analistaRecomendacaoArquitetura = {
             scoreDistributed += 10;
             sinaisDistributed.push('1 boundary de serviço');
         }
+        // Mensageria
         const temMensageria = caminhos.some(c => c.includes('/events/') || c.includes('/messaging') || c.includes('/queues') ||
             c.includes('/consumers') || c.includes('/producers'));
         const temMensageriaDeps = conteudos.some(c => c.includes('kafkajs') || c.includes('amqplib') || c.includes('ioredis') ||
@@ -102,42 +117,50 @@ export const analistaRecomendacaoArquitetura = {
             scoreDistributed += 15;
             sinaisDistributed.push('Mensageria');
         }
+        // API Gateway
         const temGateway = caminhos.some(c => c.includes('/gateway') || c.includes('/api-gateway'));
         if (temGateway) {
             scoreDistributed += 15;
             sinaisDistributed.push('API Gateway');
         }
+        // Service Discovery
         const temDiscovery = caminhos.some(c => c.includes('/discovery') || c.includes('consul') || c.includes('eureka'));
         if (temDiscovery) {
             scoreDistributed += 10;
             sinaisDistributed.push('Service Discovery');
         }
+        // Docker/Container
         const temDocker = caminhos.some(c => c.endsWith('dockerfile') || c.includes('docker-compose'));
         if (temDocker) {
             scoreDistributed += 10;
             sinaisDistributed.push('Docker');
         }
+        // K8s
         const temK8s = caminhos.some(c => c.includes('kubernetes') || c.includes('k8s/'));
         if (temK8s) {
             scoreDistributed += 10;
             sinaisDistributed.push('Kubernetes');
         }
+        // Event-driven patterns
         const temEventDriven = conteudos.filter(c => c.includes('eventemitter') || c.includes('publish') || c.includes('subscribe') ||
             c.includes('webhook') || c.includes('observable')).length > 3;
         if (temEventDriven) {
             scoreDistributed += 10;
             sinaisDistributed.push('Padrões event-driven');
         }
+        // Monitoring
         const temMonitoring = caminhos.some(c => c.includes('/health') || c.includes('/monitoring') || c.includes('/metrics'));
         if (temMonitoring) {
             scoreDistributed += 10;
             sinaisDistributed.push('Monitoramento');
         }
+        // Shared lib
         const temShared = caminhos.some(c => c.includes('/shared/') || c.includes('/common/'));
         if (temShared) {
             scoreDistributed += 5;
             sinaisDistributed.push('Biblioteca compartilhada');
         }
+        // === DECISÃO DA ARQUITETURA ===
         const totalArquivos = contexto.arquivos.length;
         const complexidadeBaixa = totalArquivos < 30;
         const temFrontend = caminhos.some(c => c.includes('/pages/') || c.includes('/components/') || c.includes('/views/'));
@@ -145,21 +168,27 @@ export const analistaRecomendacaoArquitetura = {
         let melhorScore = 0;
         let confianca = 0;
         const recomendacoes = [];
+        // Clean Architecture é recomendada para projetos com regras de negócio complexas
         if (scoreCleanArch >= 40 || (temEntities && temUseCases)) {
             if (scoreCleanArch > melhorScore) {
                 arquiteturaRecomendada = 'Clean Architecture (Arquitetura Limpa)';
                 melhorScore = scoreCleanArch;
                 confianca = Math.min(95, scoreCleanArch + (temDI ? 10 : 0));
             }
-            if (!temEntities)
+            if (!temEntities) {
                 recomendacoes.push('Crie entidades de domínio para encapsular regras de negócio');
-            if (!temUseCases)
+            }
+            if (!temUseCases) {
                 recomendacoes.push('Organize a lógica da aplicação em casos de uso (use-cases)');
-            if (!temPorts)
+            }
+            if (!temPorts) {
                 recomendacoes.push('Defina portas (ports) na camada de aplicação para inversão de dependência');
-            if (!temRepositories)
+            }
+            if (!temRepositories) {
                 recomendacoes.push('Implemente o padrão Repository para abstrair persistência');
+            }
         }
+        // Arquitetura Distribuída é recomendada para projetos com múltiplos serviços
         if (scoreDistributed >= 35 && servicosSet.size >= 1) {
             if (scoreDistributed > melhorScore) {
                 arquiteturaRecomendada = 'Arquitetura Distribuída / Microsserviços';
@@ -172,19 +201,23 @@ export const analistaRecomendacaoArquitetura = {
             if (!temGateway && servicosSet.size > 1) {
                 recomendacoes.push('Implemente um API Gateway para rotear requisições aos serviços');
             }
-            if (!temDocker)
+            if (!temDocker) {
                 recomendacoes.push('Conteinerize os serviços com Docker');
-            if (!temMonitoring)
+            }
+            if (!temMonitoring) {
                 recomendacoes.push('Adicione health checks e monitoramento centralizado');
+            }
         }
+        // MVC para projetos web tradicionais
         if (temFrontend && temControllers && !temEntities) {
-            const scoreMvc = (temControllers ? 15 : 0) + (temFrontend ? 15 : 0);
+            const scoreMvc = 30;
             if (scoreMvc > melhorScore && !complexidadeBaixa) {
                 arquiteturaRecomendada = 'MVC (Model-View-Controller)';
                 melhorScore = scoreMvc;
                 confianca = Math.min(80, scoreMvc + 30);
             }
         }
+        // Se ainda não há recomendação clara, sugerir a mais adequada
         if (melhorScore === 0) {
             if (complexidadeBaixa) {
                 arquiteturaRecomendada = 'Arquitetura Simples / Monolítica';
@@ -203,6 +236,7 @@ export const analistaRecomendacaoArquitetura = {
                 recomendacoes.push('Organize o código em camadas (controllers, services, repositories)');
             }
         }
+        // Adicionar recomendações gerais
         if (scoreCleanArch >= 20 && scoreDistributed >= 20) {
             recomendacoes.push('Projeto apresenta características híbridas - considere Clean Architecture com boundaries de microsserviços');
         }
@@ -246,4 +280,3 @@ export const analistaRecomendacaoArquitetura = {
         return ocorrencias;
     }
 };
-//# sourceMappingURL=detector-recommendation-architecture.js.map

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

@@ -1,6 +1,6 @@
+import { detectarContextoProjeto } from '../../shared/index.js';
 import { traverse } from '../../core/config/index.js';
 import { messages } from '../../core/messages/index.js';
-import { detectarContextoProjeto } from '../../shared/index.js';
 import { agruparPor, criarErroAnalise, detectarSegredosHardcoded, filtrarOcorrenciasSuprimidas, splitLines } from '../../shared/helpers/index.js';
 import { criarOcorrencia } from '../../types/index.js';
 export const analistaSeguranca = {
@@ -11,8 +11,9 @@ export const analistaSeguranca = {
         return /\.(js|jsx|ts|tsx|mjs|cjs)$/.test(relPath);
     },
     aplicar: (src, relPath, ast) => {
-        if (!src)
+        if (!src) {
             return [];
+        }
         const contextoArquivo = detectarContextoProjeto({
             arquivo: relPath,
             conteudo: src,
@@ -20,15 +21,20 @@ export const analistaSeguranca = {
         });
         const problemas = [];
         try {
+            // Detectar problemas por padrões de texto (mais confiável que AST para alguns casos)
             detectarPadroesPerigosos(src, relPath, problemas);
+            // Detectar problemas via AST quando disponível
             if (ast) {
                 detectarProblemasAST(ast, problemas);
             }
+            // Converter para ocorrências
             const ocorrencias = [];
+            // Agrupar por severidade
             const porSeveridade = agruparPor(problemas, caminho => caminho.severidade);
             for (const [severidade, items] of Object.entries(porSeveridade)) {
                 if (items.length > 0) {
                     const nivel = mapearSeveridadeParaNivel(severidade);
+                    // Ajustar severidade baseado no contexto
                     const nivelAjustado = contextoArquivo.isTest && nivel === 'aviso' ? 'info' : nivel;
                     const resumo = items.slice(0, 3).map(caminho => caminho.tipo).join(', ');
                     ocorrencias.push(criarOcorrencia({
@@ -40,6 +46,7 @@ export const analistaSeguranca = {
                     }));
                 }
             }
+            // Aplicar supressões inline antes de retornar
             return filtrarOcorrenciasSuprimidas(ocorrencias, 'seguranca', src);
         }
         catch (erro) {
@@ -50,17 +57,24 @@ export const analistaSeguranca = {
 function detectarPadroesPerigosos(src, relPath, problemas) {
     const linhas = splitLines(src);
     function isLikelyHttpHeaderName(value) {
-        const headerValue = String(value || '').trim();
-        if (!headerValue)
+        const headerValue = (value || '').trim();
+        if (!headerValue) {
             return false;
-        if (headerValue.length < 4 || headerValue.length > 80)
+        }
+        // Header names geralmente são curtos/médios e usam letras/números/hífens.
+        if (headerValue.length < 4 || headerValue.length > 80) {
             return false;
-        if (!/^[A-Za-z0-9-]+$/.test(headerValue))
+        }
+        if (!/^[A-Za-z0-9-]+$/.test(headerValue)) {
             return false;
-        if (headerValue.startsWith('-') || headerValue.endsWith('-'))
+        }
+        if (headerValue.startsWith('-') || headerValue.endsWith('-')) {
             return false;
-        if (!/-/.test(headerValue) && !/^X[A-Za-z]?/.test(headerValue))
+        }
+        // Heurística: costuma ter hífen (ex.: Content-Type) e, muitas vezes, prefixo X-
+        if (!/-/.test(headerValue) && !/^X[A-Za-z]?/.test(headerValue)) {
             return false;
+        }
         return true;
     }
     function isHttpHeadersKeyValueContext(index) {
@@ -71,8 +85,10 @@ function detectarPadroesPerigosos(src, relPath, problemas) {
         const hasValorProp = /\bvalue\b\s*[:=]/i.test(ctx);
         return hasHeaders && hasValorProp;
     }
+    // Detecção de segredos hardcoded via helper compartilhado
     const segredos = detectarSegredosHardcoded(src, relPath);
     segredos.forEach(string => {
+        // Redução de falsos positivos específica para detector-seguranca: headers HTTP
         if (string.campo === 'key' && isLikelyHttpHeaderName(string.valor) && isHttpHeadersKeyValueContext(string.linha - 1)) {
             return;
         }
@@ -86,8 +102,10 @@ function detectarPadroesPerigosos(src, relPath, problemas) {
     });
     linhas.forEach((linha, index) => {
         const numeroLinha = index + 1;
+        // Ignorar comentários, strings e regex patterns para reduzir falsos positivos
         const linhaSemComentarios = linha.replace(/\/\/.*$/gm, '').replace(/\/\*.*?\*\//gs, '');
         const linhaSemStrings = linhaSemComentarios.replace(/'[^']*'/g, '').replace(/"[^"]*"/g, '').replace(/`[^`]*`/g, '').replace(/\/(?:[^\/\\]|\\.)*\//g, '');
+        // eval() usage - apenas em código real, não em comentários/strings/regex
         if (/\beval\s*\(/.test(linhaSemStrings)) {
             problemas.push({
                 tipo: 'eval-usage',
@@ -97,6 +115,7 @@ function detectarPadroesPerigosos(src, relPath, problemas) {
                 sugestao: 'Use JSON.parse() ou funções específicas ao invés de eval()'
             });
         }
+        // dangerouslySetInnerHTML - React security risk
         if (/dangerouslySetInnerHTML\s*[:=]/.test(linhaSemStrings)) {
             problemas.push({
                 tipo: 'dangerously-set-inner-html',
@@ -106,6 +125,7 @@ function detectarPadroesPerigosos(src, relPath, problemas) {
                 sugestao: 'Use sanitize-html ou DOMPurify para limpar o conteúdo antes de renderizar'
             });
         }
+        // innerHTML com variáveis
         if (/\.(innerHTML|outerHTML)\s*=\s*[^"']/.test(linha)) {
             problemas.push({
                 tipo: 'dangerous-html',
@@ -115,6 +135,7 @@ function detectarPadroesPerigosos(src, relPath, problemas) {
                 sugestao: 'Use textContent ou sanitize o HTML antes de inserir'
             });
         }
+        // document.write usage
         if (/\bdocument\.write(ln)?\s*\(/.test(linhaSemStrings)) {
             problemas.push({
                 tipo: 'xss-vulnerability',
@@ -124,7 +145,9 @@ function detectarPadroesPerigosos(src, relPath, problemas) {
                 sugestao: 'Use manipulação de DOM segura (createElement, appendChild, etc.)'
             });
         }
+        // SQL Injection patterns
         if (/\.(query|execute|raw|queryRaw|executeRaw)\s*\(/.test(linha) && (/req\.|params\.|query\.|body\./.test(linha) || /\$\{.*\}/.test(linha) || /\s\+\s/.test(linha))) {
+            // Ignorar se parecer que está usando parâmetros (ex: ?, $1, :name)
             const temParametros = /['"`].*(\?|\$\d|:\w+).*['"`]/.test(linha);
             if (!temParametros) {
                 problemas.push({
@@ -136,6 +159,7 @@ function detectarPadroesPerigosos(src, relPath, problemas) {
                 });
             }
         }
+        // Command Injection
         if (/\b(exec|execSync|spawn|spawnSync)\s*\(/.test(linha) && /req\.|params\.|query\.|body\./.test(linha)) {
             problemas.push({
                 tipo: 'command-injection',
@@ -145,6 +169,7 @@ function detectarPadroesPerigosos(src, relPath, problemas) {
                 sugestao: 'Evite executar comandos shell com input do usuário; use APIs específicas ou valide rigorosamente'
             });
         }
+        // Insecure cookie settings
         if (/\.cookie\s*\(/.test(linha) && !/req\.cookie|request\.cookie/.test(linha) && !/httpOnly\s*:\s*true/.test(linha)) {
             problemas.push({
                 tipo: 'insecure-cookie',
@@ -154,6 +179,7 @@ function detectarPadroesPerigosos(src, relPath, problemas) {
                 sugestao: 'Sempre use httpOnly: true para evitar acesso via JavaScript (XSS). Se estiver usando configuração multi-line, o detector AST cuidará da validação.'
             });
         }
+        // Redirecionamentos inseguros
         if (/\.(assign|replace|href)\s*=\s*.*(req\.|params\.|query\.|body\.)/.test(linha)) {
             problemas.push({
                 tipo: 'xss-vulnerability',
@@ -163,6 +189,7 @@ function detectarPadroesPerigosos(src, relPath, problemas) {
                 sugestao: 'Valide a URL de destino contra uma whitelist antes de redirecionar'
             });
         }
+        // Math.random() para criptografia
         if (/Math\.random\(\)/.test(linha) && /crypto|password|token|secret/i.test(linha)) {
             problemas.push({
                 tipo: 'weak-crypto',
@@ -172,6 +199,7 @@ function detectarPadroesPerigosos(src, relPath, problemas) {
                 sugestao: 'Use crypto.randomBytes() ou crypto.getRandomValues()'
             });
         }
+        // Exposure of sensitive environment variables
         if (/\b(console\.log|console\.debug|console\.info|res\.send|res\.json|res\.write|reply\.send)\s*\(.*(process\.env\.(PASSWORD|SECRET|TOKEN|KEY|API|PWD|AUTH|CREDENTIALS|DB|PASS|STRIPE|AWS|PRIVATE))/i.test(linha)) {
             problemas.push({
                 tipo: 'sensitive-env-exposure',
@@ -181,8 +209,10 @@ function detectarPadroesPerigosos(src, relPath, problemas) {
                 sugestao: 'Nunca exponha variáveis de ambiente que contenham segredos em logs ou respostas'
             });
         }
+        // Algoritmos de hash fracos
         if (/createHash\s*\(\s*['"`](md5|md4|sha1)['"`]\s*\)/.test(linha)) {
             const algoritmo = /createHash\s*\(\s*['"`](md5|md4|sha1)['"`]\s*\)/.exec(linha)?.[1];
+            // Verificar se há comentário justificando o uso (ex: fingerprinting, não-criptográfico)
             const linhaAnterior = index > 0 ? linhas[index - 1] : '';
             const linha2Atras = index > 1 ? linhas[index - 2] : '';
             const comentarioContexto = linhaAnterior + linha2Atras;
@@ -197,6 +227,7 @@ function detectarPadroesPerigosos(src, relPath, problemas) {
                 });
             }
         }
+        // RegExp com input do usuário
         if (/new RegExp\s*\([^)]*\)/.test(linha) && /req\.|params\.|query\.|body\./.test(linha)) {
             problemas.push({
                 tipo: 'unsafe-regex',
@@ -206,9 +237,13 @@ function detectarPadroesPerigosos(src, relPath, problemas) {
                 sugestao: 'Valide e escape o input antes de usar em RegExp'
             });
         }
+        // Dangerous literal regex (heuristic for ReDoS)
         const regexLiteralMatch = linha.match(/\/([^\/\\]|\\.)+\/[gimuy]*/);
         if (regexLiteralMatch) {
             const pattern = regexLiteralMatch[0];
+            // Heurística para quantificadores aninhados ou repetitivos que causam backtracking catastrófico
+            // Foca em padrões como (a+)+, (.*)*, (.+)+ e .*.* ou .+ .+
+            // Ignora padrões seguros como [\s\S]*? (usados em parsers)
             const isParserLoop = /[\s\S]*?\//.test(pattern) || /[\s\S]*?/.test(pattern);
             if (!isParserLoop && (/(\([^)]+\+?\)\+|\([^)]+\+?\)\*|(\.\*){2,}|(\.\+){2,}|([a-zA-Z0-9])\+\+)/.test(pattern) || /\[[^\]]+\]\+\+/.test(pattern))) {
                 problemas.push({
@@ -220,6 +255,7 @@ function detectarPadroesPerigosos(src, relPath, problemas) {
                 });
             }
         }
+        // __proto__ manipulation - evitar falsos positivos em strings/comentários
         if (/__proto__/.test(linhaSemStrings)) {
             problemas.push({
                 tipo: 'prototype-pollution',
@@ -229,6 +265,7 @@ function detectarPadroesPerigosos(src, relPath, problemas) {
                 sugestao: 'Use Object.create(null) ou Object.setPrototypeOf() com cuidado'
             });
         }
+        // Path traversal patterns
         if (/\.\.\//g.test(linha) && /req\.|params\.|query\./.test(linha)) {
             problemas.push({
                 tipo: 'path-traversal',
@@ -239,26 +276,39 @@ function detectarPadroesPerigosos(src, relPath, problemas) {
             });
         }
     });
+    // Detectar async/await sem try-catch (melhoria exclusiva)
     detectarAsyncSemTryCatch(src, problemas);
 }
+/**
+ * Detecta uso de async/await sem tratamento adequado de erro
+ */
 function detectarAsyncSemTryCatch(src, problemas) {
     const lines = splitLines(src);
+    // Contexto global do arquivo para detectar padrões do Next.js
     const isNextJsServerComponent = /^['"](use server|use client)['"]/.test(src.trim()) || /export\s+(default\s+)?async\s+function/.test(src);
     const hasDynamicImport = /next\/dynamic|import\s*\(/.test(src);
     for (let indice = 0; indice < lines.length; indice++) {
         const line = lines[indice];
         const trimmedLine = line.trim();
+        // Detectar await sem try-catch
         if (/\bawait\s+/.test(line) && !trimmedLine.startsWith('//')) {
+            // Verificar contexto expandido para detectar event handlers
             const contextLines = lines.slice(Math.max(0, indice - 10), indice);
             const context = contextLines.join(' ');
+            // Detectar se está dentro de event handler (fire-and-forget por design)
             const isEventHandler = /\.on\s*\(/.test(context) || /\.once\s*\(/.test(context) || /addEventListener\s*\(/.test(context) || /collector\.on\s*\(/.test(context) || /emitter\.on\s*\(/.test(context) || /process\.on\s*\(/.test(context);
+            // Verificar se é dynamic import do Next.js (tratamento gerenciado pelo framework)
             const isDynamicImport = hasDynamicImport && (/import\s*\(/.test(line) || /dynamic\s*\(/.test(context));
+            // Server Components do Next.js: tratamento gerenciado pelo framework
             if (isNextJsServerComponent || isDynamicImport) {
                 continue;
             }
+            // Verificar se há try-catch em escopo expandido (100 linhas antes/depois)
             const extendedContext = lines.slice(Math.max(0, indice - 100), Math.min(lines.length, indice + 100));
             const fullContext = extendedContext.join('\n');
+            // Detectar try-catch em escopo pai (bloco que envolve o await)
             const hasErroHandling = /try\s*\{[\s\S]*?\}\s*catch/.test(fullContext) || /\.catch\s*\(/.test(line) || /\.catch\s*\(/.test(lines[indice + 1] || '') ||
+                // Promise encadeada com .then().catch()
                 /\.then\s*\([^)]*\)\s*\.catch/.test(fullContext);
             if (!hasErroHandling) {
                 problemas.push({
@@ -275,53 +325,61 @@ function detectarAsyncSemTryCatch(src, problemas) {
 function detectarProblemasAST(ast, problemas) {
     try {
         traverse(ast.node, {
+            // Detectar Function constructor
             NewExpression(path) {
                 if (path.node.callee.type === 'Identifier' && path.node.callee.name === 'Function') {
                     problemas.push({
                         tipo: 'eval-usage',
                         descricao: 'Function constructor pode executar código dinâmico',
                         severidade: 'alta',
-                        linha: path.node.loc?.start.line || 0,
+                        linha: path.node.loc?.start.line ?? 0,
                         sugestao: 'Evite Function constructor, use funções declaradas'
                     });
                 }
             },
+            // Detectar chamadas perigosas
             CallExpression(path) {
                 const callee = path.node.callee;
                 const args = path.node.arguments;
+                // 1. setTimeout/setInterval com strings
                 if (callee.type === 'Identifier' && ['setTimeout', 'setInterval'].includes(callee.name) && args[0]?.type === 'StringLiteral') {
                     problemas.push({
                         tipo: 'eval-usage',
                         descricao: 'setTimeout/setInterval com string executa código dinâmico',
                         severidade: 'media',
-                        linha: path.node.loc?.start.line || 0,
+                        linha: path.node.loc?.start.line ?? 0,
                         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 && 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 === true : 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,
+                                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];
-                    const isUnsafe = firstArg && (firstArg.type === 'TemplateLiteral' && firstArg.expressions.length > 0 || firstArg.type === 'BinaryExpression' && firstArg.operator === '+');
+                    // 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) {
@@ -329,7 +387,7 @@ function detectarProblemasAST(ast, problemas) {
                                 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,
+                                linha: path.node.loc?.start.line ?? 0,
                                 sugestao: 'Use queries parametrizadas ao invés de concatenar strings ou template literals com variáveis'
                             });
                         }
@@ -339,6 +397,7 @@ function detectarProblemasAST(ast, problemas) {
         });
     }
     catch {
+        // Ignorar erros de traverse para não quebrar a análise
     }
 }
 function mapearSeveridadeParaNivel(severidade) {
@@ -353,4 +412,3 @@ function mapearSeveridadeParaNivel(severidade) {
             return 'info';
     }
 }
-//# sourceMappingURL=detector-security.js.map