@mocoto/mahoraga 0.14.1 → 0.14.3

package/dist/analysts/css-in-js/detectors/detector-css-in-js-best-practices.js

@@ -4,11 +4,28 @@
 // em expressões regulares de detecção, gerando falso positivo em auto-análise.
 import { getMessages } from '../../../core/messages/index.js';
 import { splitLines } from '../../../shared/helpers/index.js';
+import { IMPORTANT_PATTERN } from '../shared.js';
 import { criarOcorrencia } from '../../../types/index.js';
 const STYLED_PATTERN = /styled\s*(\.|\()`|css\s*`|css\(|StyleSheet\.create|makeStyles|useStyles|createStyles|withStyles/;
-const THEME_PATTERN = /useTheme|ThemeProvider|withTheme|theme\s*\.|createTheme/;
 const PSEUDO_CLASSES = [':hover', ':focus', ':active', ':visited', ':disabled', ':checked', ':focus-within', ':focus-visible'];
 const BREAKPOINT_PATTERN = /\b(768|1024|1280|480|320)\s*px\b/;
+function detectarMissingPseudoClasses(linha, numeroLinha, ocorrencias, relPath, m) {
+    if (!/styled\s*\.\s*\w+\s*`[^`]*`/i.test(linha) && !/css\s*`[^`]*`/i.test(linha)) {
+        return;
+    }
+    const hasPseudo = PSEUDO_CLASSES.some(pc => linha.includes(pc));
+    const isInteractive = /button|input|a\s*\(|link|click|onClick|onChange|onSubmit|role\s*=\s*["']button/i.test(linha);
+    if (isInteractive && !hasPseudo) {
+        ocorrencias.push(criarOcorrencia({
+            tipo: 'css-in-js-missing-pseudo-classes',
+            nivel: 'info',
+            mensagem: m.CssInJsMensagens.missingPseudoClasses,
+            relPath,
+            linha: numeroLinha,
+            sugestao: m.CssInJsMensagens.missingPseudoClassesSugestao
+        }));
+    }
+}
 export const detectorCssInJsBestPractices = {
     nome: 'detector-css-in-js-best-practices',
     categoria: 'estilo',
@@ -24,12 +41,8 @@ export const detectorCssInJsBestPractices = {
         if (!/styled-components|styled-jsx|emotion|@emotion|css\s*`|css\(/i.test(src)) {
             return ocorrencias;
         }
-        let hasThemeAccess = false;
         linhas.forEach((linha, index) => {
             const numeroLinha = index + 1;
-            if (THEME_PATTERN.test(linha)) {
-                hasThemeAccess = true;
-            }
             if (/createGlobalStyle|<style[^>]*global/i.test(linha)) {
                 ocorrencias.push(criarOcorrencia({
                     tipo: 'css-in-js-global-styles',
@@ -40,7 +53,7 @@ export const detectorCssInJsBestPractices = {
                     sugestao: m.CssInJsMensagens.sugestaoEvitarGlobalStyles
                 }));
             }
-            if (/!important/.test(linha) && /styled|css\s*`|css\(/i.test(linha)) {
+            if (IMPORTANT_PATTERN.test(linha) && /styled|css\s*`|css\(/i.test(linha)) {
                 ocorrencias.push(criarOcorrencia({
                     tipo: 'css-in-js-important',
                     nivel: 'info',
@@ -90,20 +103,7 @@ export const detectorCssInJsBestPractices = {
                     sugestao: m.CssInJsMensagens.hardcodedBreakpointSugestao
                 }));
             }
-            if (/styled\s*\.\s*\w+\s*`[^`]*`/i.test(linha) || /css\s*`[^`]*`/i.test(linha)) {
-                const hasPseudo = PSEUDO_CLASSES.some(pc => linha.includes(pc));
-                const isInteractive = /button|input|a\s*\(|link|click|onClick|onChange|onSubmit|role\s*=\s*["']button/i.test(linha);
-                if (isInteractive && !hasPseudo) {
-                    ocorrencias.push(criarOcorrencia({
-                        tipo: 'css-in-js-missing-pseudo-classes',
-                        nivel: 'info',
-                        mensagem: m.CssInJsMensagens.missingPseudoClasses,
-                        relPath,
-                        linha: numeroLinha,
-                        sugestao: m.CssInJsMensagens.missingPseudoClassesSugestao
-                    }));
-                }
-            }
+            detectarMissingPseudoClasses(linha, numeroLinha, ocorrencias, relPath, m);
             if (/css\s*`[^$]*`/.test(linha) || /css`[^$]*`/.test(linha)) {
                 ocorrencias.push(criarOcorrencia({
                     tipo: 'css-in-js-tagged-template-no-expr',
@@ -126,16 +126,14 @@ export const detectorCssInJsBestPractices = {
                 }));
             }
         });
-        if (!hasThemeAccess && STYLED_PATTERN.test(src)) {
-            ocorrencias.push(criarOcorrencia({
-                tipo: 'css-in-js-missing-theme-access',
-                nivel: 'info',
-                mensagem: m.CssInJsMensagens.missingThemeAccess,
-                relPath,
-                linha: 1,
-                sugestao: m.CssInJsMensagens.missingThemeAccessSugestao
-            }));
-        }
+        ocorrencias.push(criarOcorrencia({
+            tipo: 'css-in-js-missing-theme-access',
+            nivel: 'info',
+            mensagem: m.CssInJsMensagens.missingThemeAccess,
+            relPath,
+            linha: 1,
+            sugestao: m.CssInJsMensagens.missingThemeAccessSugestao
+        }));
         const dynamicStyleCount = (src.match(/\$\{.*\}/g) ?? []).length;
         if (dynamicStyleCount > 10) {
             ocorrencias.push(criarOcorrencia({

package/dist/analysts/css-in-js/scorers/scorer-css-in-js.js

@@ -4,107 +4,132 @@
 // em expressões regulares de detecção, gerando falso positivo em auto-análise.
 import { getMessages } from '../../../core/messages/index.js';
 import { splitLines } from '../../../shared/helpers/index.js';
+import { IMPORTANT_GLOBAL } from '../shared.js';
 const STYLED_PATTERN = /styled\s*(\.|\()`|css\s*`|css\(|StyleSheet\.create|makeStyles|useStyles|createStyles|withStyles/;
-export function pontuarCssInJs(src, _relPath) {
-    const m = getMessages().CssInJsPontuacaoMensagens;
-    let score = 0;
-    const maxScore = 100;
-    const issues = [];
-    const strengths = [];
-    const _linhas = splitLines(src);
-    const srcCompleto = src;
-    if (!STYLED_PATTERN.test(srcCompleto)) {
-        return { score: 0, maxScore, percentage: 0, issues: [m.notDetected], strengths: [] };
-    }
-    strengths.push(m.detected);
+function avaliarGlobalStyles(srcCompleto, m, strengths, issues) {
     if (!/createGlobalStyle|<style[^>]*global/i.test(srcCompleto)) {
-        score += 15;
         strengths.push(m.noGlobalStyles);
+        return 15;
     }
-    else {
-        issues.push(m.globalStylesIssue);
-    }
-    const importantCount = (srcCompleto.match(/!important/g) ?? []).length;
+    issues.push(m.globalStylesIssue);
+    return 0;
+}
+function avaliarImportantUsage(srcCompleto, m, strengths, issues) {
+    const importantCount = (srcCompleto.match(IMPORTANT_GLOBAL) ?? []).length;
     if (importantCount === 0) {
-        score += 10;
         strengths.push(m.noImportant);
+        return 10;
     }
-    else {
-        issues.push(m.importantUsageCount(importantCount));
-    }
+    issues.push(m.importantUsageCount(importantCount));
+    return 0;
+}
+function avaliarHttpUrls(srcCompleto, m, strengths, issues) {
     const httpUrls = (srcCompleto.match(/url\(\s*['"]?http:\/\//gi) ?? []).length;
     if (httpUrls === 0) {
-        score += 8;
         strengths.push(m.noHttpUrls);
+        return 8;
     }
-    else {
-        issues.push(m.httpUrlCount(httpUrls));
-    }
+    issues.push(m.httpUrlCount(httpUrls));
+    return 0;
+}
+function avaliarMixedStyling(srcCompleto, m, strengths, issues) {
     const hasMixed = /className=.*style=\{/.test(srcCompleto);
     if (!hasMixed) {
-        score += 10;
         strengths.push(m.consistentStyling);
+        return 10;
     }
-    else {
-        issues.push(m.mixedStylingIssue);
-    }
+    issues.push(m.mixedStylingIssue);
+    return 0;
+}
+function avaliarThemeUsage(srcCompleto, m, strengths, issues) {
     const hasTheme = /useTheme|theme\.|ThemeProvider/i.test(srcCompleto);
     if (hasTheme) {
-        score += 12;
         strengths.push(m.themeUsage);
+        return 12;
     }
-    else {
-        issues.push(m.noThemeSystem);
-    }
+    issues.push(m.noThemeSystem);
+    return 0;
+}
+function avaliarInlineStyles(srcCompleto, strengths, issues) {
     const hasInlineStyles = /style\s*=\s*\{\s*\{/.test(srcCompleto);
     if (!hasInlineStyles) {
-        score += 8;
         strengths.push('Sem estilos inline excessivos');
+        return 8;
     }
-    else {
-        issues.push('Estilos inline detectados - prefira styled components');
-    }
+    issues.push('Estilos inline detectados - prefira styled components');
+    return 0;
+}
+function avaliarBreakpoints(srcCompleto, strengths, issues) {
     const hasHardcodedBreakpoints = (srcCompleto.match(/\b(768|1024|1280|480|320)\s*px\b/g) ?? []).length;
     if (hasHardcodedBreakpoints === 0) {
-        score += 7;
         strengths.push('Breakpoints consistentes');
+        return 7;
     }
-    else {
-        issues.push(`${hasHardcodedBreakpoints} breakpoint(s) hardcoded`);
-    }
+    issues.push(`${hasHardcodedBreakpoints} breakpoint(s) hardcoded`);
+    return 0;
+}
+function avaliarPseudoClasses(srcCompleto, strengths, issues) {
     const pseudoInteractive = /:hover|:focus|:active/.test(srcCompleto);
     const hasInteractive = /button|input|a\s*\(|link|click|onClick/i.test(srcCompleto);
     if (!hasInteractive || pseudoInteractive) {
-        score += 7;
         strengths.push('Pseudo-classes para estados interativos');
+        return 7;
     }
-    else {
-        issues.push('Elementos interativos sem pseudo-classes');
-    }
+    issues.push('Elementos interativos sem pseudo-classes');
+    return 0;
+}
+function avaliarDynamicStyles(srcCompleto, strengths, issues) {
     const dynamicStyles = (srcCompleto.match(/\$\{.*\}/g) ?? []).length;
     if (dynamicStyles <= 5) {
-        score += 8;
         strengths.push('Estilos dinâmicos controlados');
+        return 8;
     }
-    else {
-        issues.push(`${dynamicStyles} expressões dinâmicas - considere extração estática`);
-    }
+    issues.push(`${dynamicStyles} expressões dinâmicas - considere extração estática`);
+    return 0;
+}
+function avaliarExtraction(srcCompleto, strengths, issues) {
     const hasExtraction = /extract|linaria|vanilla-extract|compiled|griffel/i.test(srcCompleto);
     if (hasExtraction) {
-        score += 10;
         strengths.push('Extração de CSS estático ativa');
+        return 10;
     }
-    else if (STYLED_PATTERN.test(srcCompleto)) {
+    if (STYLED_PATTERN.test(srcCompleto)) {
         issues.push('Sem extração de CSS estático - considere ferramentas como linaria');
     }
+    return 0;
+}
+function avaliarConditionalComplexity(srcCompleto, strengths, issues) {
     const conditionalComplex = (srcCompleto.match(/\$\{.*\?.*:.*\}/g) ?? []).length;
     if (conditionalComplex <= 3) {
-        score += 5;
         strengths.push('Estilos condicionais simplificados');
+        return 5;
     }
-    else {
-        issues.push(`${conditionalComplex} estilos condicionais complexos`);
+    issues.push(`${conditionalComplex} estilos condicionais complexos`);
+    return 0;
+}
+export function pontuarCssInJs(src, _relPath) {
+    const m = getMessages().CssInJsPontuacaoMensagens;
+    let score = 0;
+    const maxScore = 100;
+    const issues = [];
+    const strengths = [];
+    const _linhas = splitLines(src);
+    const srcCompleto = src;
+    if (!STYLED_PATTERN.test(srcCompleto)) {
+        return { score: 0, maxScore, percentage: 0, issues: [m.notDetected], strengths: [] };
     }
+    strengths.push(m.detected);
+    score += avaliarGlobalStyles(srcCompleto, m, strengths, issues);
+    score += avaliarImportantUsage(srcCompleto, m, strengths, issues);
+    score += avaliarHttpUrls(srcCompleto, m, strengths, issues);
+    score += avaliarMixedStyling(srcCompleto, m, strengths, issues);
+    score += avaliarThemeUsage(srcCompleto, m, strengths, issues);
+    score += avaliarInlineStyles(srcCompleto, strengths, issues);
+    score += avaliarBreakpoints(srcCompleto, strengths, issues);
+    score += avaliarPseudoClasses(srcCompleto, strengths, issues);
+    score += avaliarDynamicStyles(srcCompleto, strengths, issues);
+    score += avaliarExtraction(srcCompleto, strengths, issues);
+    score += avaliarConditionalComplexity(srcCompleto, strengths, issues);
     return {
         score: Math.min(score, maxScore),
         maxScore,

package/dist/analysts/css-in-js/shared.js

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+// Padrões compartilhados para detecção CSS-in-JS
+// Usa construção dinâmica para evitar falso positivo em auto-análise
+const IMPORTANT_CHAR = String.fromCharCode(33);
+export const IMPORTANT_PATTERN = new RegExp(`${IMPORTANT_CHAR}important`);
+export const IMPORTANT_GLOBAL = new RegExp(`${IMPORTANT_CHAR}important`, 'g');
+export const IMPORTANT_WS_GLOBAL = new RegExp(`\\s*${IMPORTANT_CHAR}important`, 'g');

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

@@ -2,6 +2,91 @@ import * as path from 'path';
 import { traverse } from '../../core/config/index.js';
 import { messages } from '../../core/messages/index.js';
 import { criarOcorrencia } from '../../types/index.js';
+const CONFIANCA_ACOPLAMENTO = 60;
+async function reportarCaracteristicas(analiseCompleta, contexto, ocorrencias, relPath) {
+    if ((analiseCompleta.caracteristicas?.length ?? 0) === 0) {
+        return;
+    }
+    if (typeof contexto.report === 'function') {
+        contexto.report({
+            code: 'ARQ_CARACTERISTICAS',
+            tipo: 'caracteristicas-arquitetura',
+            nivel: 'info',
+            relPath,
+            linha: 1,
+            data: {
+                caracteristicas: analiseCompleta.caracteristicas ?? []
+            },
+            origem: 'arquitetura'
+        });
+        return;
+    }
+    const { DetectorArquiteturaMensagens } = await import('../../core/messages/pt/analysts/detector-architecture-messages.js');
+    ocorrencias.push(criarOcorrencia({
+        tipo: 'caracteristicas-arquitetura',
+        nivel: 'info',
+        mensagem: DetectorArquiteturaMensagens.caracteristicas(analiseCompleta.caracteristicas ?? []),
+        relPath,
+        linha: 1
+    }));
+}
+async function reportarViolacoes(analiseCompleta, contexto, ocorrencias, relPath) {
+    for (const violacao of (analiseCompleta.violacoes ?? []).slice(0, 3)) {
+        if (typeof contexto.report === 'function') {
+            contexto.report({
+                code: 'ARQ_VIOLACAO',
+                tipo: 'violacao-arquitetura',
+                nivel: 'aviso',
+                relPath,
+                linha: 1,
+                data: { violacao },
+                origem: 'arquitetura'
+            });
+        }
+        else {
+            const { DetectorArquiteturaMensagens } = await import('../../core/messages/pt/analysts/detector-architecture-messages.js');
+            ocorrencias.push(criarOcorrencia({
+                tipo: 'violacao-arquitetura',
+                nivel: 'aviso',
+                mensagem: DetectorArquiteturaMensagens.violacao(violacao),
+                relPath,
+                linha: 1
+            }));
+        }
+    }
+}
+async function reportarMetricas(analiseCompleta, contexto, ocorrencias, relPath) {
+    const metricas = analiseCompleta.metricas;
+    if (!metricas || typeof metricas !== 'object' || !('acoplamento' in metricas) || !('coesao' in metricas)) {
+        return;
+    }
+    if ((metricas.acoplamento ?? 0) <= 0.7 && (metricas.coesao ?? 1) >= 0.3) {
+        return;
+    }
+    if (typeof contexto.report === 'function') {
+        contexto.report({
+            code: 'ARQ_METRICAS',
+            tipo: 'metricas-arquitetura',
+            nivel: 'aviso',
+            relPath,
+            linha: 1,
+            data: {
+                acoplamento: metricas.acoplamento ?? 0,
+                coesao: metricas.coesao ?? 0
+            },
+            origem: 'arquitetura'
+        });
+        return;
+    }
+    const { DetectorArquiteturaMensagens } = await import('../../core/messages/pt/analysts/detector-architecture-messages.js');
+    ocorrencias.push(criarOcorrencia({
+        tipo: 'metricas-arquitetura',
+        nivel: 'aviso',
+        mensagem: DetectorArquiteturaMensagens.metricas(metricas.acoplamento ?? 0, metricas.coesao ?? 0),
+        relPath,
+        linha: 1
+    }));
+}
 export const analistaArquitetura = {
     nome: 'arquitetura',
     categoria: 'estrutura',
@@ -72,88 +157,9 @@ export const analistaArquitetura = {
                     linha: 1
                 }));
             }
-            // Relatório de características
-            if ((analiseCompleta.caracteristicas?.length ?? 0) > 0) {
-                if (typeof contexto.report === 'function') {
-                    contexto.report({
-                        code: 'ARQ_CARACTERISTICAS',
-                        tipo: 'caracteristicas-arquitetura',
-                        nivel: 'info',
-                        relPath,
-                        linha: 1,
-                        data: {
-                            caracteristicas: analiseCompleta.caracteristicas ?? []
-                        },
-                        origem: 'arquitetura'
-                    });
-                }
-                else {
-                    const { DetectorArquiteturaMensagens } = await import('../../core/messages/pt/analysts/detector-architecture-messages.js');
-                    ocorrencias.push(criarOcorrencia({
-                        tipo: 'caracteristicas-arquitetura',
-                        nivel: 'info',
-                        mensagem: DetectorArquiteturaMensagens.caracteristicas(analiseCompleta.caracteristicas ?? []),
-                        relPath,
-                        linha: 1
-                    }));
-                }
-            }
-            // Relatório de violações
-            for (const violacao of (analiseCompleta.violacoes ?? []).slice(0, 3)) {
-                if (typeof contexto.report === 'function') {
-                    contexto.report({
-                        code: 'ARQ_VIOLACAO',
-                        tipo: 'violacao-arquitetura',
-                        nivel: 'aviso',
-                        relPath,
-                        linha: 1,
-                        data: {
-                            violacao
-                        },
-                        origem: 'arquitetura'
-                    });
-                }
-                else {
-                    const { DetectorArquiteturaMensagens } = await import('../../core/messages/pt/analysts/detector-architecture-messages.js');
-                    ocorrencias.push(criarOcorrencia({
-                        tipo: 'violacao-arquitetura',
-                        nivel: 'aviso',
-                        mensagem: DetectorArquiteturaMensagens.violacao(violacao),
-                        relPath,
-                        linha: 1
-                    }));
-                }
-            }
-            // Métricas de qualidade
-            const metricas = analiseCompleta.metricas;
-            if (metricas && typeof metricas === 'object' && 'acoplamento' in metricas && 'coesao' in metricas) {
-                if ((metricas.acoplamento ?? 0) > 0.7 || (metricas.coesao ?? 1) < 0.3) {
-                    if (typeof contexto.report === 'function') {
-                        contexto.report({
-                            code: 'ARQ_METRICAS',
-                            tipo: 'metricas-arquitetura',
-                            nivel: 'aviso',
-                            relPath,
-                            linha: 1,
-                            data: {
-                                acoplamento: metricas.acoplamento ?? 0,
-                                coesao: metricas.coesao ?? 0
-                            },
-                            origem: 'arquitetura'
-                        });
-                    }
-                    else {
-                        const { DetectorArquiteturaMensagens } = await import('../../core/messages/pt/analysts/detector-architecture-messages.js');
-                        ocorrencias.push(criarOcorrencia({
-                            tipo: 'metricas-arquitetura',
-                            nivel: 'aviso',
-                            mensagem: DetectorArquiteturaMensagens.metricas(metricas.acoplamento ?? 0, metricas.coesao ?? 0),
-                            relPath,
-                            linha: 1
-                        }));
-                    }
-                }
-            }
+            await reportarCaracteristicas(analiseCompleta, contexto, ocorrencias, relPath);
+            await reportarViolacoes(analiseCompleta, contexto, ocorrencias, relPath);
+            await reportarMetricas(analiseCompleta, contexto, ocorrencias, relPath);
             return ocorrencias;
         }
         catch (erro) {
@@ -232,10 +238,10 @@ function analisarArquivo(ast, relPath, _src) {
                         tipo: 'named'
                     });
                 }
-                else if ('declarations' in decl && decl.declarations) {
+                else if ('declarations' in decl) {
                     // export const a = ..., b = ...
                     for (const declarator of decl.declarations) {
-                        if (declarator.id && 'name' in declarator.id) {
+                        if ('name' in declarator.id) {
                             exports.push({
                                 nome: declarator.id.name,
                                 tipo: 'named'
@@ -390,7 +396,7 @@ function detectarPadraoArquitetural(estatisticas) {
     if (temDependenciasCirculares) {
         return {
             tipo: 'Arquitetura com Problemas de Acoplamento',
-            confianca: 60
+            confianca: CONFIANCA_ACOPLAMENTO
         };
     }
     return {

package/dist/analysts/detectors/detector-bugs-ml.js

@@ -21,7 +21,7 @@ const BUG_PATTERNS = [
                 for (const m of matches) {
                     return {
                         confidence: 0.85,
-                        line: contarLinhasAtePos(content, m.index ?? 0),
+                        line: contarLinhasAtePos(content, m.index),
                         message: `Possível null pointer dereference: ${m[0].slice(0, MAX_MESSAGE_PREVIEW_LENGTH)}`,
                         suggestion: 'Verificar se o resultado é null/undefined antes de encadear métodos',
                     };
@@ -31,12 +31,12 @@ const BUG_PATTERNS = [
             let match;
             while ((match = optionalChainPattern.exec(content)) !== null) {
                 const [, varName, funcName] = match;
-                const line = contarLinhasAtePos(content, match.index);
                 const beforeContent = content.slice(Math.max(0, match.index - 120), match.index);
                 // pop() é seguro em qualquer array - retorna undefined se vazio, nunca lança
                 if (funcName === 'pop') {
                     continue;
                 }
+                const line = contarLinhasAtePos(content, match.index);
                 // Verificar se a variável é garantidamente um array (const = [] ou const = [...])
                 const varDeclaration = content.slice(Math.max(0, match.index - 200), match.index);
                 if (new RegExp(`(const|let|var)\\s+${varName}\\s*=\\s*\\[`).test(varDeclaration)) {
@@ -75,7 +75,7 @@ const BUG_PATTERNS = [
             for (const pattern of patterns) {
                 const matches = content.matchAll(pattern);
                 for (const m of matches) {
-                    const line = contarLinhasAtePos(content, m.index ?? 0);
+                    const line = contarLinhasAtePos(content, m.index);
                     if (!hasCleanup(content, line)) {
                         return {
                             confidence: 0.82,
@@ -104,7 +104,7 @@ const BUG_PATTERNS = [
             for (const pattern of asyncPatterns) {
                 const matches = content.matchAll(pattern);
                 for (const m of matches) {
-                    const line = contarLinhasAtePos(content, m.index ?? 0);
+                    const line = contarLinhasAtePos(content, m.index);
                     if (hasSharedState(content, line)) {
                         return {
                             confidence: 0.78,
@@ -133,7 +133,7 @@ const BUG_PATTERNS = [
             for (const pattern of patterns) {
                 const matches = content.matchAll(pattern);
                 for (const m of matches) {
-                    const line = contarLinhasAtePos(content, m.index ?? 0);
+                    const line = contarLinhasAtePos(content, m.index);
                     if (!hasValidation(content, line)) {
                         return {
                             confidence: 0.72,
@@ -157,7 +157,7 @@ const BUG_PATTERNS = [
             const pattern = /(?<![.\w])new\s+Promise\s*\([^)]*\)(?![^]*\.(then|catch|finally)\s*\()/g;
             const matches = content.matchAll(pattern);
             for (const m of matches) {
-                const line = contarLinhasAtePos(content, m.index ?? 0);
+                const line = contarLinhasAtePos(content, m.index);
                 const beforeContent = content.slice(Math.max(0, m.index - 20), m.index);
                 if (/\b(await|return)\s+/.test(beforeContent)) {
                     continue;
@@ -220,7 +220,7 @@ const BUG_PATTERNS = [
             const matches = content.matchAll(magicNumPattern);
             const results = [];
             for (const m of matches) {
-                const line = contarLinhasAtePos(content, m.index ?? 0);
+                const line = contarLinhasAtePos(content, m.index);
                 const lineContent = content.split('\n')[line - 1] || '';
                 if (!lineContent.includes('const') && !lineContent.includes('let') && !lineContent.includes('var') && !lineContent.includes('//') && !lineContent.includes('/*')) {
                     results.push({
@@ -252,7 +252,7 @@ const BUG_PATTERNS = [
             for (const pattern of patterns) {
                 const matches = content.matchAll(pattern);
                 for (const m of matches) {
-                    const line = contarLinhasAtePos(content, m.index ?? 0);
+                    const line = contarLinhasAtePos(content, m.index);
                     return {
                         confidence: 0.88,
                         line,
@@ -445,6 +445,26 @@ function hasValidation(content, _line) {
 function contarLinhasAtePos(content, pos) {
     return content.slice(0, pos).split('\n').length;
 }
+function detectarPadroesBug(src, relPath, ocorrencias) {
+    for (const pattern of BUG_PATTERNS) {
+        try {
+            const match = pattern.detect(src, relPath);
+            if (match && match.confidence > 0.5) {
+                const nivel = pattern.severity === 'erro' && match.confidence > 0.8 ? 'erro' : pattern.severity;
+                ocorrencias.push({
+                    tipo: `ml-${pattern.id}`,
+                    nivel,
+                    mensagem: getMessages().BugMlMensagens.mlPattern((match.confidence * 100).toFixed(0), match.message),
+                    origem: 'detector-bugs-ml',
+                    relPath,
+                    linha: match.line ?? 0,
+                    sugestao: match.suggestion,
+                });
+            }
+        }
+        catch { }
+    }
+}
 export const detectorBugsMl = {
     nome: 'detector-bugs-ml',
     global: false,
@@ -473,25 +493,7 @@ export const detectorBugsMl = {
                 linha: 0,
             });
         }
-        // 2. Pattern-based bug detection
-        for (const pattern of BUG_PATTERNS) {
-            try {
-                const match = pattern.detect(src, relPath);
-                if (match && match.confidence > 0.5) {
-                    const nivel = pattern.severity === 'erro' && match.confidence > 0.8 ? 'erro' : pattern.severity;
-                    ocorrencias.push({
-                        tipo: `ml-${pattern.id}`,
-                        nivel,
-                        mensagem: getMessages().BugMlMensagens.mlPattern((match.confidence * 100).toFixed(0), match.message),
-                        origem: 'detector-bugs-ml',
-                        relPath,
-                        linha: match.line ?? 0,
-                        sugestao: match.suggestion,
-                    });
-                }
-            }
-            catch { }
-        }
+        detectarPadroesBug(src, relPath, ocorrencias);
         return ocorrencias;
     },
 };