@mocoto/mahoraga 0.14.0 → 0.14.2

package/dist/analysts/js-ts/analysts/analyst-functions-long.js

@@ -1,34 +1,37 @@
 import * as textoTitulo from '@babel/types';
-import { config, traverse } from '../../../core/config/index.js';
 import { detectarContextoProjeto } from '../../../shared/index.js';
+import { config, traverse } from '../../../core/config/index.js';
 import { criarAnalista, criarOcorrencia, isBabelNode } from '../../../types/index.js';
 function isNodePath(x) {
     return typeof x === 'object' && x !== null && 'node' in x && isBabelNode(x.node) && typeof x.traverse === 'function';
 }
-const LIMITE_LINHAS = config.ANALISE_LIMITES?.FUNCOES_LONGAS?.MAX_LINHAS ?? 30;
-const LIMITE_PARAMETROS = config.ANALISE_LIMITES?.FUNCOES_LONGAS?.MAX_PARAMETROS ?? 4;
-const LIMITE_ANINHAMENTO = config.ANALISE_LIMITES?.FUNCOES_LONGAS?.MAX_ANINHAMENTO ?? 3;
+const LIMITE_LINHAS = config.ANALISE_LIMITES.FUNCOES_LONGAS.MAX_LINHAS;
+const LIMITE_PARAMETROS = config.ANALISE_LIMITES.FUNCOES_LONGAS.MAX_PARAMETROS;
+const LIMITE_ANINHAMENTO = config.ANALISE_LIMITES.FUNCOES_LONGAS.MAX_ANINHAMENTO;
 const LIMITE_COMPLEXIDADE_COGNITIVA = 15;
 const LIMITE_RESPONSABILIDADES = 3;
 const LIMITE_CICLOMATICA = 10;
 function pushOcorrencia(ocorrencias, tipo, nivel, relPath, linha, mensagem) {
-    ocorrencias.push(criarOcorrencia({ tipo: tipo, nivel, relPath, linha, mensagem, origem: 'analista-funcoes-longas' }));
+    ocorrencias.push(criarOcorrencia({ tipo, nivel, relPath, linha, mensagem, origem: 'analista-funcoes-longas' }));
 }
 function locValido(loc) {
-    if (!loc || typeof loc !== 'object')
+    if (!loc || typeof loc !== 'object') {
         return false;
+    }
     const s = loc.start;
     const e = loc.end;
-    if (!s || typeof s !== 'object' || !e || typeof e !== 'object')
+    if (!s || typeof s !== 'object' || !e || typeof e !== 'object') {
         return false;
+    }
     const sl = s.line;
     const el = e.line;
     return typeof sl === 'number' && typeof el === 'number' && sl >= 1 && el >= sl;
 }
 function calcularComplexidadeCognitiva(body) {
     const state = { score: 0, depth: 0 };
-    if (!body || typeof body !== 'object')
+    if (!body || typeof body !== 'object') {
         return 0;
+    }
     try {
         traverse(body, {
             IfStatement(path) {
@@ -56,8 +59,9 @@ function calcularComplexidadeCognitiva(body) {
     return state.score;
 }
 function calcularCiclomatica(body) {
-    if (!body || typeof body !== 'object')
+    if (!body || typeof body !== 'object') {
         return 1;
+    }
     let score = 1;
     try {
         traverse(body, {
@@ -69,13 +73,15 @@ function calcularCiclomatica(body) {
             WhileStatement() { score++; },
             DoWhileStatement() { score++; },
             SwitchCase(path) {
-                if (!path.node.consequent || path.node.consequent.length === 0)
+                if (path.node.consequent.length === 0) {
                     return;
+                }
                 score++;
             },
             LogicalExpression(path) {
-                if (path.node.operator === '||' || path.node.operator === '&&')
+                if (path.node.operator === '||' || path.node.operator === '&&') {
                     score++;
+                }
             },
             CatchClause() { score++; },
         });
@@ -114,9 +120,9 @@ function verificarEarlyReturn(fn) {
         traverse(paraNode(fn), {
             ReturnStatement(path) {
                 const fnParent = path.getFunctionParent();
-                if (fnParent && fnParent.node === fn) {
+                if (fnParent?.node === fn) {
                     const grandParent = path.parentPath;
-                    if (grandParent && textoTitulo.isIfStatement(grandParent.node)) {
+                    if (textoTitulo.isIfStatement(grandParent.node)) {
                         encontrouEarlyReturn = true;
                     }
                 }
@@ -158,8 +164,9 @@ function verificarAninhamentoExcessivo(fn, maxNesting) {
     return maxDepth > maxNesting;
 }
 function verificarFuncao(fn, limitesAjustados, contextoArquivo, aninhamento, ocorrencias, relPath) {
-    if (!locValido(fn.loc))
+    if (!locValido(fn.loc)) {
         return;
+    }
     const startLine = fn.loc.start.line;
     const endLine = fn.loc.end.line;
     const linhas = endLine - startLine + 1;
@@ -174,7 +181,7 @@ function verificarFuncao(fn, limitesAjustados, contextoArquivo, aninhamento, oco
     if (aninhamento > limitesAjustados.aninhamento) {
         pushOcorrencia(ocorrencias, 'FUNCAO_ANINHADA', 'aviso', relPath, startLine, `Função aninhada em nível ${aninhamento} (máx: ${limitesAjustados.aninhamento})`);
     }
-    const semComentario = fn.leadingComments == null || (Array.isArray(fn.leadingComments) && fn.leadingComments.length === 0);
+    const semComentario = fn.leadingComments === null || (Array.isArray(fn.leadingComments) && fn.leadingComments.length === 0);
     if (semComentario && !contextoArquivo.isTest) {
         pushOcorrencia(ocorrencias, 'FUNCAO_SEM_COMENTARIO', 'info', relPath, startLine, 'Função sem comentário acima.');
     }
@@ -201,14 +208,15 @@ function verificarFuncao(fn, limitesAjustados, contextoArquivo, aninhamento, oco
 const TIPOS_FUNCAO = new Set(['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression']);
 function criarVisitors(analisarRecursivo, aninhamento) {
     return {
-        FunctionDeclaration: (caminho) => analisarRecursivo(caminho, aninhamento + 1),
-        FunctionExpression: (caminho) => analisarRecursivo(caminho, aninhamento + 1),
-        ArrowFunctionExpression: (caminho) => analisarRecursivo(caminho, aninhamento + 1),
+        FunctionDeclaration: (caminho) => { analisarRecursivo(caminho, aninhamento + 1); },
+        FunctionExpression: (caminho) => { analisarRecursivo(caminho, aninhamento + 1); },
+        ArrowFunctionExpression: (caminho) => { analisarRecursivo(caminho, aninhamento + 1); },
     };
 }
 function extrairFileNode(fileAst) {
-    if (!fileAst || typeof fileAst !== 'object')
+    if (!fileAst || typeof fileAst !== 'object') {
         return null;
+    }
     try {
         const maybeNode = fileAst.node;
         if (maybeNode && typeof maybeNode === 'object' && Array.isArray(maybeNode.body)) {
@@ -231,11 +239,13 @@ function verificarFuncoesDoBody(body, limitesAjustados, contextoArquivo, ocorren
     }
 }
 function processarFileAst(fileAst, limitesAjustados, contextoArquivo, ocorrencias, relPath) {
-    if (!fileAst)
+    if (!fileAst) {
         return ocorrencias;
+    }
     const fileNode = extrairFileNode(fileAst);
-    if (!fileNode)
+    if (!fileNode) {
         return ocorrencias;
+    }
     const body = Array.isArray(fileNode.body) ? fileNode.body : [];
     verificarFuncoesDoBody(body, limitesAjustados, contextoArquivo, ocorrencias, relPath);
     return ocorrencias;
@@ -281,4 +291,3 @@ export const analistaFuncoesLongas = criarAnalista({
     test: (relPath) => relPath.endsWith('.js') || relPath.endsWith('.ts'),
     global: false
 });
-//# sourceMappingURL=analyst-functions-long.js.map

package/dist/analysts/js-ts/analysts/analyst-patterns-usage.js

@@ -1,7 +1,7 @@
 import * as textoTitulo from '@babel/types';
+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 { garantirArray, incrementar } from '../../../shared/helpers/index.js';
 import { criarOcorrencia, ocorrenciaErroAnalista } from '../../../types/index.js';
 export const estatisticasUsoGlobal = {
@@ -33,7 +33,7 @@ export const analistaPadroesUso = {
                 origem: data.origem,
                 tipo: data.tipo,
                 mensagem: data.mensagem,
-                relPath: data.arquivo || data.relPath,
+                relPath: data.arquivo ?? data.relPath,
                 linha: data.linha,
                 coluna: data.coluna
             }));
@@ -51,16 +51,18 @@ export const analistaPadroesUso = {
         }
         let astWrap = astInput;
         if (!astWrap && contexto?.arquivos) {
-            const found = contexto.arquivos?.find((arquivo) => arquivo.relPath === relPath) || contexto.arquivos?.[0];
-            astWrap = found?.ast || undefined;
+            const found = contexto.arquivos?.find((arquivo) => arquivo.relPath === relPath) ?? contexto.arquivos[0];
+            astWrap = found.ast ?? undefined;
         }
         const hasNodeProp = (valor) => typeof valor === 'object' && valor !== null && 'node' in valor;
         const ast = (astWrap && (hasNodeProp(astWrap) ? astWrap.node : astWrap));
-        if (!ast || typeof ast !== 'object')
+        if (!ast || typeof ast !== 'object') {
             return null;
-        const tipo = ast.type;
-        if (tipo !== 'File' && tipo !== 'Program')
+        }
+        const tipo = (ast).type;
+        if (tipo !== 'File' && tipo !== 'Program') {
             return null;
+        }
         let nonNullCount = 0;
         const stringCounts = new Map();
         const magicStringCandidates = new Map();
@@ -111,6 +113,7 @@ export const analistaPadroesUso = {
                     if ((node.type === 'ClassProperty' || node.type === 'PropertyDefinition') && 'value' in node && textoTitulo.isArrowFunctionExpression(node.value) && !contextoArquivo.isTest) {
                         push({ tipo: 'info', mensagem: messages.PadroesUsoMensagens.arrowAsClassMethod, relPath, linha: node.loc?.start.line, coluna: node.loc?.start.column });
                     }
+                    // ts-expect-error / ts-ignore detection
                     if (node.leadingComments) {
                         for (const comment of node.leadingComments) {
                             if (comment.value.includes('@ts-ignore')) {
@@ -118,26 +121,31 @@ export const analistaPadroesUso = {
                             }
                         }
                     }
+                    // Non-null assertion ! count
                     if (textoTitulo.isTSNonNullExpression(node)) {
                         nonNullCount++;
                         if (nonNullCount > 3) {
                             push({ tipo: 'aviso', mensagem: messages.PadroesUsoMensagens.nonNullAssertion(nonNullCount), relPath, linha: node.loc?.start.line, coluna: node.loc?.start.column, nivel: 'aviso' });
                         }
                     }
+                    // Type assertion as Type without validation
                     if (textoTitulo.isTSAsExpression(node)) {
-                        const parent = path.parentPath?.node;
-                        if (parent && !textoTitulo.isVariableDeclarator(parent)) {
+                        const parent = path.parentPath.node;
+                        if (!textoTitulo.isVariableDeclarator(parent)) {
                             push({ tipo: 'info', mensagem: messages.PadroesUsoMensagens.typeAssertionWithoutValidation, relPath, linha: node.loc?.start.line, coluna: node.loc?.start.column, nivel: 'info' });
                         }
                     }
+                    // || vs ?? misuse
                     if (textoTitulo.isLogicalExpression(node) && node.operator === '||') {
                         if (textoTitulo.isStringLiteral(node.left) || textoTitulo.isNumericLiteral(node.left)) {
                             push({ tipo: 'info', mensagem: messages.PadroesUsoMensagens.orVsNullishMisuse, relPath, linha: node.loc?.start.line, coluna: node.loc?.start.column, nivel: 'info' });
                         }
                     }
+                    // console.log detection
                     if (textoTitulo.isCallExpression(node) && textoTitulo.isMemberExpression(node.callee) && textoTitulo.isIdentifier(node.callee.object) && node.callee.object.name === 'console' && textoTitulo.isIdentifier(node.callee.property) && (node.callee.property.name === 'log' || node.callee.property.name === 'warn')) {
                         push({ tipo: 'alerta', mensagem: messages.PadroesUsoMensagens.consoleLog, relPath, linha: node.loc?.start.line, coluna: node.loc?.start.column, nivel: 'aviso' });
                     }
+                    // non-arrow callback where arrow would be better
                     if (textoTitulo.isCallExpression(node) && textoTitulo.isMemberExpression(node.callee)) {
                         const prop = node.callee.property;
                         if (textoTitulo.isIdentifier(prop) && ['map', 'filter', 'reduce', 'forEach', 'find', 'some', 'every', 'flatMap'].includes(prop.name)) {
@@ -148,28 +156,35 @@ export const analistaPadroesUso = {
                             }
                         }
                     }
+                    // Useless conditionals: if (x === true), if (x === false), x === true ? ... : ...
                     if (textoTitulo.isIfStatement(node) && textoTitulo.isBinaryExpression(node.test)) {
                         const bin = node.test;
                         if ((bin.operator === '===' || bin.operator === '==') && textoTitulo.isBooleanLiteral(bin.right)) {
                             push({ tipo: 'info', mensagem: messages.PadroesUsoMensagens.uselessConditional, relPath, linha: node.loc?.start.line, coluna: node.loc?.start.column, nivel: 'info' });
                         }
                     }
+                    // satisfies keyword usage (TypeScript 4.9+)
+                    if (textoTitulo.isTSSatisfiesExpression(node)) {
+                        push({ tipo: 'info', mensagem: messages.PadroesUsoMensagens.satisfiesUsage, relPath, linha: node.loc?.start.line, coluna: node.loc?.start.column, nivel: 'info' });
+                    }
                 }
             });
+            // Magic strings detection (via text scan)
             const stringRegex = /['"`]([a-zA-Z_][a-zA-Z0-9_-]{2,})['"`]/g;
             let m;
             while ((m = stringRegex.exec(src)) !== null) {
                 const str = m[1];
                 if (str.length >= 3 && !['let', 'var', 'const', 'for', 'if', 'else', 'return', 'import', 'export', 'function', 'class', 'new', 'this', 'typeof', 'delete', 'void', 'null', 'true', 'false', 'undefined', 'NaN', 'Infinity'].includes(str)) {
-                    stringCounts.set(str, (stringCounts.get(str) || 0) + 1);
+                    stringCounts.set(str, (stringCounts.get(str) ?? 0) + 1);
                     if (!magicStringCandidates.has(str)) {
                         const lineNum = src.substring(0, m.index).split('\n').length;
                         magicStringCandidates.set(str, { count: 1, linha: lineNum });
                     }
                     else {
                         const existing = magicStringCandidates.get(str);
-                        if (existing)
+                        if (existing) {
                             existing.count++;
+                        }
                     }
                 }
             }
@@ -189,4 +204,3 @@ export const analistaPadroesUso = {
         return garantirArray(ocorrencias);
     }
 };
-//# sourceMappingURL=analyst-patterns-usage.js.map

package/dist/analysts/js-ts/analysts/analyst-todo-comments.js

@@ -1,7 +1,11 @@
-import { messages } from '../../../core/messages/index.js';
 import { detectarContextoProjeto } from '../../../shared/index.js';
+import { messages } from '../../../core/messages/index.js';
 import { detectarComentariosPendentes } from '../../../shared/helpers/index.js';
 import { criarOcorrencia } from '../../../types/index.js';
+/**
+ * Analista para detectar TODO e FIXME em comentários.
+ * Utiliza helpers compartilhados para busca consistente em todo o projeto.
+ */
 export const analistaTodoComentarios = {
     nome: 'todo-comments',
     categoria: 'qualidade',
@@ -16,22 +20,26 @@ export const analistaTodoComentarios = {
         if (contextoArquivo.isTest || contextoArquivo.isConfiguracao || contextoArquivo.frameworks.includes('types')) {
             return false;
         }
-        if (/analistas[\\\/]analista-todo-comments\.(ts|js)$/i.test(relPath))
+        if (/analistas[\\\/]analista-todo-comments\.(ts|js)$/i.test(relPath)) {
             return false;
+        }
         return /\.(ts|js|tsx|jsx)$/i.test(relPath);
     },
     aplicar(src, relPath, _ast) {
-        if (!src || typeof src !== 'string')
+        if (!src || typeof src !== 'string') {
             return null;
+        }
         const contextoArquivo = detectarContextoProjeto({
             arquivo: relPath,
             conteudo: src,
             relPath
         });
         const nivelTodo = contextoArquivo.isLibrary ? 'aviso' : 'info';
+        // Utiliza helper compartilhado para detecção robusta
         const todos = detectarComentariosPendentes(src);
-        if (todos.length === 0)
+        if (todos.length === 0) {
             return null;
+        }
         return todos.map(todo => criarOcorrencia({
             tipo: 'TODO-pendente',
             mensagem: messages.TodoComentariosMensagens.todoOrFixmeFound(todo.tipo === 'FIXME' ? 'FIXME' : 'TODO', todo.texto.substring(0, 50)),
@@ -42,4 +50,3 @@ export const analistaTodoComentarios = {
         }));
     }
 };
-//# sourceMappingURL=analyst-todo-comments.js.map

package/dist/analysts/js-ts/analysts/index.js

@@ -1,5 +1,8 @@
+// SPDX-License-Identifier: MIT
+/**
+ * @fileoverview Analistas de JavaScript/TypeScript
+ */
 export * from './analyst-commands-cli.js';
 export * from './analyst-functions-long.js';
 export * from './analyst-patterns-usage.js';
 export * from './analyst-todo-comments.js';
-//# sourceMappingURL=index.js.map

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

@@ -20,11 +20,11 @@ const visitorAsync = {
                 if (binding && binding.path.isFunction() && !binding.path.node.async) {
                     return;
                 }
-                const occurrences = state.ocorrencias || [];
+                const occurrences = state.ocorrencias;
                 occurrences.push({
                     tipo: 'floating-promise',
-                    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: 'media',
                     nivel: 'aviso',
                     mensagem: messages.DetectorJsTsMensagens.floatingPromise(funcName),
@@ -40,14 +40,14 @@ const visitorAsync = {
             const propName = prop.type === 'Identifier' ? prop.name : '';
             if (propName === 'map' || propName === 'forEach') {
                 const arg = path.node.arguments[0];
-                if (arg && (arg.type === 'ArrowFunctionExpression' || arg.type === 'FunctionExpression')) {
+                if (arg.type === 'ArrowFunctionExpression' || arg.type === 'FunctionExpression') {
                     if (arg.async) {
                         const isForEach = propName === 'forEach';
-                        const occurrences = state.ocorrencias || [];
+                        const occurrences = state.ocorrencias;
                         occurrences.push({
                             tipo: isForEach ? 'async-in-foreach' : 'async-in-map-without-all',
-                            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: 'alta',
                             nivel: 'erro',
                             mensagem: isForEach ? messages.DetectorJsTsMensagens.asyncInForEach(propName) : messages.DetectorJsTsMensagens.asyncInMap(propName),
@@ -56,13 +56,14 @@ const visitorAsync = {
                     }
                 }
             }
+            // Promise.all().then() without error handling
             if (propName === 'then' && textoTitulo.isCallExpression(callee.object) && textoTitulo.isMemberExpression(callee.object.callee)) {
                 const innerProp = callee.object.callee.property;
                 if (textoTitulo.isIdentifier(innerProp) && innerProp.name === 'all') {
-                    const _hasCatch = path.parentPath && textoTitulo.isCallExpression(path.parentPath.node) && path.parentPath.node.arguments.length > 0;
+                    const _hasCatch = textoTitulo.isCallExpression(path.parentPath.node) && path.parentPath.node.arguments.length > 0;
                     let hasErrorHandler = false;
                     try {
-                        path.parentPath?.traverse({
+                        path.parentPath.traverse({
                             CallExpression(p) {
                                 if (textoTitulo.isMemberExpression(p.node.callee) && textoTitulo.isIdentifier(p.node.callee.property) && p.node.callee.property.name === 'catch') {
                                     hasErrorHandler = true;
@@ -71,11 +72,12 @@ const visitorAsync = {
                         });
                     }
                     catch { }
-                    if (!hasErrorHandler) {
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-boolean-literal-compare, @typescript-eslint/no-unnecessary-condition
+                    if (hasErrorHandler === false) {
                         state.ocorrencias.push({
                             tipo: 'promise-all-no-error',
-                            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: 'alta',
                             nivel: 'aviso',
                             mensagem: messages.DetectorJsTsMensagens.promiseAllWithoutErrorHandling,
@@ -84,21 +86,22 @@ const visitorAsync = {
                     }
                 }
             }
+            // Promise nesting: .then() inside .then()
             if (propName === 'then') {
                 const arg = path.node.arguments[0];
-                if (arg && (arg.type === 'ArrowFunctionExpression' || arg.type === 'FunctionExpression')) {
+                if (arg.type === 'ArrowFunctionExpression' || arg.type === 'FunctionExpression') {
                     const body = arg.body;
-                    if (body && body.type === 'BlockStatement') {
+                    if (body.type === 'BlockStatement') {
                         for (const stmt of body.body) {
-                            if (stmt.type === 'ReturnStatement' && stmt.argument && stmt.argument.type === 'CallExpression') {
+                            if (stmt.type === 'ReturnStatement' && stmt.argument?.type === 'CallExpression') {
                                 const retCall = stmt.argument;
                                 if (retCall.callee.type === 'MemberExpression') {
                                     const retProp = retCall.callee.property;
-                                    if (retProp && retProp.type === 'Identifier' && retProp.name === 'then') {
+                                    if (retProp?.type === 'Identifier' && retProp.name === 'then') {
                                         state.ocorrencias.push({
                                             tipo: 'promise-nesting',
-                                            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: 'media',
                                             nivel: 'info',
                                             mensagem: messages.DetectorJsTsMensagens.promiseNesting,
@@ -112,17 +115,20 @@ const visitorAsync = {
                 }
             }
         }
+        // @mahoraga-disable ml-unhandled-promise
+        // Justificativa: O detector analisa uso de Promise em AST, não cria promises
+        // Promise constructor anti-pattern: new Promise((resolve, reject) => { ... })
         if (callee.type === 'Identifier' && callee.name === 'Promise' && path.node.arguments.length === 1) {
             const executor = path.node.arguments[0];
-            if (executor && (executor.type === 'ArrowFunctionExpression' || executor.type === 'FunctionExpression')) {
+            if (executor.type === 'ArrowFunctionExpression' || executor.type === 'FunctionExpression') {
                 const executorBody = executor.type === 'ArrowFunctionExpression' ? executor.body : executor.body;
-                if (executorBody && executorBody.type === 'BlockStatement') {
+                if (executorBody.type === 'BlockStatement') {
                     for (const stmt of executorBody.body) {
                         if (stmt.type === 'ExpressionStatement' && stmt.expression.type === 'CallExpression') {
                             state.ocorrencias.push({
                                 tipo: 'promise-constructor-anti-pattern',
-                                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: 'media',
                                 nivel: 'aviso',
                                 mensagem: messages.DetectorJsTsMensagens.promiseConstructorAntiPattern,
@@ -134,11 +140,13 @@ const visitorAsync = {
                 }
             }
         }
-        if (callee.type === 'Identifier' && path.parentPath && textoTitulo.isReturnStatement(path.parentPath.node)) {
+        // return await misuse (outside try/catch)
+        if (callee.type === 'Identifier' && textoTitulo.isReturnStatement(path.parentPath.node)) {
             const fnParent = path.getFunctionParent();
             if (fnParent) {
                 let inTryCatch = false;
                 let current = path.parentPath;
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
                 while (current) {
                     if (textoTitulo.isTryStatement(current.node)) {
                         inTryCatch = true;
@@ -149,8 +157,8 @@ const visitorAsync = {
                 if (!inTryCatch) {
                     state.ocorrencias.push({
                         tipo: 'return-await-misuse',
-                        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',
                         nivel: 'info',
                         mensagem: messages.DetectorJsTsMensagens.returnAwaitMisuse,
@@ -161,14 +169,15 @@ const visitorAsync = {
         }
     },
     AwaitExpression(path, state) {
-        const currentLine = path.node.loc?.start.line || 0;
+        // Track consecutive independent awaits for Promise.all suggestion
+        const currentLine = path.node.loc?.start.line ?? 0;
         if (state.lastAwaitLine > 0 && currentLine - state.lastAwaitLine <= 2) {
             state.consecutiveAwaits++;
             if (state.consecutiveAwaits >= 2) {
                 state.ocorrencias.push({
                     tipo: 'missing-promise-all',
                     linha: currentLine,
-                    coluna: path.node.loc?.start.column || 0,
+                    coluna: path.node.loc?.start.column ?? 0,
                     severidade: 'media',
                     nivel: 'info',
                     mensagem: messages.DetectorJsTsMensagens.missingPromiseAll(state.consecutiveAwaits + 1),
@@ -181,7 +190,23 @@ const visitorAsync = {
         }
         state.lastAwaitLine = currentLine;
     },
+    // Top-level await and for-await-of detection via text fallback
+    // These are checked in the aplicar method
+    ForOfStatement(path, state) {
+        if (path.node.await) {
+            state.ocorrencias.push({
+                tipo: 'for-await-of',
+                linha: path.node.loc?.start.line ?? 0,
+                coluna: path.node.loc?.start.column ?? 0,
+                severidade: 'baixa',
+                nivel: 'info',
+                mensagem: messages.DetectorJsTsMensagens.forAwaitOf,
+                relPath: state.relPath
+            });
+        }
+    },
     Function(path, state) {
+        // Async function without await
         if (path.node.async) {
             let hasAwait = false;
             try {
@@ -190,11 +215,12 @@ const visitorAsync = {
                 });
             }
             catch { }
-            if (!hasAwait) {
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-boolean-literal-compare, @typescript-eslint/no-unnecessary-condition
+            if (hasAwait === false) {
                 state.ocorrencias.push({
                     tipo: 'async-without-await',
-                    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',
                     nivel: 'info',
                     mensagem: messages.DetectorJsTsMensagens.asyncWithoutAwait,
@@ -205,19 +231,24 @@ const visitorAsync = {
     }
 };
 function getFunctionName(node) {
-    if (node.type === 'Identifier')
+    if (node.type === 'Identifier') {
         return node.name;
-    if (node.type === 'MemberExpression' && node.property.type === 'Identifier')
+    }
+    if (node.type === 'MemberExpression' && node.property.type === 'Identifier') {
         return node.property.name;
+    }
     return null;
 }
 function isProbablyAsync(name) {
-    if (/^(fetch|request|axios|prisma|db\.|database\.|api\.)/.test(name))
+    if (/^(fetch|request|axios|prisma|db\.|database\.|api\.)/.test(name)) {
         return true;
-    if (/Async$/.test(name))
+    }
+    if (/Async$/.test(name)) {
         return true;
-    if (['fetch', 'axios', 'insert', 'mutate', 'query', 'save', 'load'].includes(name))
+    }
+    if (['fetch', 'axios', 'insert', 'mutate', 'query', 'save', 'load'].includes(name)) {
         return true;
+    }
     return false;
 }
 export const analistaAntiPadroesAsync = {
@@ -228,9 +259,10 @@ export const analistaAntiPadroesAsync = {
     test: (relPath) => {
         return /\.(js|jsx|ts|tsx)$/.test(relPath) && !/\.test\.(ts|js)$/.test(relPath);
     },
-    aplicar: async (src, relPath, ast) => {
-        if (!ast)
+    aplicar: (src, relPath, ast) => {
+        if (!ast) {
             return [];
+        }
         if (shouldSuppressOccurrence('anti-padroes-async', relPath)) {
             return [];
         }
@@ -242,14 +274,67 @@ export const analistaAntiPadroesAsync = {
         };
         const nodeToTraverse = ('node' in ast ? ast.node : ast);
         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 fnParentLines = new Set();
+            const fnVisitor = {
+                Function(path) {
+                    if (path.node.loc) {
+                        for (let i = path.node.loc.start.line; i <= path.node.loc.end.line; i++) {
+                            fnParentLines.add(i);
+                        }
+                    }
+                }
+            };
+            traverse(nodeToTraverse, fnVisitor, undefined, {});
+            if (!fnParentLines.has(topLevelAwaitLine)) {
+                stateObj.ocorrencias.push({
+                    tipo: 'top-level-await',
+                    linha: topLevelAwaitLine,
+                    coluna: 0,
+                    severidade: 'baixa',
+                    nivel: 'info',
+                    mensagem: messages.DetectorJsTsMensagens.topLevelAwait,
+                    relPath
+                });
+            }
+        }
+        // Promise.withResolvers detection via text
+        if (/Promise\.withResolvers\s*\(/g.test(src)) {
+            const match = /Promise\.withResolvers\s*\(/g.exec(src);
+            const linha = match ? src.substring(0, match.index).split('\n').length : 1;
+            stateObj.ocorrencias.push({
+                tipo: 'promise-with-resolvers',
+                linha,
+                coluna: 0,
+                severidade: 'baixa',
+                nivel: 'info',
+                mensagem: messages.DetectorJsTsMensagens.promiseWithResolvers,
+                relPath
+            });
+        }
+        // Promise.allSettled detection
+        if (/Promise\.allSettled\s*\(/g.test(src)) {
+            const match = /Promise\.allSettled\s*\(/g.exec(src);
+            const linha = match ? src.substring(0, match.index).split('\n').length : 1;
+            stateObj.ocorrencias.push({
+                tipo: 'promise-all-settled',
+                linha,
+                coluna: 0,
+                severidade: 'baixa',
+                nivel: 'info',
+                mensagem: messages.DetectorJsTsMensagens.promiseAllSettled,
+                relPath
+            });
+        }
         return stateObj.ocorrencias.map(ocorrencia => criarOcorrencia({
             tipo: ocorrencia.tipo ?? 'anti-padroes-async',
-            nivel: ocorrencia.nivel || 'aviso',
+            nivel: ocorrencia.nivel ?? 'aviso',
             mensagem: ocorrencia.mensagem,
-            linha: ocorrencia.linha || 0,
+            linha: ocorrencia.linha ?? 0,
             relPath,
             origem: 'anti-padroes-async'
         }));
     }
 };
-//# sourceMappingURL=detector-anti-patterns-async.js.map