@mocoto/mahoraga 0.14.0 → 0.14.2

package/dist/analysts/react/detectors/detector-react-best-practices.js

@@ -15,8 +15,9 @@ export const detectorReactBestPractices = {
     descricao: 'Detecta más práticas em componentes React',
     test: (relPath) => /\.(jsx|tsx)$/i.test(relPath),
     aplicar: (src, relPath) => {
-        if (!src)
+        if (!src) {
             return [];
+        }
         const ocorrencias = [];
         const linhas = splitLines(src);
         linhas.forEach((linha, index) => {
@@ -48,8 +49,9 @@ export const detectorReactBestPractices = {
             const seen = new Set();
             for (const o of deeper) {
                 const chave = `${o.tipo}|${o.relPath}|${o.linha ?? 0}`;
-                if (seen.has(chave))
+                if (seen.has(chave)) {
                     continue;
+                }
                 seen.add(chave);
                 const dup = ocorrencias.findIndex(ex => ex.tipo === o.tipo && ex.linha === o.linha);
                 if (dup === -1) {
@@ -62,20 +64,21 @@ export const detectorReactBestPractices = {
 };
 function detectWithBabel(src, relPath) {
     try {
-        const plugins = ['decorators-legacy', 'jsx'];
+        const plugins = ['decorators-legacy', 'classProperties', 'classPrivateProperties', 'classPrivateMethods', 'optionalChaining', 'nullishCoalescingOperator', 'topLevelAwait', 'importAttributes', 'jsx'];
         plugins.unshift('typescript');
         const ast = babelParse(src, { sourceType: 'unambiguous', errorRecovery: true, plugins });
         const out = [];
         const seen = new Set();
         const pushOnce = (o) => {
             const chave = `${o.tipo}|${o.relPath}|${o.linha ?? 0}`;
-            if (seen.has(chave))
+            if (seen.has(chave)) {
                 return;
+            }
             seen.add(chave);
             out.push(o);
         };
         const _lineOf = createLineLookup(src).lineAt;
-        const isHookName = (name) => /^use[A-Z0-9_]/.test(name) || name === 'useEffect' || name === 'useLayoutEffect' || name === 'useMemo' || name === 'useCallback' || name === 'useState' || name === 'useReducer' || name === 'useRef' || name === 'useContext' || name === 'useImperativeHandle' || name === 'useInsertionEffect' || name === 'useDebugValue' || name === 'useDeferredValue' || name === 'useTransition' || name === 'useSyncExternalStore' || name === 'useId';
+        const isHookName = (name) => /^use[A-Z0-9_]/.test(name);
         const declaredVars = new Set();
         const visitor = {
             VariableDeclarator(path) {
@@ -87,13 +90,16 @@ function detectWithBabel(src, relPath) {
                 const node = path.node;
                 const callee = node.callee;
                 let name = '';
-                if (t.isIdentifier(callee))
+                if (t.isIdentifier(callee)) {
                     name = callee.name;
-                else if (t.isMemberExpression(callee) && t.isIdentifier(callee.property))
+                }
+                else if (t.isMemberExpression(callee) && t.isIdentifier(callee.property)) {
                     name = callee.property.name;
-                if (!name)
+                }
+                if (!name) {
                     return;
-                const locLine = path.node.loc?.start?.line;
+                }
+                const locLine = path.node.loc?.start.line;
                 if (isHookName(name)) {
                     const parent = path.findParent(p => p.isIfStatement() || p.isConditionalExpression() || p.isLogicalExpression() || p.isSwitchStatement() || p.isSwitchCase() || p.isForStatement() || p.isWhileStatement() || p.isDoWhileStatement() || p.isLoop());
                     if (parent) {
@@ -108,7 +114,7 @@ function detectWithBabel(src, relPath) {
                             pushOnce(warn('react-hook-inside-callback', D.hookInsideCallback, relPath, locLine, D.hookInsideCallbackSugestao, 'erro'));
                         }
                     }
-                    if (fnParent && fnParent.isFunction()) {
+                    if (fnParent?.isFunction()) {
                         const fnBody = fnParent.node.body;
                         if (t.isBlockStatement(fnBody)) {
                             const bodyStmts = fnBody.body;
@@ -128,7 +134,7 @@ function detectWithBabel(src, relPath) {
                     }
                     if (name === 'useEffect' || name === 'useLayoutEffect' || name === 'useInsertionEffect') {
                         const bodyArg = node.arguments[0];
-                        if (bodyArg && (t.isFunctionExpression(bodyArg) || t.isArrowFunctionExpression(bodyArg)) && bodyArg.body && t.isBlockStatement(bodyArg.body)) {
+                        if ((t.isFunctionExpression(bodyArg) || t.isArrowFunctionExpression(bodyArg)) && t.isBlockStatement(bodyArg.body)) {
                             const bodyStmts = bodyArg.body.body;
                             const hasCleanup = bodyStmts.some(stmt => t.isReturnStatement(stmt) && stmt.argument && (t.isFunctionExpression(stmt.argument) || t.isArrowFunctionExpression(stmt.argument)));
                             const hasSubscriptions = /\b(subscribe|addEventListener|on\()/.test(src.slice(bodyArg.start ?? 0, bodyArg.end ?? 0));
@@ -140,8 +146,9 @@ function detectWithBabel(src, relPath) {
                             const depsArg = node.arguments[1];
                             if (t.isArrayExpression(depsArg)) {
                                 for (const el of depsArg.elements) {
-                                    if (t.isIdentifier(el))
+                                    if (t.isIdentifier(el)) {
                                         refsInDeps.add(el.name);
+                                    }
                                 }
                             }
                             const bodyText = src.slice(bodyArg.start ?? 0, bodyArg.end ?? 0);
@@ -167,7 +174,7 @@ function detectWithBabel(src, relPath) {
                                 }
                                 return false;
                             });
-                            if (stateCalls.length > 1 && depsArg && t.isArrayExpression(depsArg)) {
+                            if (stateCalls.length > 1) {
                                 pushOnce(warn('react-infinite-loop', D.infiniteLoopPattern, relPath, locLine, D.infiniteLoopPatternSugestao, 'aviso'));
                             }
                         }
@@ -243,10 +250,11 @@ function detectWithBabel(src, relPath) {
             },
             JSXOpeningElement(path) {
                 const node = path.node;
-                const locLine = node.loc?.start?.line;
+                const locLine = node.loc?.start.line;
                 const tag = t.isJSXIdentifier(node.name) ? node.name.name : '';
-                if (!tag)
+                if (!tag) {
                     return;
+                }
                 if (tag === 'img' || tag === 'input' || tag === 'textarea' || tag === 'select' || tag === 'button') {
                     const hasAria = node.attributes.some(a => {
                         if (t.isJSXAttribute(a) && t.isJSXIdentifier(a.name)) {
@@ -264,17 +272,18 @@ function detectWithBabel(src, relPath) {
                     pushOnce(warn('react-onclick-nokeydown', D.onClickWithoutKeyDown, relPath, locLine, D.onClickWithoutKeyDownSugestao, 'aviso'));
                 }
                 const fragmentParent = path.findParent(p => p.isJSXFragment());
-                if (fragmentParent && fragmentParent.isJSXFragment()) {
-                    const children = fragmentParent.node.children?.filter(c => !t.isJSXText(c) || (c.value?.trim() ?? '') !== '') ?? [];
+                if (fragmentParent?.isJSXFragment()) {
+                    const children = fragmentParent.node.children.filter(c => !t.isJSXText(c) || c.value.trim() !== '');
                     if (children.length <= 1) {
                         pushOnce(warn('react-unnecessary-fragment', D.unnecessaryFragment, relPath, locLine, undefined, 'info'));
                     }
                 }
             },
             JSXAttribute(path) {
-                const locLine = path.node.loc?.start?.line;
-                if (!t.isJSXIdentifier(path.node.name))
+                const locLine = path.node.loc?.start.line;
+                if (!t.isJSXIdentifier(path.node.name)) {
                     return;
+                }
                 const name = path.node.name.name;
                 if (name.startsWith('on') && path.node.value && t.isJSXExpressionContainer(path.node.value)) {
                     const expr = path.node.value.expression;
@@ -296,7 +305,7 @@ function detectWithBabel(src, relPath) {
                 }
             },
             MemberExpression(path) {
-                const locLine = path.node.loc?.start?.line;
+                const locLine = path.node.loc?.start.line;
                 if (t.isIdentifier(path.node.object) && t.isIdentifier(path.node.property)) {
                     const obj = path.node.object.name;
                     const prop = path.node.property.name;
@@ -313,4 +322,3 @@ function detectWithBabel(src, relPath) {
         return null;
     }
 }
-//# sourceMappingURL=detector-react-best-practices.js.map

package/dist/analysts/react/detectors/index.js

@@ -1,2 +1,2 @@
+// SPDX-License-Identifier: MIT
 export * from './detector-react-best-practices.js';
-//# sourceMappingURL=index.js.map

package/dist/analysts/react/index.js

@@ -1,6 +1,11 @@
+// SPDX-License-Identifier: MIT
+/**
+ * [BUSCA] Analistas de React
+ *
+ * Heurísticas leves de React e React Hooks (sem ESLint).
+ */
 export * from './analysts/analyst-react.js';
 export * from './analysts/analyst-react-hooks.js';
 export * from './corrections/index.js';
 export * from './detectors/index.js';
 export * from './scorers/index.js';
-//# sourceMappingURL=index.js.map

package/dist/analysts/react/scorers/index.js

@@ -1,2 +1,2 @@
+// SPDX-License-Identifier: MIT
 export * from './scorer-react.js';
-//# sourceMappingURL=index.js.map

package/dist/analysts/react/scorers/scorer-react.js

@@ -1,26 +1,71 @@
+// SPDX-License-Identifier: MIT
+// @mahoraga-disable react-hooks/rule
 export function pontuarReact(src, _relPath) {
     let score = 0;
     const maxScore = 100;
     const issues = [];
     const strengths = [];
     const srcCompleto = src;
-    const usaHooks = /use(State|Effect|Memo|Callback|Reducer|Ref|Context|LayoutEffect|ImperativeHandle|Transition|DeferredValue|SyncExternalStore|InsertionEffect|Id)/.test(srcCompleto);
+    // React 19 patterns: forwardRef deprecation, React.FC, Server Components
+    const hasForwardRef = /\bforwardRef\s*\(/.test(srcCompleto);
+    if (hasForwardRef) {
+        issues.push('forwardRef é deprecated no React 19 — passe ref como prop direta');
+    }
+    else {
+        score += 3;
+        strengths.push('Sem forwardRef (estilo React 19)');
+    }
+    const hasReactFC = /\bReact\.(FC|FunctionComponent)\b/.test(srcCompleto);
+    if (hasReactFC) {
+        issues.push('React.FC/FunctionComponent é deprecated no React 19');
+    }
+    else {
+        score += 2;
+        strengths.push('Sem React.FC (tipagem direta de props)');
+    }
+    const hasUseClient = /^['"]use client['"];/m.test(srcCompleto);
+    const hasServerFeatures = /useState|useEffect|useContext|onClick/.test(srcCompleto);
+    if (hasServerFeatures && !hasUseClient) {
+        const firstLine = srcCompleto.split('\n')[0]?.trim() ?? '';
+        if (firstLine.startsWith('import')) {
+            issues.push('Componente usa hooks/eventos sem diretiva \'use client\' (React 19)');
+            score = Math.max(0, score - 3);
+        }
+    }
+    else if (hasUseClient) {
+        score += 3;
+        strengths.push('Diretiva \'use client\' presente (React 19)');
+    }
+    const hasFormAction = /<form[^>]*\saction\s*=/.test(srcCompleto);
+    if (hasFormAction) {
+        strengths.push('Uso de form action (React 19)');
+        score += 2;
+    }
+    // Hooks usage & compliance (20 pontos)
+    const usaHooks = /use(State|Effect|Memo|Callback|Reducer|Ref|Context|LayoutEffect|ImperativeHandle|Transition|DeferredValue|SyncExternalStore|InsertionEffect|Id|Optimistic|ActionState|FormStatus)|\buse\s*\(/.test(srcCompleto);
     let hookPontos = 0;
-    if (usaHooks)
+    if (usaHooks) {
         hookPontos = 10;
+    }
     const hasCustomHooks = /\buse[A-Z][A-Za-z0-9_]*\s*=\s*\(/.test(srcCompleto);
-    if (hasCustomHooks)
+    if (hasCustomHooks) {
         hookPontos += 5;
+    }
     const hooksAtTop = !/(if|for|while|switch)\s*\([^)]*\)\s*\{[\s\S]{0,200}?use[A-Z]/.test(srcCompleto);
-    if (hooksAtTop)
+    if (hooksAtTop) {
         hookPontos += 5;
+    }
     score += hookPontos;
-    if (usaHooks)
+    if (usaHooks) {
         strengths.push('Uso de React Hooks detectado');
-    if (hooksAtTop)
+    }
+    if (hooksAtTop) {
         strengths.push('Hooks na raiz do componente (regras seguidas)');
-    if (!hooksAtTop && usaHooks)
+    }
+    if (!hooksAtTop && usaHooks) {
         issues.push('Hooks em condicionais/loops - quebra regras dos hooks');
+    }
+    // useCallback/useMemo para performance (10 pontos)
     const hasMemoization = /use(Memo|Callback)\s*\([^)]*,\s*\[/.test(srcCompleto);
     if (hasMemoization) {
         score += 10;
@@ -30,8 +75,9 @@ export function pontuarReact(src, _relPath) {
         score += 3;
         issues.push('Considere useMemo/useCallback para listas');
     }
-    const imgWithoutAlt = (srcCompleto.match(/<img(?![^>]*alt=)[^>]*>/gi) || []).length;
-    const imgWithAriaHidden = (srcCompleto.match(/<img[^>]*aria-hidden=["']true["'][^>]*>/gi) || []).length;
+    // Acessibilidade (15 pontos)
+    const imgWithoutAlt = (srcCompleto.match(/<img(?![^>]*alt=)[^>]*>/gi) ?? []).length;
+    const imgWithAriaHidden = (srcCompleto.match(/<img[^>]*aria-hidden=["']true["'][^>]*>/gi) ?? []).length;
     if (imgWithoutAlt === 0 || imgWithoutAlt === imgWithAriaHidden) {
         score += 15;
         strengths.push('Imagens com alt ou aria-hidden adequados');
@@ -40,8 +86,9 @@ export function pontuarReact(src, _relPath) {
         score += Math.max(0, 15 - imgWithoutAlt * 5);
         issues.push(`${imgWithoutAlt} imagem(ns) sem alt`);
     }
-    const interactiveElements = (srcCompleto.match(/<(button|input|textarea|select)[^>]*>/gi) || []).length;
-    const withAria = (srcCompleto.match(/<(button|input|textarea|select)[^>]*\s(aria-label|aria-labelledby|aria-describedby)=/gi) || []).length;
+    // Aria em elementos interativos (5 pontos)
+    const interactiveElements = (srcCompleto.match(/<(button|input|textarea|select)[^>]*>/gi) ?? []).length;
+    const withAria = (srcCompleto.match(/<(button|input|textarea|select)[^>]*\s(aria-label|aria-labelledby|aria-describedby)=/gi) ?? []).length;
     if (interactiveElements > 0) {
         if (withAria === interactiveElements) {
             score += 5;
@@ -52,6 +99,7 @@ export function pontuarReact(src, _relPath) {
             issues.push(`${interactiveElements - withAria} elemento(s) interativo(s) sem aria`);
         }
     }
+    // Sem dangerouslySetInnerHTML (10 pontos)
     if (!/dangerouslySetInnerHTML/.test(srcCompleto)) {
         score += 10;
         strengths.push('Sem uso de dangerouslySetInnerHTML');
@@ -59,7 +107,8 @@ export function pontuarReact(src, _relPath) {
     else {
         issues.push('dangerouslySetInnerHTML detectado');
     }
-    const inlineHandlers = (srcCompleto.match(/on(Click|Submit|Change|MouseOver|KeyDown|Focus|Blur)=\{[^}]*=>/g) || []).length;
+    // Sem inline handlers (10 pontos)
+    const inlineHandlers = (srcCompleto.match(/on(Click|Submit|Change|MouseOver|KeyDown|Focus|Blur)=\{[^}]*=>/g) ?? []).length;
     if (inlineHandlers === 0) {
         score += 10;
         strengths.push('Handlers extraídos (sem inline)');
@@ -72,6 +121,7 @@ export function pontuarReact(src, _relPath) {
         score += 4;
         issues.push(`${inlineHandlers} handlers inline - extraia para funções`);
     }
+    // Sem deprecated lifecycle methods (10 pontos)
     if (!/componentWillMount|componentWillReceiveProps|componentWillUpdate/.test(srcCompleto)) {
         score += 10;
         strengths.push('Sem lifecycle methods deprecated');
@@ -79,8 +129,9 @@ export function pontuarReact(src, _relPath) {
     else {
         issues.push('Lifecycle methods deprecated detectados');
     }
-    const listItems = (srcCompleto.match(/\.map\s*\(/g) || []).length;
-    const keysFound = (srcCompleto.match(/\bkey=\{|\.id\b/g) || []).length;
+    // Key em listas (10 pontos)
+    const listItems = (srcCompleto.match(/\.map\s*\(/g) ?? []).length;
+    const keysFound = (srcCompleto.match(/\bkey=\{|\.id\b/g) ?? []).length;
     if (listItems === 0) {
         score += 10;
         strengths.push('Sem listas que precisam de key');
@@ -93,6 +144,7 @@ export function pontuarReact(src, _relPath) {
         score += Math.round((keysFound / Math.max(listItems, 1)) * 10);
         issues.push(`${Math.max(0, listItems - keysFound)} lista(s) sem key`);
     }
+    // Context usage (5 pontos)
     const hasContext = /createContext|useContext/.test(srcCompleto);
     if (hasContext) {
         const hasMemoizedValue = /useMemo\s*\([\s\S]*?\bvalue\b/.test(srcCompleto);
@@ -105,8 +157,9 @@ export function pontuarReact(src, _relPath) {
             issues.push('Context value não memoizado - pode causar re-renders');
         }
     }
-    const effectsWithCleanup = (srcCompleto.match(/useEffect\s*\(\s*\(\)\s*=>\s*\{[\s\S]*?return\s+(function|\()/g) || []).length;
-    const effectsTotal = (srcCompleto.match(/useEffect\s*\(/g) || []).length;
+    // Effect cleanup (5 pontos)
+    const effectsWithCleanup = (srcCompleto.match(/useEffect\s*\(\s*\(\)\s*=>\s*\{[\s\S]*?return\s+(function|\()/g) ?? []).length;
+    const effectsTotal = (srcCompleto.match(/useEffect\s*\(/g) ?? []).length;
     if (effectsTotal > 0) {
         if (effectsWithCleanup === effectsTotal) {
             score += 5;
@@ -134,4 +187,3 @@ export const pontuadorReact = {
     descricao: 'Pontua qualidade de código React',
     pontuar: pontuarReact
 };
-//# sourceMappingURL=scorer-react.js.map

package/dist/analysts/registry/autodiscovery.js

@@ -1,8 +1,10 @@
+// SPDX-License-Identifier: MIT
 import { promises as fs } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 function isEntry(x) {
-    if (!x || typeof x !== 'object')
+    if (!x || typeof x !== 'object') {
         return false;
+    }
     const ocorrencia = x;
     return typeof ocorrencia.nome === 'string' && typeof ocorrencia.aplicar === 'function';
 }
@@ -11,27 +13,44 @@ function extrairEntradasDeModulo(mod) {
     const out = [];
     const candidates = [];
     candidates.push(metrica.default);
-    if (Array.isArray(metrica.analistas))
+    if (Array.isArray(metrica.analistas)) {
         candidates.push(...metrica.analistas);
-    for (const valor of Object.values(metrica))
+    }
+    // Coleta exportações nomeadas que pareçam analista/técnica
+    for (const valor of Object.values(metrica)) {
         candidates.push(valor);
+    }
     for (const elem of candidates) {
         if (Array.isArray(elem)) {
-            for (const item of elem)
-                if (isEntry(item))
+            for (const item of elem) {
+                if (isEntry(item)) {
                     out.push(item);
+                }
+            }
             continue;
         }
-        if (isEntry(elem))
+        if (isEntry(elem)) {
             out.push(elem);
+        }
     }
+    // Dedup interno por nome
     const byName = new Map();
     for (const erro of out) {
-        if (erro.nome)
+        if (erro.nome) {
             byName.set(erro.nome, erro);
+        }
     }
     return Array.from(byName.values());
 }
+/**
+ * Autodiscovery de analistas/plugins.
+ *
+ * Convenção: qualquer arquivo em `src/analistas/plugins/` com prefixo
+ * `analista-` ou `detector-` será importado e suas entradas serão extraídas.
+ *
+ * - Em runtime buildado: arquivos `.js`
+ * - Em Vitest/dev: arquivos `.ts` podem existir (resolver do Vitest mapeia `.js` -> `.ts`)
+ */
 export async function discoverAnalistasPlugins() {
     try {
         const dirUrl = new URL('../plugins/', import.meta.url);
@@ -49,13 +68,16 @@ export async function discoverAnalistasPlugins() {
                 results.push(...extracted);
             }
             catch {
+                // plugin opcional: ignorar
             }
         }
+        // Dedup final por nome
         const byName = new Map();
         for (const raiz of results) {
             const entry = raiz;
-            if (entry?.nome)
+            if (entry.nome) {
                 byName.set(entry.nome, raiz);
+            }
         }
         return Array.from(byName.values());
     }
@@ -63,4 +85,3 @@ export async function discoverAnalistasPlugins() {
         return [];
     }
 }
-//# sourceMappingURL=autodiscovery.js.map

package/dist/analysts/registry/index.js

@@ -1,3 +1,6 @@
+// SPDX-License-Identifier: MIT
+/**
+ * @fileoverview Analistas registry and autodiscovery
+ */
 export * from './autodiscovery.js';
 export * from './registry.js';
-//# sourceMappingURL=index.js.map

package/dist/analysts/registry/registry.js

@@ -1,28 +1,38 @@
+// SPDX-License-Identifier: MIT
+// Registro central de todos os analistas disponíveis no sistema
+// === Analistas de Workflows / CI-CD ===
 import { analistaAzurePipelines } from '../azure-pipelines/index.js';
 import { analistaCircleCI } from '../circleci/index.js';
 import { analistaCss } from '../css/index.js';
 import { analistaCssInJs } from '../css-in-js/index.js';
+// === Detectores de Estrutura ===
 import { analistaRecomendacaoArquitetura, detectorBugsMl, detectorMonorepo } from '../detectors/index.js';
 import { analistaGithubActions, analistaGithubActionsGlobal } from '../github-actions/index.js';
 import { analistaGitLabCI } from '../gitlab-ci/index.js';
+// === Novos Analistas de Linguagem (v0.8) ===
 import { analistaGo, analistaGoBoasPraticas, analistaGoConcorrencia, analistaGoRecursos, analistaGoSeguranca, detectorConvencoes as detectorConvencoesGo, detectorErrosNaoTratados, detectorVulnerabilidades } from '../go/index.js';
 import { analistaHtml } from '../html/index.js';
 import { analistaJenkins } from '../jenkins/index.js';
+// === Analistas de Linguagem / Tecnologia ===
 import { analistaComandosCli, analistaFuncoesLongas, analistaPadroesUso, analistaTodoComentarios } from '../js-ts/analysts/index.js';
 import { analistaConstrucoesSintaticas, analistaVazamentoMemoria, detectorInterfacesInline, detectorTiposInseguros } from '../js-ts/detectors/index.js';
 import { analistaPhp } from '../php/index.js';
+// === Plugins built-in ===
 import { analistaDocumentacao, detectorMarkdown } from '../plugins/index.js';
 import { analistaPython } from '../python/index.js';
 import { analistaReact, analistaReactHooks } from '../react/index.js';
 import { analistaRust, analistaRustBoasPraticas, analistaRustConcorrencia, analistaRustMemoria, analistaRustSeguranca, detectorConvencoes as detectorConvencoesRust, detectorErrosPotenciais, detectorUnsafe } from '../rust/index.js';
 import { analistaShell } from '../shell/index.js';
 import { analistaSql } from '../sql/index.js';
+// === Analistas de Arquitetura / Estratégia ===
 import { analistaSugestoesContextuais } from '../strategists/index.js';
 import { analistaSvg } from '../svg/index.js';
 import { analistaTailwind } from '../tailwind/index.js';
 import { analistaXml } from '../xml/index.js';
+// === Importações internas ===
 import { comSupressaoInline } from '../../shared/helpers/index.js';
 import { discoverAnalistasPlugins } from './autodiscovery.js';
+// Tentativa de carregar analista de pontuação dinâmico (opcional)
 let analistaCorrecaoAutomatica;
 try {
     const modPontuacao = await import('../corrections/analyst-scoring.js');
@@ -36,22 +46,37 @@ try {
     }
 }
 catch {
+    // Opcional - registry tolera undefined
 }
 const pluginsAutodiscovered = await discoverAnalistasPlugins();
+/**
+ * Registro central de analistas.
+ * Todos os analistas disponíveis para uso pelo framework.
+ */
 export const registroAnalistas = [
+    // Analistas de Workflows / CI-CD
     comSupressaoInline(analistaGithubActions), comSupressaoInline(analistaGithubActionsGlobal), comSupressaoInline(analistaAzurePipelines), comSupressaoInline(analistaCircleCI), comSupressaoInline(analistaGitLabCI), comSupressaoInline(analistaJenkins),
+    // Analistas de Linguagem / Tecnologia
     comSupressaoInline(analistaComandosCli), comSupressaoInline(analistaFuncoesLongas), comSupressaoInline(analistaPadroesUso), comSupressaoInline(analistaTodoComentarios), comSupressaoInline(analistaConstrucoesSintaticas), comSupressaoInline(analistaVazamentoMemoria), comSupressaoInline(detectorInterfacesInline), comSupressaoInline(detectorTiposInseguros), comSupressaoInline(analistaPython), comSupressaoInline(analistaReact), comSupressaoInline(analistaReactHooks), comSupressaoInline(analistaShell), comSupressaoInline(analistaHtml), comSupressaoInline(analistaSvg), comSupressaoInline(analistaCss), comSupressaoInline(analistaXml), comSupressaoInline(analistaSql), comSupressaoInline(analistaTailwind), comSupressaoInline(analistaCssInJs), comSupressaoInline(analistaGo), comSupressaoInline(analistaGoBoasPraticas), comSupressaoInline(analistaGoConcorrencia), comSupressaoInline(analistaGoRecursos), comSupressaoInline(analistaGoSeguranca), comSupressaoInline(detectorErrosNaoTratados), comSupressaoInline(detectorVulnerabilidades), comSupressaoInline(detectorConvencoesGo), comSupressaoInline(analistaRust), comSupressaoInline(analistaRustBoasPraticas), comSupressaoInline(analistaRustConcorrencia), comSupressaoInline(analistaRustMemoria), comSupressaoInline(analistaRustSeguranca), comSupressaoInline(detectorErrosPotenciais), comSupressaoInline(detectorUnsafe), comSupressaoInline(detectorConvencoesRust), comSupressaoInline(analistaPhp),
+    // Detectores de Estrutura
     comSupressaoInline(detectorMonorepo), comSupressaoInline(detectorBugsMl),
+    // Analistas de Arquitetura / Estratégia
     comSupressaoInline(analistaSugestoesContextuais), comSupressaoInline(analistaRecomendacaoArquitetura),
+    // Plugins built-in
     comSupressaoInline(analistaDocumentacao), comSupressaoInline(detectorMarkdown),
+    // Plugins autodiscovered em src/analistas/plugins/
     ...pluginsAutodiscovered.map(caminho => comSupressaoInline(caminho)),
+    // Analista de correção automática (opcional)
     ...(analistaCorrecaoAutomatica ? [comSupressaoInline(analistaCorrecaoAutomatica)] : [])
 ];
+/**
+ * Lista todos os analistas registrados no sistema
+ * Retorna metadados básicos para exibição (CLI, Relatórios)
+ */
 export function listarAnalistas() {
     return registroAnalistas.map(arquivo => ({
         nome: arquivo.nome || 'desconhecido',
-        categoria: arquivo.categoria || 'n/d',
-        descricao: arquivo.descricao || ''
+        categoria: arquivo.categoria ?? 'n/d',
+        descricao: arquivo.descricao ?? ''
     }));
 }
-//# sourceMappingURL=registry.js.map

package/dist/analysts/rust/analysts/analyst-best-practices.js

@@ -1,7 +1,8 @@
+// SPDX-License-Identifier: MIT
 import { messages } from '../../../core/messages/index.js';
 import { createLineLookup, maskRustComments } from '../../../shared/helpers/index.js';
 import { criarAnalista, criarOcorrencia } from '../../../types/index.js';
-const disableEnv = process.env.MAHORAGA_DISABLE_PLUGIN_RUST === '1';
+const disableEnv = process.env.SUKUNA_DISABLE_PLUGIN_RUST === '1';
 function warn(message, relPath, line, nivel) {
     return criarOcorrencia({
         relPath,
@@ -16,59 +17,105 @@ function collectBestPractices(src, relPath) {
     const ocorrencias = [];
     const lineOf = createLineLookup(src).lineAt;
     const scan = maskRustComments(src);
+    // println! in library code
     for (const match of scan.matchAll(/\bprintln!\s*\(/g)) {
         const line = lineOf(match.index);
         if (!relPath.includes('src/bin/') && !relPath.includes('examples/') && !relPath.includes('tests/')) {
             ocorrencias.push(warn(messages.RustMensagens.printlnInLib, relPath, line));
         }
     }
+    // Magic numbers
     for (const match of scan.matchAll(/(?:if|match|let|return|&&|\|\|)\s+.*[=!]=\s*(\d{4,})\b/g)) {
         const line = lineOf(match.index);
         ocorrencias.push(warn(messages.RustMensagens.magicNumber, relPath, line, messages.SeverityNiveis.suggestion));
     }
+    // Excessive function length
     const funcBlocks = src.matchAll(/(?:^|\n)\s*fn\s+\w+.*?\{/gs);
     for (const funcBlock of funcBlocks) {
-        const startIdx = (funcBlock.index ?? 0) + (funcBlock[0]?.length ?? 0);
+        const startIdx = funcBlock.index + funcBlock[0].length;
         let braceCount = 1;
         let endIdx = startIdx;
         for (let i = startIdx; i < src.length && braceCount > 0; i++) {
-            if (src[i] === '{')
+            if (src[i] === '{') {
                 braceCount++;
-            if (src[i] === '}')
+            }
+            if (src[i] === '}') {
                 braceCount--;
+            }
             endIdx = i;
         }
         const funcBody = src.slice(startIdx, endIdx);
         const funcLines = funcBody.split('\n').length;
         if (funcLines > 80) {
-            const line = lineOf(funcBlock.index ?? 0);
+            const line = lineOf(funcBlock.index);
             ocorrencias.push(warn(messages.RustMensagens.longFunction, relPath, line));
         }
     }
+    // Shadowing detected
     const declaredVars = new Set();
     for (const match of scan.matchAll(/\blet\s+(?:mut\s+)?(\w+)\s*=/g)) {
         const varName = match[1];
-        if (varName.startsWith('_'))
+        if (varName.startsWith('_')) {
             continue;
+        }
         if (declaredVars.has(varName)) {
             const line = lineOf(match.index);
             ocorrencias.push(warn(`Variable '${varName}' shadows previous declaration; consider renaming`, relPath, line, messages.SeverityNiveis.info));
         }
         declaredVars.add(varName);
     }
+    // Vec::push in a loop without pre-allocation
+    for (const match of scan.matchAll(/for\s+(\w+)\s+in\s+(\w+)\.iter\(\)\s*\{[\s\S]{0,200}results\.push\(/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn('Collection built with push() in loop; consider using .map().collect() or Iterator adapters', relPath, line, messages.SeverityNiveis.suggestion));
+    }
+    // Use of as_ptr_range / as_mut_ptr_range (Rust 1.77+)
+    for (const match of scan.matchAll(/\.as_(ptr|mut_ptr)_range\(\)/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn(`.${match[1]}_range() used (Rust 1.77+)`, relPath, line, messages.SeverityNiveis.info));
+    }
+    // Option::unwrap_or_else(|| ...) -> unwrap_or(...) when argument is constant
+    for (const match of scan.matchAll(/\.unwrap_or_else\(\s*\|\|\s*(\w+)::(\w+)\s*\)/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn(`.unwrap_or_else(|| ...) with constant default; consider .unwrap_or(...) (Rust 1.78+)`, relPath, line, messages.SeverityNiveis.suggestion));
+    }
+    // use of assert!(expr.is_some()) -> assert!(expr.is_some()) is fine, but check for unwrap after
+    for (const match of scan.matchAll(/if\s+(\w+)\.is_some\(\)\s*\{[\s\S]{0,100}(\w+)\.unwrap\(\)/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn('Guard with .is_some() followed by .unwrap(); use if let Some(x) = ... instead', relPath, line, messages.SeverityNiveis.suggestion));
+    }
+    // use of format!("literal {var}") without explicit capture (Rust 1.80+)
+    for (const match of scan.matchAll(/format!\(["']([^"']*\{(\w+)\}[^"']*)["'],\s*\2\s*\)/g)) {
+        const line = lineOf(match.index);
+        const varName = match[2];
+        ocorrencias.push(warn(`format!("...{${varName}}...", ${varName}) can be simplified to format!("...{${varName}}...") using implicit capture (Rust 1.80+)`, relPath, line, messages.SeverityNiveis.suggestion));
+    }
+    // detect assert!(matches!(expr, pattern)) pattern -> suggest assert_matches!
+    for (const match of scan.matchAll(/assert!\(matches!\(([^,]+),\s*([^)]+)\)\s*\)/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn(`assert!(matches!(${match[1]}, ${match[2]})) — consider assert_matches!(${match[1]}, ${match[2]}) (nightly Rust 1.81+)`, relPath, line, messages.SeverityNiveis.info));
+    }
+    // detect Vec<_>::new() -> Vec::new() (type inference)
+    // detect .into_iter() -> .iter()/iter_mut() when not consuming
+    for (const match of scan.matchAll(/\.into_iter\(\)\.(map|filter|for_each)/g)) {
+        const line = lineOf(match.index);
+        if (!src.slice(0, match.index).includes('.collect')) {
+            ocorrencias.push(warn('.into_iter() used but not consuming; consider .iter() for read-only iteration', relPath, line, messages.SeverityNiveis.suggestion));
+        }
+    }
     return ocorrencias;
 }
 export const analistaRustBoasPraticas = criarAnalista({
     nome: 'analista-rust-boas-praticas',
     categoria: 'boas-praticas',
-    descricao: 'Detecta desvios de boas práticas em código Rust.',
+    descricao: 'Detecta desvios de boas práticas Rust (edition 2024, Rust 1.80+).',
     global: false,
     test: (relPath) => /\.(rs)$/i.test(relPath),
-    aplicar: async (src, relPath) => {
-        if (disableEnv)
+    aplicar: (src, relPath) => {
+        if (disableEnv) {
             return null;
+        }
         const msgs = collectBestPractices(src, relPath);
         return msgs.length ? msgs : null;
     }
 });
-//# sourceMappingURL=analyst-best-practices.js.map