@mocoto/mahoraga 0.14.1 → 0.14.3

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

@@ -20,7 +20,6 @@ function collectGeneralRustIssues(src, relPath) {
     const ocorrencias = [];
     const lineOf = createLineLookup(src).lineAt;
     const scan = maskRustComments(src);
-    // Missing module-level comment
     const firstItem = scan.match(/^\s*(?:pub\s+)?(?:fn|mod|struct|enum|trait|impl)\s+\w+/m);
     if (firstItem) {
         const srcBefore = src.slice(0, firstItem.index ?? 0);
@@ -29,7 +28,6 @@ function collectGeneralRustIssues(src, relPath) {
             ocorrencias.push(warn('Module or crate missing documentation comment (//! or /*! */)', relPath, line, messages.SeverityNiveis.suggestion));
         }
     }
-    // Snake case convention for functions
     for (const match of scan.matchAll(/^\s*(?:pub\s+)?fn\s+(\w+)\s*\(/gm)) {
         const fnName = match[1];
         if (/[A-Z]/.test(fnName)) {
@@ -37,7 +35,6 @@ function collectGeneralRustIssues(src, relPath) {
             ocorrencias.push(warn(`Function '${fnName}' should follow snake_case convention`, relPath, line, messages.SeverityNiveis.suggestion));
         }
     }
-    // PascalCase for types
     for (const match of scan.matchAll(/^\s*(?:pub\s+)?(?:struct|enum|trait|type)\s+(\w+)/gm)) {
         const typeName = match[1];
         if (/^[a-z_]/.test(typeName)) {
@@ -45,7 +42,6 @@ function collectGeneralRustIssues(src, relPath) {
             ocorrencias.push(warn(`Type '${typeName}' should follow PascalCase convention`, relPath, line, messages.SeverityNiveis.suggestion));
         }
     }
-    // Deep nesting
     let maxDepth = 0;
     const lines = src.split('\n');
     for (const line of lines) {
@@ -56,12 +52,63 @@ function collectGeneralRustIssues(src, relPath) {
     if (maxDepth > 8) {
         ocorrencias.push(warn(`Deep nesting detected (${maxDepth} levels); consider refactoring`, relPath, 1, messages.SeverityNiveis.suggestion));
     }
+    // detect Lazy/OnceCell from once_cell crate -> suggest std::sync::LazyLock (Rust 1.80+)
+    for (const match of scan.matchAll(/\b(once_cell::sync::Lazy|once_cell::sync::OnceCell)\b/g)) {
+        const line = lineOf(match.index);
+        const isLazy = match[1].includes('Lazy');
+        ocorrencias.push(warn(isLazy
+            ? `'once_cell::sync::Lazy' detected; use std::sync::LazyLock (stable since Rust 1.80)`
+            : `'once_cell::sync::OnceCell' detected; use std::sync::OnceLock (stable since Rust 1.70)`, relPath, line, messages.SeverityNiveis.suggestion));
+    }
+    // detect manual offset calculation -> suggest std::mem::offset_of! (Rust 1.77+)
+    for (const match of scan.matchAll(/offset_of!\(/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn('offset_of! macro usage is correct for Rust 1.77+', relPath, line, messages.SeverityNiveis.info));
+    }
+    // detect manual transmute-like offset patterns
+    for (const match of scan.matchAll(/(\w+) as \*const u8\)\.offset\((\d+)\)/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn('Manual pointer offset for field access; consider std::mem::offset_of! (Rust 1.77+)', relPath, line, messages.SeverityNiveis.suggestion));
+    }
+    // detect assert!(matches!(...)) -> suggest assert_matches! (Rust 1.81+)
+    for (const match of scan.matchAll(/assert!\(matches!\(/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn('assert!(matches!(...)) pattern; consider assert_matches!(...) (unstable, nightly only)', relPath, line, messages.SeverityNiveis.info));
+    }
+    // detect if let ... && let ... (let_chains, stable since Rust 1.78)
+    for (const match of scan.matchAll(/if\s+let\s+\w+\s*=\s*\w+\s*&&\s*let\s+/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn('let_chains pattern detected (stable since Rust 1.78)', relPath, line, messages.SeverityNiveis.info));
+    }
+    // detect is_some_and / is_ok_and (stable since Rust 1.70)
+    for (const match of scan.matchAll(/\.is_some\(\)\s*&&\s*\w+\s*==/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn('.is_some() && predicate pattern; consider .is_some_and(|x| ...) (Rust 1.70+)', relPath, line, messages.SeverityNiveis.suggestion));
+    }
+    for (const match of scan.matchAll(/\.is_ok\(\)\s*&&\s*\w+\s*==/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn('.is_ok() && predicate pattern; consider .is_ok_and(|x| ...) (Rust 1.70+)', relPath, line, messages.SeverityNiveis.suggestion));
+    }
+    // detect Option::inspect / Result::inspect (stable since Rust 1.76)
+    for (const match of scan.matchAll(/\.map\(.*\|x\|.*\{[\s\S]{0,100}println!.*\}\)/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn('map() with side-effect closure; consider .inspect() (Rust 1.76+)', relPath, line, messages.SeverityNiveis.suggestion));
+    }
+    // detect string interpolation for format args (Rust 1.80+)
+    for (const match of scan.matchAll(/format!\(["']\{[\w:?]*\}["'],\s*(\w+)\)/g)) {
+        const line = lineOf(match.index);
+        const varName = match[1];
+        if (varName !== match[0].match(/\{(\w+)\}/)?.[1]) {
+            // suggest captured identifier format
+            ocorrencias.push(warn(`format!("{varName}") could be simplified to format!("{varName}") using captured identifiers (Rust 1.80+)`, relPath, line, messages.SeverityNiveis.info));
+        }
+    }
     return ocorrencias;
 }
 export const analistaRust = criarAnalista({
     nome: 'analista-rust',
     categoria: 'linguagem',
-    descricao: 'Analisa código Rust em busca de convenções de nomenclatura e organização.',
+    descricao: 'Analisa código Rust: convenções, nomenclatura, padrões modernos (edition 2024).',
     global: false,
     test: (relPath) => isRustFile(relPath),
     aplicar: (src, relPath) => {

package/dist/analysts/rust/analysts/analyst-security.js

@@ -51,12 +51,40 @@ function collectSecurityIssues(src, relPath) {
         const line = lineOf(match.index);
         ocorrencias.push(warn(`Unsafe ${match[1]} declaration; document safety invariants with // SAFETY:`, relPath, line, messages.SeverityNiveis.error));
     }
+    // pointer::cast instead of `as` pointer cast (Rust 1.72+)
+    for (const match of scan.matchAll(/\b(\w+)\s+as\s+\*const\s+\w+/g)) {
+        const line = lineOf(match.index);
+        if (!match[0].includes('as *const u8')) {
+            ocorrencias.push(warn('Using `as` for pointer cast; consider .pointer::cast::<T>() or .cast() (Rust 1.72+)', relPath, line, messages.SeverityNiveis.suggestion));
+        }
+    }
+    // Command::new with shell injection risk
+    for (const match of scan.matchAll(/Command::new\(["'](sh|bash|cmd|powershell)["']\)/g)) {
+        const line = lineOf(match.index);
+        const argsMatch = src.slice(match.index, match.index + 200).match(/\.arg\(/);
+        if (argsMatch) {
+            ocorrencias.push(warn('Shell invocation via Command; ensure no injection via user input', relPath, line, messages.SeverityNiveis.error));
+        }
+    }
+    // detect .ok()?.unwrap() antipattern
+    for (const match of scan.matchAll(/\.ok\(\)\?\.unwrap\(\)/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn('.ok()?.unwrap() antipattern; use ? directly on Result instead', relPath, line, messages.SeverityNiveis.warning));
+    }
+    // detect splitn / split_once with manual index access instead of destructuring (Rust 1.62+ split_once stable)
+    for (const match of scan.matchAll(/\.splitn\(2,\s*/g)) {
+        const line = lineOf(match.index);
+        const afterSplit = src.slice(match.index, match.index + 100);
+        if (afterSplit.includes('[0]') || afterSplit.includes('[1]')) {
+            ocorrencias.push(warn('splitn(2, ...) with index access; consider .split_once() for cleaner destructuring (Rust 1.62+)', relPath, line, messages.SeverityNiveis.suggestion));
+        }
+    }
     return ocorrencias;
 }
 export const analistaRustSeguranca = criarAnalista({
     nome: 'analista-rust-seguranca',
     categoria: 'seguranca',
-    descricao: 'Detecta problemas de segurança e unsafe em código Rust.',
+    descricao: 'Detecta problemas de segurança e unsafe em Rust (edition 2024).',
     global: false,
     test: (relPath) => /\.(rs)$/i.test(relPath),
     aplicar: (src, relPath) => {

package/dist/analysts/scorers/scorer.js

@@ -166,7 +166,7 @@ export function pontuarTodos(arquivos) {
         const resultado = scoreArquetipo(def, arquivos);
         resultados.push(resultado);
         if (resultado.candidatoExtra) {
-            const extra = ARQUETIPOS.find((arquivo) => arquivo.nome === resultado.candidatoExtra);
+            const extra = ARQUETIPOS?.find((arquivo) => arquivo.nome === resultado.candidatoExtra);
             if (extra) {
                 const extraResultado = scoreArquetipo(extra, arquivos);
                 if (!resultados.some(x => x.nome === extraResultado.nome)) {
@@ -189,9 +189,9 @@ export function scoreArquetipoAvancado(def, arquivos, sinaisAvancados) {
     // Clona o resultado base para adicionar análises avançadas
     let score = resultadoBase.score;
     let explicacao = resultadoBase.explicacaoSimilaridade ?? '';
-    const frameworks = sinaisAvancados.frameworksDetectados || [];
-    const deps = sinaisAvancados.dependencias || [];
-    const scripts = sinaisAvancados.scripts || [];
+    const frameworks = sinaisAvancados.frameworksDetectados;
+    const deps = sinaisAvancados.dependencias;
+    const scripts = sinaisAvancados.scripts;
     const detalhes = sinaisAvancados.detalhes ?? {};
     // BONUS INTELIGENTE: Considerar sinais avançados para pontuação contextual
     score += calcularBonusContextual(def, sinaisAvancados);
@@ -602,7 +602,7 @@ export function pontuarTodosAvancado(arquivos, sinaisAvancados) {
         const resultado = scoreArquetipoAvancado(def, arquivos, sinaisAvancados);
         resultados.push(resultado);
         if (resultado.candidatoExtra) {
-            const extra = ARQUETIPOS.find((arquivo) => arquivo.nome === resultado.candidatoExtra);
+            const extra = ARQUETIPOS?.find((arquivo) => arquivo.nome === resultado.candidatoExtra);
             if (extra) {
                 const extraResultado = scoreArquetipoAvancado(extra, arquivos, sinaisAvancados);
                 if (!resultados.some(x => x.nome === extraResultado.nome)) {

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

@@ -24,7 +24,7 @@ export const analistaShell = criarAnalista({
                 sugestao: messages.AnalistaShellMensagens.missingShebangSugestao
             }));
         }
-        // 2. Verificar 'set -e' ou 'set -o pipefail' (Tratamento de Erros)
+        // 2. Verificar 'set -euo pipefail' (Tratamento de Erros + strict mode)
         const srcCompleto = src.toLowerCase();
         if (!srcCompleto.includes('set -e') && !srcCompleto.includes('set -o pipefail')) {
             ocorrencias.push(criarOcorrencia({
@@ -36,6 +36,84 @@ export const analistaShell = criarAnalista({
                 sugestao: messages.AnalistaShellMensagens.missingSetESugestao
             }));
         }
+        // 2b. Verificar 'set -u'
+        if (!srcCompleto.includes('set -u')) {
+            ocorrencias.push(criarOcorrencia({
+                tipo: 'codigo-fragil',
+                nivel: 'info',
+                mensagem: messages.AnalistaShellMensagens.missingSetU,
+                relPath,
+                linha: 1,
+                sugestao: messages.AnalistaShellMensagens.missingSetUSugestao
+            }));
+        }
+        // 2c. Verificar IFS=$'\n\t'
+        if (!src.includes('IFS=')) {
+            ocorrencias.push(criarOcorrencia({
+                tipo: 'codigo-fragil',
+                nivel: 'info',
+                mensagem: messages.AnalistaShellMensagens.missingIso,
+                relPath,
+                linha: 1,
+                sugestao: messages.AnalistaShellMensagens.missingIsoSugestao
+            }));
+        }
+        // 2d. Verificar trap handler
+        if (!src.includes('trap ')) {
+            ocorrencias.push(criarOcorrencia({
+                tipo: 'boa-pratica-ausente',
+                nivel: 'info',
+                mensagem: messages.AnalistaShellMensagens.missingTrap,
+                relPath,
+                linha: 1,
+                sugestao: messages.AnalistaShellMensagens.missingTrapSugestao
+            }));
+        }
+        // 2e. Verificar main function pattern
+        if (!src.includes('main()') && !src.includes('main ()')) {
+            ocorrencias.push(criarOcorrencia({
+                tipo: 'boa-pratica-ausente',
+                nivel: 'info',
+                mensagem: messages.AnalistaShellMensagens.missingMainFn,
+                relPath,
+                linha: linhas.length,
+                sugestao: messages.AnalistaShellMensagens.missingMainFnSugestao
+            }));
+        }
+        // 2f. Verificar command -v usage for hardcoded paths
+        if (/(\/usr\/bin\/|\/bin\/|\/usr\/local\/bin\/)/.test(src) && !src.includes('command -v')) {
+            ocorrencias.push(criarOcorrencia({
+                tipo: 'boa-pratica-ausente',
+                nivel: 'info',
+                mensagem: messages.AnalistaShellMensagens.missingCommandV,
+                relPath,
+                linha: 1,
+                sugestao: messages.AnalistaShellMensagens.missingCommandVSugestao
+            }));
+        }
+        // 2g. Verificar DEBUG mode
+        if (!src.includes('${DEBUG:-}') && !src.includes('$DEBUG')) {
+            ocorrencias.push(criarOcorrencia({
+                tipo: 'boa-pratica-ausente',
+                nivel: 'info',
+                mensagem: messages.AnalistaShellMensagens.missingDebugMode,
+                relPath,
+                linha: 1,
+                sugestao: messages.AnalistaShellMensagens.missingDebugModeSugestao
+            }));
+        }
+        // 2h. Verificar input validation
+        const hasUsageCheck = /\[\[ -z "\$[0-9*@]/.test(src) || /\[ -z "\$[0-9*@]/.test(src) || src.includes('Usage:') || src.includes('usage:');
+        if (!hasUsageCheck && /\$[0-9]/.test(src)) {
+            ocorrencias.push(criarOcorrencia({
+                tipo: 'boa-pratica-ausente',
+                nivel: 'info',
+                mensagem: messages.AnalistaShellMensagens.missingInputValidation,
+                relPath,
+                linha: 1,
+                sugestao: messages.AnalistaShellMensagens.missingInputValidationSugestao
+            }));
+        }
         linhas.forEach((linha, index) => {
             const numeroLinha = index + 1;
             const linhaTrim = linha.trim();
@@ -55,9 +133,7 @@ export const analistaShell = criarAnalista({
                 }));
             }
             // 4. Variáveis não aspeadas (Fragilidade)
-            // Detecta patterns como $VAR sem aspas (ex: echo $USER, mas ignora em loops/condicionais complexas)
             if (/\$(\w+)\b/.test(linha) && !/["'].*\$\w+.*["']/.test(linha) && !/\$\(.*\)/.test(linha) && !/^\s*(for|while|if|case|read)\s+/.test(linhaTrim)) {
-                // Heurística simples: se a variável aparece sozinha ou em comando comum
                 if (/\b(echo|ls|cd|rm|cp|mv)\s+.*\$\w+/.test(linhaTrim)) {
                     ocorrencias.push(criarOcorrencia({
                         tipo: 'codigo-fragil',
@@ -73,7 +149,7 @@ export const analistaShell = criarAnalista({
             if (/\brm\s+-rf\s+\/(\s|$|['"`])/.test(linha)) {
                 ocorrencias.push(criarOcorrencia({
                     tipo: 'vulnerabilidade-seguranca',
-                    nivel: 'critica',
+                    nivel: 'erro',
                     mensagem: messages.AnalistaShellMensagens.rmRfRoot,
                     relPath,
                     linha: numeroLinha,
@@ -84,7 +160,7 @@ export const analistaShell = criarAnalista({
             if (/(curl|wget).*(|\s)sh(\s|$)/.test(linha)) {
                 ocorrencias.push(criarOcorrencia({
                     tipo: 'vulnerabilidade-seguranca',
-                    nivel: 'alta',
+                    nivel: 'erro',
                     mensagem: messages.AnalistaShellMensagens.curlPipeSh,
                     relPath,
                     linha: numeroLinha,

package/dist/analysts/shell/corrections/correction-shell.js

@@ -25,12 +25,45 @@ export function detectarCorrecoesShell(src, _relPath) {
     if (!/set\s+(-e|-o\s+pipefail)/.test(src)) {
         correcoes.push({
             tipo: 'shell-add-set-e',
-            original: 'Sem set -e',
+            original: 'Sem set -euo pipefail',
             sugerido: 'set -euo pipefail',
             linha: 2,
             confianca: 90
         });
     }
+    // Add set -u if missing
+    if (!/set\s+-u/.test(src)) {
+        const linhaSetE = src.match(/set\s+(-e\b)/);
+        const sugestao = linhaSetE ? 'set -euo pipefail' : 'set -u';
+        const linha = linhaSetE ? 2 : 1;
+        correcoes.push({
+            tipo: 'shell-add-set-u',
+            original: 'Sem set -u',
+            sugerido: sugestao,
+            linha,
+            confianca: 85
+        });
+    }
+    // Add IFS if missing
+    if (!/IFS=/.test(src)) {
+        correcoes.push({
+            tipo: 'shell-add-ifs',
+            original: 'Sem IFS',
+            sugerido: "IFS=$'\\n\\t'",
+            linha: 3,
+            confianca: 80
+        });
+    }
+    // Add trap if missing
+    if (!/\btrap\s+/.test(src) && linhas.length > 5) {
+        correcoes.push({
+            tipo: 'shell-add-trap',
+            original: 'Sem trap handler',
+            sugerido: 'trap "cleanup" EXIT INT TERM',
+            linha: linhas.length + 1,
+            confianca: 75
+        });
+    }
     linhas.forEach((linha, index) => {
         const numeroLinha = index + 1;
         if (/\b(echo|ls|cd|rm|cp|mv)\s+.*\$\w+/.test(linha) && !/["'].*\$\w+.*["']/.test(linha)) {

package/dist/analysts/shell/detectors/detector-shell-security.js

@@ -57,6 +57,94 @@ export const detectorShellSecurity = {
                 sugestao: messages.DetectorShellMensagens.unsafePipefailSugestao
             }));
         }
+        // set -u (treat unset variables as error)
+        if (!/set\s+-u/.test(src)) {
+            ocorrencias.push(criarOcorrencia({
+                tipo: 'shell-missing-set-u',
+                nivel: 'info',
+                mensagem: messages.DetectorShellMensagens.missingSetU,
+                relPath,
+                linha: 1,
+                sugestao: messages.DetectorShellMensagens.missingSetUSugestao
+            }));
+        }
+        // IFS=$'\n\t'
+        if (!/IFS=/.test(src)) {
+            ocorrencias.push(criarOcorrencia({
+                tipo: 'shell-missing-ifs',
+                nivel: 'info',
+                mensagem: messages.DetectorShellMensagens.missingIso,
+                relPath,
+                linha: 1,
+                sugestao: messages.DetectorShellMensagens.missingIsoSugestao
+            }));
+        }
+        // Trap handler
+        if (!/\btrap\s+/.test(src)) {
+            ocorrencias.push(criarOcorrencia({
+                tipo: 'shell-missing-trap',
+                nivel: 'info',
+                mensagem: messages.DetectorShellMensagens.missingTrap,
+                relPath,
+                linha: 1,
+                sugestao: messages.DetectorShellMensagens.missingTrapSugestao
+            }));
+        }
+        // Main function pattern
+        if (!/main\s*\(\s*\)/.test(src) && !/^main\s*\(/m.test(src)) {
+            ocorrencias.push(criarOcorrencia({
+                tipo: 'shell-missing-main-fn',
+                nivel: 'info',
+                mensagem: messages.DetectorShellMensagens.missingMainFn,
+                relPath,
+                linha: linhas.length,
+                sugestao: messages.DetectorShellMensagens.missingMainFnSugestao
+            }));
+        }
+        // Hardcoded paths without command -v
+        if (/(\/usr\/bin\/|\/bin\/|\/usr\/local\/bin\/)/.test(src) && !/command\s+-v/.test(src)) {
+            ocorrencias.push(criarOcorrencia({
+                tipo: 'shell-missing-command-v',
+                nivel: 'info',
+                mensagem: messages.DetectorShellMensagens.missingCommandV,
+                relPath,
+                linha: 1,
+                sugestao: messages.DetectorShellMensagens.missingCommandVSugestao
+            }));
+        }
+        // DEBUG mode
+        if (!/\$\{DEBUG[^}]*\}/.test(src) && !/\$DEBUG\b/.test(src)) {
+            ocorrencias.push(criarOcorrencia({
+                tipo: 'shell-missing-debug-mode',
+                nivel: 'info',
+                mensagem: messages.DetectorShellMensagens.missingDebugMode,
+                relPath,
+                linha: 1,
+                sugestao: messages.DetectorShellMensagens.missingDebugModeSugestao
+            }));
+        }
+        // Input validation
+        if (/\$[0-9@*]/.test(src) && !/\[\[ -z "\$[0-9@*]/.test(src) && !/\[ -z "\$[0-9@*]/.test(src)) {
+            ocorrencias.push(criarOcorrencia({
+                tipo: 'shell-missing-input-validation',
+                nivel: 'info',
+                mensagem: messages.DetectorShellMensagens.missingInputValidation,
+                relPath,
+                linha: 1,
+                sugestao: messages.DetectorShellMensagens.missingInputValidationSugestao
+            }));
+        }
+        // ShellCheck recommendation (only if script is non-trivial)
+        if (linhas.length > 10 && !src.includes('shellcheck')) {
+            ocorrencias.push(criarOcorrencia({
+                tipo: 'shellcheck-recommended',
+                nivel: 'info',
+                mensagem: messages.DetectorShellMensagens.shellCheckRecommended,
+                relPath,
+                linha: 1,
+                sugestao: messages.DetectorShellMensagens.shellCheckRecommendedSugestao
+            }));
+        }
         const isSh = /\/bin\/sh(\s|$)/.test(shebang);
         linhas.forEach((linha, index) => {
             const numeroLinha = index + 1;

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

@@ -12,7 +12,7 @@
 import { splitLines } from '../../../shared/helpers/index.js';
 export function pontuarShell(src, _relPath) {
     let score = 0;
-    const maxScore = 200;
+    const maxScore = 280;
     const issues = [];
     const strengths = [];
     const linhas = splitLines(src);
@@ -33,6 +33,30 @@ export function pontuarShell(src, _relPath) {
     else {
         issues.push('Sem set -e / pipefail');
     }
+    // set -u (10 pontos)
+    if (/set\s+-u/.test(srcCompleto)) {
+        score += 10;
+        strengths.push('Strict mode (set -u)');
+    }
+    else {
+        issues.push('Sem set -u');
+    }
+    // IFS (5 pontos)
+    if (/IFS=/.test(srcCompleto)) {
+        score += 5;
+        strengths.push('IFS configurado');
+    }
+    else {
+        issues.push('Sem IFS');
+    }
+    // trap handler (10 pontos)
+    if (/\btrap\s+/.test(srcCompleto)) {
+        score += 10;
+        strengths.push('Cleanup handler presente');
+    }
+    else {
+        issues.push('Sem trap handler');
+    }
     // No eval (15 pontos)
     if (!/\beval\s+/.test(srcCompleto)) {
         score += 15;
@@ -218,6 +242,39 @@ export function pontuarShell(src, _relPath) {
     else {
         issues.push('sudo detectado');
     }
+    // ── Modern Bash (2026) ──────────────────────────────────────────
+    // main function pattern (5 pontos)
+    if (/main\s*\(\s*\)/.test(srcCompleto)) {
+        score += 5;
+        strengths.push('Função main presente');
+    }
+    else {
+        issues.push('Sem padrão de função main');
+    }
+    // command -v usage (5 pontos)
+    if (hardPaths === 0 || /command\s+-v/.test(srcCompleto)) {
+        score += 5;
+        strengths.push('Uso de command -v');
+    }
+    else {
+        issues.push('Caminhos fixos sem command -v');
+    }
+    // DEBUG mode (5 pontos)
+    if (/\$\{DEBUG[^}]*\}/.test(srcCompleto) || /\$DEBUG\b/.test(srcCompleto)) {
+        score += 5;
+        strengths.push('Modo debug presente');
+    }
+    else {
+        issues.push('Sem modo debug');
+    }
+    // Input validation (5 pontos)
+    if (/\[\[ -z "\$[0-9@*]/.test(srcCompleto) || /\[ -z "\$[0-9@*]/.test(srcCompleto)) {
+        score += 5;
+        strengths.push('Validação de input');
+    }
+    else if (/\$[0-9]/.test(srcCompleto)) {
+        issues.push('Sem validação de argumentos');
+    }
     return {
         score,
         maxScore,

package/dist/analysts/strategists/operator-structure.js

@@ -55,12 +55,10 @@ export const OperarioEstrutura = {
                     } : {})
                 }, sinaisAvancados // Passar sinais avançados para inteligência contextual
                 );
-                if (planoAlt && Array.isArray(planoAlt.mover)) {
-                    return {
-                        plano: planoAlt,
-                        origem: 'estrategista'
-                    };
-                }
+                return {
+                    plano: planoAlt,
+                    origem: 'estrategista'
+                };
             }
             catch (erro) {
                 log.aviso(MENSAGENS_ARQUETIPOS_HANDLER.falhaEstrategista);
@@ -109,7 +107,7 @@ export const OperarioEstrutura = {
             return mapa;
         }
         for (const occ of ocorrencias) {
-            const rel = occ.relPath ?? occ.arquivo ?? 'arquivo desconhecido';
+            const rel = occ.relPath;
             mapa.push({
                 arquivo: rel,
                 ideal: null,

package/dist/analysts/strategists/suggestions-contextuais.js

@@ -29,7 +29,7 @@ export const analistaSugestoesContextuais = {
             // Obter package.json se disponível
             let packageJson;
             try {
-                const pkgArquivo = contexto.arquivos.find(arquivo => arquivo.relPath === 'package.json');
+                const pkgArquivo = contexto.arquivos?.find(arquivo => arquivo.relPath === 'package.json');
                 if (pkgArquivo?.content) {
                     packageJson = JSON.parse(pkgArquivo.content);
                 }
@@ -112,9 +112,12 @@ export const analistaSugestoesContextuais = {
                     case 'estrutura':
                         mensagem = messages.SugestoesContextuaisMensagens.evidenciaEstrutura(evidencia.valor, melhorResultado.tecnologia);
                         break;
+                    case 'export':
+                    case 'config':
+                    case 'script':
+                        continue;
                     default:
                         continue;
-                    // Pular outros tipos menos relevantes
                 }
                 ocorrencias.push({
                     tipo: 'evidencia_contextual',

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

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: MIT
 import { messages } from '../../../core/messages/index.js';
 import { otimizarSvgLikeSvgo, shouldSugerirOtimizacaoSvg } from '../../../shared/formatters/index.js';
 import { criarAnalista, criarOcorrencia } from '../../../types/index.js';