@mocoto/mahoraga 0.14.2 → 0.14.4

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

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: MIT
 import { messages } from '../../../core/messages/index.js';
+import { IMPORTANT_PATTERN } from '../shared.js';
 import { criarAnalista, criarOcorrencia } from '../../../types/index.js';
 const disableEnv = process.env.SUKUNA_DISABLE_PLUGIN_CSS_IN_JS === '1';
 function findLine(src, index = 0) {
@@ -80,6 +81,26 @@ function detectarStyledJsx(src) {
         indices
     };
 }
+function processarStyledComponents(sc, src, relPath, ocorrencias) {
+    if (!sc.detected) {
+        return;
+    }
+    const first = sc.indices[0] ?? 0;
+    ocorrencias.push(emitir(messages.CssInJsMensagens.detectedStyledComponents, relPath, messages.SeverityNiveis.info, findLine(src, first)));
+    if (sc.global) {
+        ocorrencias.push(emitir(messages.CssInJsMensagens.globalStyles('styled-components'), relPath, messages.SeverityNiveis.warning, findLine(src, first)));
+    }
+}
+function processarStyledJsx(sj, src, relPath, ocorrencias) {
+    if (!sj.detected) {
+        return;
+    }
+    const first = sj.indices[0] ?? 0;
+    ocorrencias.push(emitir(messages.CssInJsMensagens.detectedStyledJsx, relPath, messages.SeverityNiveis.info, findLine(src, first)));
+    if (sj.global) {
+        ocorrencias.push(emitir(messages.CssInJsMensagens.globalStyles('styled-jsx'), relPath, messages.SeverityNiveis.warning, findLine(src, first)));
+    }
+}
 export const analistaCssInJs = criarAnalista({
     nome: 'analista-css-in-js',
     categoria: 'estilo',
@@ -93,7 +114,6 @@ export const analistaCssInJs = criarAnalista({
         if (relPath.includes('src/analistas/css-in-js/')) {
             return null;
         }
-        // Prefiltro barato para evitar múltiplos matchAll em arquivos que não têm sinais.
         if (!/styled-components|styled-jsx|<style\b[^>]*\bjsx\b|\bcreateGlobalStyle\b|\bstyled\b/i.test(src)) {
             return null;
         }
@@ -103,22 +123,9 @@ export const analistaCssInJs = criarAnalista({
         if (!sc.detected && !sj.detected) {
             return null;
         }
-        if (sc.detected) {
-            const first = sc.indices[0] ?? 0;
-            ocorrencias.push(emitir(messages.CssInJsMensagens.detectedStyledComponents, relPath, messages.SeverityNiveis.info, findLine(src, first)));
-            if (sc.global) {
-                ocorrencias.push(emitir(messages.CssInJsMensagens.globalStyles('styled-components'), relPath, messages.SeverityNiveis.warning, findLine(src, first)));
-            }
-        }
-        if (sj.detected) {
-            const first = sj.indices[0] ?? 0;
-            ocorrencias.push(emitir(messages.CssInJsMensagens.detectedStyledJsx, relPath, messages.SeverityNiveis.info, findLine(src, first)));
-            if (sj.global) {
-                ocorrencias.push(emitir(messages.CssInJsMensagens.globalStyles('styled-jsx'), relPath, messages.SeverityNiveis.warning, findLine(src, first)));
-            }
-        }
-        // Sinais comuns dentro de CSS em template strings / style tags
-        if (/!important/.test(src)) {
+        processarStyledComponents(sc, src, relPath, ocorrencias);
+        processarStyledJsx(sj, src, relPath, ocorrencias);
+        if (IMPORTANT_PATTERN.test(src)) {
             ocorrencias.push(emitir(messages.CssInJsMensagens.importantUsage, relPath, messages.SeverityNiveis.warning, 1));
         }
         if (/url\(\s*['"]?http:\/\//i.test(src)) {

package/dist/analysts/css-in-js/corrections/correction-css-in-js.js

@@ -12,30 +12,45 @@
  */
 import { getMessages } from '../../../core/messages/index.js';
 import { splitLines } from '../../../shared/helpers/index.js';
+import { IMPORTANT_PATTERN, IMPORTANT_WS_GLOBAL } from '../shared.js';
 import { criarOcorrencia } from '../../../types/index.js';
+function detectarCreateGlobalStyle(linha, numeroLinha, m) {
+    if (!/createGlobalStyle/.test(linha)) {
+        return null;
+    }
+    return {
+        tipo: 'css-in-js-extract-global',
+        original: linha.trim(),
+        sugerido: m.extractGlobalCss,
+        linha: numeroLinha,
+        confianca: 70
+    };
+}
+function detectarImportantCorrection(linha, numeroLinha) {
+    if (!IMPORTANT_PATTERN.test(linha) || !/styled|css\s*`/.test(linha)) {
+        return null;
+    }
+    return {
+        tipo: 'css-in-js-remove-important',
+        original: linha.trim(),
+        sugerido: linha.replace(IMPORTANT_WS_GLOBAL, ''),
+        linha: numeroLinha,
+        confianca: 80
+    };
+}
 export function detectarCorrecoesCssInJs(src, _relPath) {
     const m = getMessages().CssInJsCorrecaoMensagens;
     const correcoes = [];
     const linhas = splitLines(src);
     linhas.forEach((linha, index) => {
         const numeroLinha = index + 1;
-        if (/createGlobalStyle/.test(linha)) {
-            correcoes.push({
-                tipo: 'css-in-js-extract-global',
-                original: linha.trim(),
-                sugerido: m.extractGlobalCss,
-                linha: numeroLinha,
-                confianca: 70
-            });
+        const globalCorrection = detectarCreateGlobalStyle(linha, numeroLinha, m);
+        if (globalCorrection) {
+            correcoes.push(globalCorrection);
         }
-        if (/!important/.test(linha) && /styled|css\s*`/.test(linha)) {
-            correcoes.push({
-                tipo: 'css-in-js-remove-important',
-                original: linha.trim(),
-                sugerido: linha.replace(/\s*!important/g, ''),
-                linha: numeroLinha,
-                confianca: 80
-            });
+        const importantCorrection = detectarImportantCorrection(linha, numeroLinha);
+        if (importantCorrection) {
+            correcoes.push(importantCorrection);
         }
     });
     return correcoes;

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

@@ -4,10 +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 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',
@@ -35,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',
@@ -85,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',

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) {
@@ -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

@@ -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;
     },
 };