@mocoto/mahoraga 0.14.6 → 0.14.8

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

@@ -179,7 +179,16 @@ const CONHECIDAS_CSS_PROPRIEDADES = new Set([
     // CSS3 e modernas
     'transform-origin', 'inset', 'background-clip', 'max-width', 'max-height', 'min-height', 'animation-delay', 'pointer-events', 'scroll-behavior', 'background-attachment', 'text-shadow', 'inset-inline', 'inset-block', 'inset-inline-start', 'inset-inline-end', 'inset-block-start', 'inset-block-end',
     // Outros comuns
-    'cursor', 'opacity', 'transform', 'transition', 'animation', 'list-style', 'vertical-align', 'text-overflow', 'box-shadow', 'border-radius', 'outline', 'content', 'counter-reset', 'counter-increment'
+    'cursor', 'opacity', 'transform', 'transition', 'animation', 'list-style', 'vertical-align', 'text-overflow', 'box-shadow', 'border-radius', 'outline', 'content', 'counter-reset', 'counter-increment',
+    // CSS modernas (propriedades válidas e amplamente suportadas — ver feedback.md 1.4)
+    'clip-path', 'backdrop-filter', 'aspect-ratio', 'accent-color', 'appearance', 'user-select',
+    'object-fit', 'object-position', 'mix-blend-mode', 'filter', 'backdrop', 'will-change',
+    'place-items', 'place-content', 'place-self', 'grid-auto-flow', 'grid-auto-columns', 'grid-auto-rows',
+    'scroll-snap-type', 'scroll-snap-align', 'scroll-snap-stop', 'scroll-behavior', 'scroll-padding',
+    'text-wrap', 'overflow-wrap', 'word-break', 'hyphens', 'line-break', 'paint-order',
+    'touch-action', 'user-zoom', 'zoom', 'field-sizing', 'd', 'fill', 'stroke', 'stroke-width',
+    'mask-image', 'mask-size', 'mask-position', 'mask-repeat', 'clip-rule', 'fill-rule',
+    'isolation', 'contain', 'contain-intrinsic-size', 'content-visibility', 'rotate', 'scale', 'translate'
 ]);
 function isValidCssProperty(prop) {
     const normalized = prop.toLowerCase();

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

@@ -1,6 +1,6 @@
-// SPDX-License-Identifier: MIT
-// @mahoraga-disable ml-deep-nesting
-// Justificativa: O detector de aninhamento excessivo analisa o próprio código gerando falso positivo em auto-análise. O padrão deep-nesting é necessário para detecção de bugs.
+import { parse as babelParse } from '@babel/parser';
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
 import { getMessages } from '../../core/messages/index.js';
 const MAX_MESSAGE_PREVIEW_LENGTH = 60;
 // Statistical bug patterns with ML-like scoring
@@ -180,27 +180,42 @@ const BUG_PATTERNS = [
         severity: 'aviso',
         category: 'logic',
         weight: 0.7,
-        detect(content, _relPath) {
+        detect(content, relPath) {
+            // Contagem ingênua de todos os `()[]{}` globais gera falso positivo em
+            // bases modernas: aninhamento de JSX (divs aninhadas) e parênteses/colchetes
+            // de expressões inflam a profundidade sem aumentar a complexidade de
+            // decisão. Seguindo feedback.md seção 1.5, contamos apenas o aninhamento
+            // de BLOCOS DE LÓGICA (BlockStatement) via AST — JSX, literais de objeto/
+            // array e parênteses de expressão são ignorados. Arquivos não analisáveis
+            // mantêm o fallback conservador por contagem de colchetes.
+            const logic = computeLogicNestingDepth(content, relPath);
             let maxDepth = 0;
-            let currentDepth = 0;
             let depthLine = 0;
-            let lineCount = 1;
-            for (const char of content) {
-                if (char === '\n') {
-                    lineCount++;
-                }
-                if (char === '{' || char === '(' || char === '[') {
-                    currentDepth++;
-                    if (currentDepth > maxDepth) {
-                        maxDepth = currentDepth;
-                        depthLine = lineCount;
+            if (logic !== null) {
+                maxDepth = logic.depth;
+                depthLine = logic.line;
+            }
+            else {
+                let currentDepth = 0;
+                let lineCount = 1;
+                for (const char of content) {
+                    if (char === '\n') {
+                        lineCount++;
+                    }
+                    if (char === '{' || char === '(' || char === '[') {
+                        currentDepth++;
+                        if (currentDepth > maxDepth) {
+                            maxDepth = currentDepth;
+                            depthLine = lineCount;
+                        }
+                    }
+                    else if (char === '}' || char === ')' || char === ']') {
+                        currentDepth = Math.max(0, currentDepth - 1);
                     }
-                }
-                else if (char === '}' || char === ')' || char === ']') {
-                    currentDepth = Math.max(0, currentDepth - 1);
                 }
             }
-            if (maxDepth > 6) {
+            // Limiar maior: só sinaliza aninhamento de lógica genuinamente profundo.
+            if (maxDepth > 7) {
                 return {
                     confidence: Math.min(0.95, 0.5 + maxDepth * 0.06),
                     line: depthLine,
@@ -447,6 +462,53 @@ function hasValidation(content, _line) {
 function contarLinhasAtePos(content, pos) {
     return content.slice(0, pos).split('\n').length;
 }
+const traverseFn = traverse;
+/**
+ * Calcula a profundidade de aninhamento de BLOCOS DE LÓGICA (BlockStatement)
+ * via AST, ignorando JSX, literais de objeto/array e parênteses de expressões
+ * — que a contagem ingênua de colchetes contava indevidamente (feedback.md 1.5).
+ * Retorna `null` quando o arquivo não é JS/TS ou não pôde ser parseado.
+ */
+function computeLogicNestingDepth(content, relPath) {
+    if (!/\.(tsx?|jsx?|mjs|cjs)$/i.test(relPath)) {
+        return null;
+    }
+    try {
+        const lower = relPath.toLowerCase();
+        const isTs = lower.endsWith('.ts') || lower.endsWith('.tsx');
+        const isJsxLike = lower.endsWith('.tsx') || lower.endsWith('.jsx');
+        const plugins = ['decorators-legacy', 'classProperties', 'classPrivateProperties', 'classPrivateMethods', 'optionalChaining', 'nullishCoalescingOperator', 'topLevelAwait', 'importAttributes'];
+        if (isTs) {
+            plugins.unshift('typescript');
+        }
+        if (isJsxLike) {
+            plugins.unshift('jsx');
+        }
+        const ast = babelParse(content, { sourceType: 'unambiguous', errorRecovery: true, plugins: plugins });
+        let depth = 0;
+        let max = 0;
+        let maxLine = 0;
+        const visitor = {
+            BlockStatement: {
+                enter(path) {
+                    depth++;
+                    if (depth > max) {
+                        max = depth;
+                        maxLine = path.node.loc?.start.line ?? 0;
+                    }
+                },
+                exit() {
+                    depth--;
+                }
+            }
+        };
+        traverseFn(ast, visitor);
+        return { depth: max, line: maxLine };
+    }
+    catch {
+        return null;
+    }
+}
 function detectarPadroesBug(src, relPath, ocorrencias) {
     for (const pattern of BUG_PATTERNS) {
         try {

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

@@ -4,7 +4,7 @@
  */
 const detectoresJsTs = [];
 export function registrarDetectorJsTs(detector) {
-    if (!detector.nome) {
+    if (!detector || !detector.nome) {
         return;
     }
     const exists = detectoresJsTs.some(d => d.nome === detector.nome);

package/dist/analysts/react/analysts/analyst-react-hooks.js

@@ -106,73 +106,80 @@ function extractHookCallContent(src, startIndex) {
     }
     return content;
 }
-function collectHookIssues(src, relPath) {
+function collectHookIssues(src, relPath, opts = {}) {
     const ocorrencias = [];
     const lineOf = createLineLookup(src).lineAt;
-    // Check useEffect/useLayoutEffect for deps
-    const effectMatches = [...src.matchAll(/use(Layout)?Effect\s*\(/g)];
-    effectMatches.forEach(m => {
-        const hookInicio = m.index;
-        const fullCall = extractHookCallContent(src, hookInicio + m[0].length - 1);
-        // More robust deps detection: find the last comma followed by an array or identifier before the closing paren
-        const hasDepsArg = (() => {
-            // Find the last ')' (closing paren of the full call)
-            const lastClosing = fullCall.lastIndexOf(')');
-            if (lastClosing === -1)
+    // As verificações estruturais (useEffect/useMemo/useCallback sem deps e hook
+    // em condicional) são imprecisas quando feitas por regex/linha e geram falsos
+    // positivos. Quando a análise por AST (`parseHooksWithBabel`) está disponível,
+    // ela é a fonte autoritativa e estas verificações devem ser ignoradas.
+    const skipStructural = opts.skipStructural === true;
+    if (!skipStructural) {
+        // Check useEffect/useLayoutEffect for deps
+        const effectMatches = [...src.matchAll(/use(Layout)?Effect\s*\(/g)];
+        effectMatches.forEach(m => {
+            const hookInicio = m.index;
+            const fullCall = extractHookCallContent(src, hookInicio + m[0].length - 1);
+            // More robust deps detection: find the last comma followed by an array or identifier before the closing paren
+            const hasDepsArg = (() => {
+                // Find the last ')' (closing paren of the full call)
+                const lastClosing = fullCall.lastIndexOf(')');
+                if (lastClosing === -1)
+                    return false;
+                const beforeClosing = fullCall.slice(0, lastClosing);
+                // Find the last '[' or identifier before the closing paren
+                const arrayMatch = beforeClosing.match(/,\s*(\[[\s\S]*?\])\s*$/);
+                if (arrayMatch)
+                    return true;
+                const identMatch = beforeClosing.match(/,\s*(\w+)\s*$/);
+                if (identMatch)
+                    return true;
                 return false;
-            const beforeClosing = fullCall.slice(0, lastClosing);
-            // Find the last '[' or identifier before the closing paren
-            const arrayMatch = beforeClosing.match(/,\s*(\[[\s\S]*?\])\s*$/);
-            if (arrayMatch)
-                return true;
-            const identMatch = beforeClosing.match(/,\s*(\w+)\s*$/);
-            if (identMatch)
-                return true;
-            return false;
-        })();
-        const skip = /no-deps-ok|eslint-disable-next-line\s+react-hooks\/exhaustive-deps/i.test(fullCall);
-        if (!hasDepsArg && !skip) {
-            const line = lineOf(hookInicio);
-            ocorrencias.push(warn(messages.ReactHooksMensagens.useEffectNoDeps, relPath, line));
-        }
-        if (hasDepsArg && /\[\s*\]/.test(fullCall)) {
-            const bodyWithRefs = fullCall.match(/^[\s\S]*?(?=,\s*\[)/);
-            if (bodyWithRefs) {
-                const varRefs = bodyWithRefs[0].match(/\b([a-z]\w+)\b/g) ?? [];
-                const nonTrivialRefs = varRefs.filter(v => !/^(set|use)/.test(v) && v.length > 1 && !['undefined', 'null', 'true', 'false'].includes(v));
-                if (nonTrivialRefs.length > 0) {
-                    const line = lineOf(hookInicio);
-                    ocorrencias.push(warn('Empty deps array but effect references component variables', relPath, line));
+            })();
+            const skip = /no-deps-ok|eslint-disable-next-line\s+react-hooks\/exhaustive-deps/i.test(fullCall);
+            if (!hasDepsArg && !skip) {
+                const line = lineOf(hookInicio);
+                ocorrencias.push(warn(messages.ReactHooksMensagens.useEffectNoDeps, relPath, line));
+            }
+            if (hasDepsArg && /\[\s*\]/.test(fullCall)) {
+                const bodyWithRefs = fullCall.match(/^[\s\S]*?(?=,\s*\[)/);
+                if (bodyWithRefs) {
+                    const varRefs = bodyWithRefs[0].match(/\b([a-z]\w+)\b/g) ?? [];
+                    const nonTrivialRefs = varRefs.filter(v => !/^(set|use)/.test(v) && v.length > 1 && !['undefined', 'null', 'true', 'false'].includes(v));
+                    if (nonTrivialRefs.length > 0) {
+                        const line = lineOf(hookInicio);
+                        ocorrencias.push(warn('Empty deps array but effect references component variables', relPath, line));
+                    }
                 }
             }
-        }
-    });
-    // useMemo/useCallback deps check
-    const memoMatches = [...src.matchAll(/use(Memo|Callback)\s*\(/g)];
-    memoMatches.forEach(m => {
-        const hookInicio = m.index;
-        const fullCall = extractHookCallContent(src, hookInicio + m[0].length - 1);
-        const hasDepsArg = /,\s*(\[[\s\S]*?\]|\w+)\s*\)$/.test(fullCall);
-        const skip = /no-deps-ok|eslint-disable-next-line\s+react-hooks\/exhaustive-deps/i.test(fullCall);
-        if (!hasDepsArg && !skip) {
-            const line = lineOf(hookInicio);
-            ocorrencias.push(warn(messages.ReactHooksMensagens.memoCallbackNoDeps, relPath, line));
-        }
-    });
-    // Conditional hooks — only flag when a hook call is directly inside a conditional block,
-    // not when the conditional is inside a hook callback (e.g. cleanup inside useEffect).
-    // The regex matches: if/for/while (...) { ... useXxx ... } but limits the match scope
-    // to avoid matching conditionals that appear inside hook callbacks.
-    const conditionalHooks = [...src.matchAll(/(?:^|(?<=[\n;]))\s*(if|for|while)\s*\([^)]*\)\s*\{[\s\S]{0,160}?use[A-Z][A-Za-z0-9_]*/g)];
-    conditionalHooks.forEach(m => {
-        const line = lineOf(m.index || 0);
-        // Heuristic: skip if the 'if' keyword is preceded by a closing paren or brace at the same indentation,
-        // which suggests it's inside a callback body rather than at the component top level.
-        const pre = src.slice(Math.max(0, (m.index ?? 0) - 80), m.index ?? 0);
-        if (/=>\s*$|\)\s*=>\s*$|\)\s*\{[\s\S]{0,40}$/.test(pre))
-            return;
-        ocorrencias.push(warn(messages.ReactHooksMensagens.hookInConditional, relPath, line));
-    });
+        });
+        // useMemo/useCallback deps check
+        const memoMatches = [...src.matchAll(/use(Memo|Callback)\s*\(/g)];
+        memoMatches.forEach(m => {
+            const hookInicio = m.index;
+            const fullCall = extractHookCallContent(src, hookInicio + m[0].length - 1);
+            const hasDepsArg = /,\s*(\[[\s\S]*?\]|\w+)\s*\)$/.test(fullCall);
+            const skip = /no-deps-ok|eslint-disable-next-line\s+react-hooks\/exhaustive-deps/i.test(fullCall);
+            if (!hasDepsArg && !skip) {
+                const line = lineOf(hookInicio);
+                ocorrencias.push(warn(messages.ReactHooksMensagens.memoCallbackNoDeps, relPath, line));
+            }
+        });
+        // Conditional hooks — only flag when a hook call is directly inside a conditional block,
+        // not when the conditional is inside a hook callback (e.g. cleanup inside useEffect).
+        // The regex matches: if/for/while (...) { ... useXxx ... } but limits the match scope
+        // to avoid matching conditionals that appear inside hook callbacks.
+        const conditionalHooks = [...src.matchAll(/(?:^|(?<=[\n;]))\s*(if|for|while)\s*\([^)]*\)\s*\{[\s\S]{0,160}?use[A-Z][A-Za-z0-9_]*/g)];
+        conditionalHooks.forEach(m => {
+            const line = lineOf(m.index || 0);
+            // Heuristic: skip if the 'if' keyword is preceded by a closing paren or brace at the same indentation,
+            // which suggests it's inside a callback body rather than at the component top level.
+            const pre = src.slice(Math.max(0, (m.index ?? 0) - 80), m.index ?? 0);
+            if (/=>\s*$|\)\s*=>\s*$|\)\s*\{[\s\S]{0,40}$/.test(pre))
+                return;
+            ocorrencias.push(warn(messages.ReactHooksMensagens.hookInConditional, relPath, line));
+        });
+    } // fim de if (!skipStructural)
     // React 19: useOptimistic detected
     for (const match of src.matchAll(/\buseOptimistic\s*\(/g)) {
         const line = lineOf(match.index);
@@ -188,16 +195,12 @@ function collectHookIssues(src, relPath) {
         const line = lineOf(match.index);
         ocorrencias.push(warn('useFormStatus (React 19) detected - access pending form state', relPath, line, messages.SeverityNiveis.info));
     }
-    // React 19: use() hook - suspends, must be in Suspense boundary
-    for (const match of src.matchAll(/\buse\s*\(/g)) {
-        const line = lineOf(match.index);
-        // Avoid matching "useState", "useEffect", etc.
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- runtime safety for match.index === 0
-        if (src[match.index - 1]?.match(/[a-zA-Z]/)) {
-            continue;
-        }
-        ocorrencias.push(warn('React 19 use() hook detected - must be wrapped in <Suspense> boundary', relPath, line, messages.SeverityNiveis.error));
-    }
+    // React 19: use() hook - suspends, must be in Suspense boundary.
+    // OBS: esta detecção por regex é intencionalmente OMITIDA aqui porque
+    // casaria falsamente com comentários/strings (ex.: "terms-of-use (...)") e
+    // com identificadores como "reuse(" / "abuse(". O hook use() é detectado de
+    // forma precisa via AST em parseHooksWithBabel (que ignora comentários),
+    // tornando este regex redundante e gerador de falsos positivos.
     // Custom hooks naming convention
     const customHooks = [...src.matchAll(/\buse[A-Z][A-Za-z0-9_]*\s*=\s*\(/g)];
     customHooks.forEach(m => {
@@ -260,24 +263,33 @@ function parseHooksWithBabel(src, relPath) {
         const isMemoLike = (name) => name === 'useMemo' || name === 'useCallback';
         const isAnyHook = (name) => /^use[A-Z0-9_]/.test(name) || name === 'use';
         const inConditionalOrLoop = (path) => {
-            // Only consider conditionals/loops in the SAME function scope, not inside nested callbacks.
-            // Stop climbing at the nearest function boundary to avoid false positives when
-            // a hook is used inside a callback that happens to be in a conditional context.
+            // Só viola as Rules of Hooks se o hook estiver DENTRO de um
+            // if/for/while/do-while/switch/conditional no MESMO escopo de função que o
+            // contém. Condicionais em funções pais (ex.: um `if` no componente que define
+            // um hook customizado como useMusicPlayer) são válidas e NÃO devem gerar falso
+            // positivo (feedback.md seção 1.2). Callbacks aninhados (outra função) também
+            // delimitam o escopo — um condicional dentro de um callback não conta para o
+            // hook de fora.
             let current = path;
             while (current) {
-                const parent = current.findParent(p => p.isIfStatement() || p.isForStatement() || p.isWhileStatement() || p.isDoWhileStatement() || p.isSwitchStatement() || p.isConditionalExpression());
-                if (parent)
-                    return true;
-                // Climb to the nearest function boundary; stop if we hit one
-                const fnBoundary = current.findParent(p => p.isFunction());
-                if (!fnBoundary)
+                const parent = current.parentPath;
+                if (!parent) {
+                    break;
+                }
+                // Função que contém o hook: condicionais acima dela estão em escopo diferente.
+                if (parent.isFunction()) {
                     break;
-                // If the fnBoundary is the component function itself, we've exhausted this scope
-                // Check if there's a conditional ABOVE this function boundary
-                const aboveFn = fnBoundary.findParent(p => p.isIfStatement() || p.isForStatement() || p.isWhileStatement() || p.isDoWhileStatement() || p.isSwitchStatement() || p.isConditionalExpression());
-                if (aboveFn)
+                }
+                if (parent.isIfStatement()
+                    || parent.isForStatement()
+                    || parent.isWhileStatement()
+                    || parent.isDoWhileStatement()
+                    || parent.isSwitchStatement()
+                    || parent.isSwitchCase()
+                    || parent.isConditionalExpression()) {
                     return true;
-                break;
+                }
+                current = parent;
             }
             return false;
         };
@@ -388,12 +400,14 @@ function parseHooksWithBabel(src, relPath) {
                                 return !depsSet.has(r);
                             });
                             if (maybeMissing.length > 1) {
+                                // Apenas useMemo/useCallback com deps faltando são "sem array de
+                                // dependências". useEffect/useLayoutEffect QUE JÁ POSSUEM um array
+                                // de deps (mesmo que incompleto) NÃO devem ser reportados como
+                                // "sem array" — ver feedback.md seção 1.1. O aviso de stale closure
+                                // para esses casos já é emitido por outro analisador.
                                 if (isMemoLike(name)) {
                                     pushOnce(warn(messages.ReactHooksMensagens.memoCallbackNoDeps, relPath, locLine));
                                 }
-                                else {
-                                    pushOnce(warn(messages.ReactHooksMensagens.useEffectNoDeps, relPath, locLine));
-                                }
                             }
                             if (deps.elements.length === 0 && refsInCb.size > 0) {
                                 const nonTrivialRefs = [...refsInCb].filter(r => {
@@ -459,7 +473,12 @@ export const analistaReactHooks = criarAnalista({
         }
         const astMsgs = parseHooksWithBabel(src, relPath);
         if (astMsgs !== null) {
-            const regexMsgs = collectHookIssues(src, relPath);
+            // O AST é a fonte autoritativa para verificações estruturais (deps de
+            // useEffect/useMemo e hooks em condicional). Quando disponível, o regex
+            // estrutural é ignorado para evitar os falsos positivos de análise por
+            // texto (ver feedback.md seção 1.1 e 1.2). As verificações informativas
+            // do regex permanecem como rede de segurança.
+            const regexMsgs = collectHookIssues(src, relPath, { skipStructural: true });
             const all = [...astMsgs, ...regexMsgs];
             const seen = new Set();
             const deduped = all.filter(m => {

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

@@ -9,6 +9,68 @@ const D = messages.DetectorReactMensagens;
 function warn(tipo, mensagem, relPath, linha, sugestao, nivel = 'aviso') {
     return criarOcorrencia({ tipo, nivel, mensagem, relPath, linha, sugestao });
 }
+/**
+ * Decide se o valor passado a `dangerouslySetInnerHTML` é estático/controlado
+ * e, portanto, seguro o suficiente para NÃO gerar falso positivo.
+ * (ver feedback.md seção 1.3 — JSON-LD, string interna, conteúdo sanitizado).
+ *
+ * Consideramos controlado quando o valor é:
+ *  - uma string literal (estática);
+ *  - resultado de `JSON.stringify(...)` (ex.: JSON-LD / structured data);
+ *  - resultado de uma chamada de sanitização/escape (`sanitize`, `escape`,
+ *    `encode`, `secure`, etc.);
+ *  - um template literal (conteúdo estático na prática).
+ */
+function isJsonStringifyCall(node) {
+    if (!t.isCallExpression(node)) {
+        return false;
+    }
+    const callee = node.callee;
+    return t.isMemberExpression(callee)
+        && t.isIdentifier(callee.object)
+        && callee.object.name === 'JSON'
+        && t.isIdentifier(callee.property)
+        && callee.property.name === 'stringify';
+}
+function calleeName(callee) {
+    if (t.isIdentifier(callee)) {
+        return callee.name;
+    }
+    if (t.isMemberExpression(callee) && t.isIdentifier(callee.property)) {
+        return callee.property.name;
+    }
+    return '';
+}
+function isControlledDangerousHtml(expr) {
+    if (!expr || t.isJSXEmptyExpression(expr)) {
+        return true;
+    }
+    if (t.isStringLiteral(expr)) {
+        return true;
+    }
+    if (t.isTemplateLiteral(expr)) {
+        return true;
+    }
+    if (t.isCallExpression(expr)) {
+        if (isJsonStringifyCall(expr)) {
+            return true;
+        }
+        // JSON.stringify(data).replace(...) / .trim() — o objeto da chamada é JSON.stringify
+        if (t.isMemberExpression(expr.callee) && isJsonStringifyCall(expr.callee.object)) {
+            return true;
+        }
+        const name = calleeName(expr.callee);
+        if (/sanit|escape|encod|secure|trust/i.test(name)) {
+            return true;
+        }
+    }
+    // JSON.stringify(...).replace(...) — o objeto da MemberExpression é a chamada
+    // JSON.stringify, então o conteúdo é estruturado/controlado (ex.: JSON-LD).
+    if (t.isMemberExpression(expr) && isJsonStringifyCall(expr.object)) {
+        return true;
+    }
+    return false;
+}
 export const detectorReactBestPractices = {
     nome: 'detector-react-best-practices',
     categoria: 'framework',
@@ -22,12 +84,6 @@ export const detectorReactBestPractices = {
         const linhas = splitLines(src);
         linhas.forEach((linha, index) => {
             const numeroLinha = index + 1;
-            if (/dangerouslySetInnerHTML/.test(linha)) {
-                // Skip <script type="speculationrules"> — dangerouslySetInnerHTML is required
-                if (/speculationrules/i.test(linha))
-                    return;
-                ocorrencias.push(warn('react-dangerous-html', D.dangerousHtml, relPath, numeroLinha, D.dangerousHtmlSugestao, 'erro'));
-            }
             if (/onClick=|onSubmit=|onChange=|onMouseOver=/.test(linha) && /{[^}]*=>/.test(linha)) {
                 ocorrencias.push(warn('react-inline-handler', D.inlineHandler, relPath, numeroLinha, D.inlineHandlerSugestao, 'info'));
             }
@@ -62,6 +118,21 @@ export const detectorReactBestPractices = {
                 }
             }
         }
+        // Fallback conservador: quando o parse por AST falha, ainda detectamos
+        // dangerouslySetInnerHTML de forma limitada, alertando apenas quando o
+        // valor claramente vem de fonte externa/não controlada (props, params,
+        // localStorage, fetch, location, etc). Conteúdo estático/controlado é
+        // ignorado (ver feedback.md seção 1.3 - ex.: JSON-LD).
+        if (!deeper) {
+            linhas.forEach((linha, index) => {
+                if (/dangerouslySetInnerHTML/.test(linha) && !/speculationrules/i.test(linha)) {
+                    const numeroLinha = index + 1;
+                    if (/\b(props|params|query|searchParams|localStorage|sessionStorage|fetch\(|\blocation\b|window\.|document\.cookie|req\.|res\.)/.test(linha)) {
+                        ocorrencias.push(warn('react-dangerous-html', D.dangerousHtml, relPath, numeroLinha, D.dangerousHtmlSugestao, 'aviso'));
+                    }
+                }
+            });
+        }
         return ocorrencias;
     }
 };
@@ -326,6 +397,29 @@ function detectWithBabel(src, relPath) {
                         pushOnce(warn('react-key-index', D.keyIndexUsage, relPath, locLine, D.keyIndexUsageSugestao, 'aviso'));
                     }
                 }
+                // dangerouslySetInnerHTML: só alerta quando o valor NÃO é estático/
+                // controlado (ex.: vem de props, params, fetch, localStorage). Conteúdo
+                // como JSON-LD (JSON.stringify) ou string interna é seguro e não deve
+                // gerar ruído (ver feedback.md seção 1.3).
+                if (name === 'dangerouslySetInnerHTML') {
+                    const value = path.node.value;
+                    let htmlExpr;
+                    if (t.isJSXExpressionContainer(value)) {
+                        const inner = value.expression;
+                        if (t.isObjectExpression(inner)) {
+                            const htmlProp = inner.properties?.find(p => t.isObjectProperty(p) && t.isIdentifier(p.key) && p.key.name === '__html');
+                            if (htmlProp && t.isObjectProperty(htmlProp) && !t.isPrivateName(htmlProp.value) && !t.isJSXEmptyExpression(htmlProp.value)) {
+                                htmlExpr = htmlProp.value;
+                            }
+                        }
+                        else if (t.isExpression(inner)) {
+                            htmlExpr = inner;
+                        }
+                    }
+                    if (!isControlledDangerousHtml(htmlExpr)) {
+                        pushOnce(warn('react-dangerous-html', D.dangerousHtml, relPath, locLine, D.dangerousHtmlSugestao, 'aviso'));
+                    }
+                }
             },
             MemberExpression(path) {
                 const locLine = path.node.loc?.start.line;

package/dist/cli/commands/command-perf.js

@@ -13,7 +13,7 @@ async function obterCommit() {
     try {
         // usar helper seguro
         const { executarShellSeguro } = await import('../../core/utils/index.js');
-        return executarShellSeguro('git rev-parse --short HEAD', {
+        return executarShellSeguro('git', ['rev-parse', '--short', 'HEAD'], {
             stdio: ['ignore', 'pipe', 'ignore']
         }).toString().trim();
     }

package/dist/cli/commands/command-update.js

@@ -38,9 +38,10 @@ export function comandoAtualizar(aplicarFlagsGlobais) {
                 log.aviso(CliAtualizarExtraMensagens.guardianBaselineAlterado);
                 log.info(CliAtualizarExtraMensagens.recomendadoGuardianDiff);
             }
-            const cmd = opts.global ? 'npm install -g mahoraga@latest' : 'npm install mahoraga@latest';
+            const cmd = opts.global ? 'npm install -g @mocoto/mahoraga@latest' : 'npm install @mocoto/mahoraga@latest';
             logSistema.atualizacaoExecutando(cmd);
-            executarShellSeguro(cmd, {
+            const npmArgs = opts.global ? ['install', '-g', '@mocoto/mahoraga@latest'] : ['install', '@mocoto/mahoraga@latest'];
+            executarShellSeguro('npm', npmArgs, {
                 stdio: 'inherit'
             });
             logSistema.atualizacaoSucesso();

package/dist/core/config/auto/auto-fix-config.js

@@ -35,6 +35,9 @@ export const AGRESSIVA_AUTO_CORRECAO_CONFIGURACAO = {
 // Backwards compat constant name used elsewhere in the codebase
 export const AUTO_CORRECAO_CONFIGURACAO_PADROES = PADRAO_AUTO_CORRECAO_CONFIGURACAO;
 export function shouldExcludeFile(fileCaminho, config) {
+    if (!config.excludePadroes || !Array.isArray(config.excludePadroes)) {
+        return false;
+    }
     return config.excludePadroes.some(pattern => {
         const regexPadrao = pattern.replace(/\*\*/g, '.*').replace(/\*/g, '[^/]*').replace(/\?/g, '.');
         return new RegExp(regexPadrao).test(fileCaminho);
@@ -48,7 +51,10 @@ export function shouldExcludeFunction(functionName, config) {
 }
 export function isCategoryAllowed(category, config) {
     // allowedCategories is an array of known category strings - coerce to string[] for safe includes check
-    return (config.allowedCategories).includes(category);
+    if (!config.allowedCategories || !Array.isArray(config.allowedCategories)) {
+        return true;
+    }
+    return config.allowedCategories.includes(category);
 }
 export function hasMinimumConfidence(confidence, config) {
     if (typeof config.minConfidence !== 'number') {
@@ -63,9 +69,8 @@ export function getAutoFixConfig(mode) {
         case 'aggressive':
             return AGRESSIVA_AUTO_CORRECAO_CONFIGURACAO;
         case 'balanced':
-        case undefined: {
-            throw new Error('Not implemented yet: undefined case');
-        }
+        case undefined:
+            return PADRAO_AUTO_CORRECAO_CONFIGURACAO;
         default:
             return PADRAO_AUTO_CORRECAO_CONFIGURACAO;
     }

package/dist/core/config/config.js

@@ -110,7 +110,7 @@ export const configPadrao = {
     ANALISE_INCREMENTAL_ENABLED: false,
     ANALISE_INCREMENTAL_STATE_PATH: path.join(SUKUNA_ESTADO, 'incremental-analise.json'),
     ANALISE_INCREMENTAL_VERSION: 1,
-    ANALISE_CACHE_ENABLED: true,
+    ANALISE_CACHE_ENABLED: false,
     ANALISE_CACHE_STATE_PATH: path.join(SUKUNA_ESTADO, 'analysis-cache.json'),
     ANALISE_CACHE_VERSION: 1,
     ANALISE_CACHE_TTL_MS: 86400000,

package/dist/core/messages/en/core/formatters-messages.js

@@ -13,6 +13,7 @@ export const FormattersMensagens = {
 };
 export const ExecSafeMensagens = {
     safeModeBloqueado: 'Command execution disabled in SAFE_MODE. Set SUKUNA_ALLOW_EXEC=1 to allow it.',
+    binarioNaoPermitido: (bin) => `Binary '${bin}' is not in the allowed list.`,
 };
 export const WorkerExecutorMensagens = {
     timeoutTecnica: (nome, ms) => `Timeout: technique '${nome}' exceeded ${ms}ms`,

package/dist/core/messages/ja/core/formatters-messages.js

@@ -13,6 +13,7 @@ export const FormattersMensagens = {
 };
 export const ExecSafeMensagens = {
     safeModeBloqueado: 'SAFE_MODEではコマンド実行が無効です。許可するには SUKUNA_ALLOW_EXEC=1 を設定してください。',
+    binarioNaoPermitido: (bin) => `バイナリ '${bin}' は許可リストに含まれていません。`,
 };
 export const WorkerExecutorMensagens = {
     timeoutTecnica: (nome, ms) => `タイムアウト: 手法 '${nome}' が ${ms}ms を超えました`,

package/dist/core/messages/pt/core/formatters-messages.js

@@ -21,6 +21,7 @@ export const FormattersMensagens = {
 };
 export const ExecSafeMensagens = {
     safeModeBloqueado: 'Execução de comandos desabilitada em SAFE_MODE. Defina SUKUNA_ALLOW_EXEC=1 para permitir.',
+    binarioNaoPermitido: (bin) => `Binário '${bin}' não está na lista de permitidos.`,
 };
 export const WorkerExecutorMensagens = {
     timeoutTecnica: (nome, ms) => `Timeout: tecnica '${nome}' excedeu ${ms}ms`,