@mocoto/mahoraga 0.14.7 → 0.14.8

package/README.md

@@ -8,10 +8,7 @@ Proveniência e Autoria: Este documento integra o projeto @mocoto/mahoraga (lice
 
 </div>
 
-> Este projeto não está mais no GitHub. Publicado exclusivamente no npm como `@mocoto/mahoraga`.
-
-<p> Desisti de desistir do projeto, até parece que vou aceitar perder pra vocês 🤪 </p>
-<p> Caso tenha receio em ajudar com codigo você pode me ajudar ao usar e encontrar falsos postivos/negativos e me mandar relatorios por meio desse e-mail ai em baixo, me ajudaria muito, pois nem todos os erros e bugs eu consigo resolver em ambiente de desenvolvimento sendo preciso uso em produção para serem encontrados</p>
+Caso tenha receio em ajudar com codigo você pode me ajudar ao usar e encontrar falsos postivos/negativos e me mandar relatorios por meio desse e-mail ai em baixo, me ajudaria muito, pois nem todos os erros e bugs eu consigo resolver em ambiente de desenvolvimento sendo preciso uso em produção para serem encontrados
 
 [Gmail](mailto:mocoto.persona@gmail.com)
 
@@ -178,7 +175,6 @@ mahoraga atualizar --global            # auto-update
 
 ### Relatórios Profissionais
 
-- **Múltiplos formatos**: JSON, Markdown
 - **Métricas detalhadas**: complexidade ciclomática, duplicação, cobertura, performance com histórico
 - **Baseline de performance**: snapshots e comparação ao longo do tempo
 - **Scan de licenças**: verificação de dependências e geração de THIRD-PARTY-NOTICES
@@ -187,8 +183,6 @@ mahoraga atualizar --global            # auto-update
 
 ### Integrações CI/CD
 
-- **GitHub Actions**: scan de workflows, score 0-100, check runs, quality gate
-- **GitHub App**: análise automática em PRs e pushes
 - **GitLab CI / CircleCI / Jenkins / Azure Pipelines**: análise de pipelines
 - **Conversão** entre plataformas de CI/CD
 
@@ -252,9 +246,9 @@ O Mahoraga lê um arquivo `mahoraga.config.json` na raiz do seu projeto (ou vari
 |----------|-----------|--------|
 | `LOG_LEVEL` | Nível de log | `info` |
 | `LOG_ESTRUTURADO` | Logs em JSON | `false` |
-| `SUKUNA_DEBUG` | Modo debug | não definido |
-| `SUKUNA_STATE_DIR` | Diretório de estado | `.mahoraga` |
-| `SUKUNA_API_PORT` | Porta do GitHub App | `3100` |
+| `MAHORAGA_DEBUG` | Modo debug | não definido |
+| `MAHORAGA_STATE_DIR` | Diretório de estado | `.mahoraga` |
+| `MAHORAGA_API_PORT` | Porta do GitHub App | `3100` |
 | `GITHUB_APP_ID` | ID do GitHub App | não definido |
 | `GITHUB_PRIVATE_KEY` | Chave RSA do GitHub App | não definido |
 | `GITHUB_WEBHOOK_SECRET` | Webhook secret | não definido |
@@ -281,7 +275,7 @@ npm run lint           # ESLint
 | JavaScript | Babel | Nativo |
 | TypeScript | Babel | Nativo |
 | HTML | htmlparser2 | Nativo |
-| CSS | css-tree | Nativo |
+| CSS | postcss | Nativo |
 | XML | fast-xml-parser | Nativo |
 | Python | Heurístico | Nativo |
 | PHP | Heurístico | Nativo |
@@ -336,5 +330,3 @@ Dependências de terceiros listadas em [THIRD-PARTY-NOTICES.txt](./THIRD-PARTY-N
 ---
 
 **Feito para os iniciantes**
-
-**_Estou testando otypescript 7.0.2 Até o momento parece muito bom. o problema é que tive que remover o eslint porque ele nao roda com ts 7, vou esperar eles atualizar e voltar o eslint para o projeto._**

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/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/shared/icons.js

@@ -163,11 +163,11 @@ export const ICONES_ZELADOR = {
 export function getIcone(categoria, nome) {
     switch (categoria) {
         case 'nivel':
-            return ICONES_NIVEL[nome];
+            return ICONES_NIVEL[nome] ?? ICONES_NIVEL.info;
         case 'status':
-            return ICONES_STATUS[nome];
+            return ICONES_STATUS[nome] ?? ICONES_STATUS.pendente;
         case 'acao':
-            return ICONES_ACAO[nome];
+            return ICONES_ACAO[nome] ?? '[*]';
         default:
             return '[*]';
     }

package/dist/core/parsing/langs/json.js

@@ -6,9 +6,9 @@ export function parseComJson(codigo) {
     try {
         const parsed = JSON.parse(codigo);
         const info = {
-            type: Array.isArray(parsed) ? 'array' : typeof parsed,
+            type: parsed === null ? 'null' : (Array.isArray(parsed) ? 'array' : typeof parsed),
         };
-        if (typeof parsed === 'object' && !Array.isArray(parsed)) {
+        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
             const keys = Object.keys(parsed);
             info.keys = keys;
             info.depth = estimateDepth(parsed, 0);

package/dist/core/parsing/langs/typescript.js

@@ -27,6 +27,12 @@ export function parseComTypeScript(codigo, tsx = false) {
             errorRecovery: true,
             plugins: plugins
         });
+        if (ast.errors && ast.errors.length > 0) {
+            for (const err of ast.errors) {
+                logCore.erroTs(err.message ?? String(err), getCurrentParsingFile());
+            }
+            return null;
+        }
         return wrapMinimal(tsx ? 'tsx-tsc' : 'ts-tsc', {
             kind: 'SourceFile',
             statements: ast.program.body.length

package/dist/core/schema/version.js

@@ -40,7 +40,7 @@ export function criarSchemaMetadata(versao = VERSAO_ATUAL, descricaoPersonalizad
 export function validarSchema(relatorio) {
     const erros = [];
     // Verificar estrutura básica
-    if (typeof relatorio !== 'object') {
+    if (typeof relatorio !== 'object' || relatorio === null) {
         erros.push('Relatório deve ser um objeto');
         return {
             valido: false,

package/dist/lib/api.js

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+async function request(path) {
+    const response = await fetch(path);
+    if (!response.ok) {
+        const body = await response.json();
+        throw new Error(body.erro ?? `HTTP ${response.status}`);
+    }
+    return response.json();
+}
+export const api = {
+    getAppInfo() {
+        return request('/api/github/app-info');
+    },
+};

package/dist/shared/data-processing/occurrences.js

@@ -9,6 +9,9 @@
  * A chave de deduplicação é composta por: relPath|linha|tipo|mensagem.
  */
 export function dedupeOcorrencias(arr) {
+    if (!arr || !Array.isArray(arr)) {
+        return [];
+    }
     const seen = new Map();
     for (const ocorrencia of arr) {
         const key = `${ocorrencia.relPath ?? ''}|${String(ocorrencia.linha ?? '')}|${ocorrencia.tipo ?? ''}|${ocorrencia.mensagem ?? ''}`;

package/dist/shared/formatters/code-min-formatter.js

@@ -10,7 +10,7 @@ export function formatarCodeMinimo(code, opts) {
     const formatted = normalizarNewlinesFinais(removerEspacosFinaisPorLinha(normalized));
     return {
         ok: true,
-        parser: opts?.parser,
+        parser: (opts?.parser ?? 'code'),
         formatted,
         changed: formatted !== normalizarNewlinesFinais(normalized),
     };

package/dist/shared/formatters/formatters/commons.js

@@ -93,13 +93,19 @@ const REPEATABLE_TO_SINGLE = new Set([',', '.', '!', '?', ';']);
 const REPEATABLE_KEEP_UP_TO_3 = new Set(['.', '!', '?']);
 const MULTI_PUNCT_RE = /([,\.!?:;_\-])\1+/g;
 const SPACE_BEFORE_PUNCT_RE = /\s+([,.:;!?])/g;
-const NO_SPACE_AFTER_NON_DOT_PUNCT_RE = /([,:;!?])([^\s\)\]\}\[!,;:?])/g;
+const NO_SPACE_AFTER_NON_DOT_PUNCT_RE = /([,:;!?])([^\s\)\]\}\[!,;:?"'])/g;
 const SPACE_BEFORE_ELLIPSIS_RE = /([^0-9])(\.{3})/g;
 const PROTECTED_PATTERNS = [/https?:\/\/[^\s"'<>]+/gi, /ftp:\/\/[^\s"'<>]+/gi, /file:\/\/[^\s"'<>]+/gi, /www\.[^\s"'<>]+/gi, /[a-zA-Z0-9](?:\.[a-zA-Z0-9-]+)+\.[a-zA-Z]{2,}/g, /(?:^|(?<=\s|["'=(\[,]))\.\//g, /(?:^|(?<=\s|["'=(\[,]))\.\.\//g, /(?<=[/\\])[\w-]+\.[\w]+/g, /\d+\.\d+(?:\.\d+)*/g, /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g, /[a-f0-9]{7,}\.[a-f0-9]+/gi, /[\w-]+\.[\w-]+\.[\w]+/g,
     // Proteger paths e nomes de arquivo com extensão
     /(?:^|[\s"'=(\[,])([\/\\][\w-]+(?:[\/\\][\w-]+)*[\/\\]?[\w-]+\.[a-zA-Z0-9]+)/g, /(?:^|[\s"'=(\[,])([\w-]+(?:[\/\\][\w-]+)+\.[a-zA-Z0-9]+)/g,
     // Proteger imports/require paths
-    /(?:from\s+|require\(|import\s+)(["'])([^"']+\.[a-zA-Z0-9]+)\1/g];
+    /(?:from\s+|require\(|import\s+)(["'])([^"']+\.[a-zA-Z0-9]+)\1/g,
+    // Proteger expansões de parâmetro shell ${...} - operadores :- := :? :+ e slicing não devem ser tocados
+    /\$\{[^}]*\}/g,
+    // Proteger terminadores de case shell: ;; ;;& ;&
+    /;;[;&]?|;&/g,
+    // Proteger expressões de teste shell [[ ... ]] e (( ... ))
+    /\[\[[^\]]*\]\]|\(\([^)]*\)\)/g];
 function protectSequences(code) {
     const placeholders = [];
     let result = code;
@@ -299,14 +305,22 @@ function fixSpacingAroundPunct(code) {
         if (shouldSkipLineForPunctuation(line, idx, lines)) {
             return line;
         }
-        const t1 = line.replace(SPACE_BEFORE_PUNCT_RE, '$1');
-        const t2 = t1.replace(NO_SPACE_AFTER_NON_DOT_PUNCT_RE, (m, p1, _p2, off) => fixNonDotPunct(m, p1, _p2, off, t1));
+        // Proteger espaço antes de ! quando é operador de negação shell:
+        // [[ ! → preservar o espaço, não remover
+        // Also protect (( ! and case ! patterns
+        const shellNegationProtected = line
+            .replace(/(\[\[)\s+(!)/g, '$1\x00SHL_NEG\x00')
+            .replace(/(\(\()\s+(!)/g, '$1\x00SHL_NEG\x00');
+        const t1 = shellNegationProtected.replace(SPACE_BEFORE_PUNCT_RE, '$1');
+        // Restaurar proteção de negação shell
+        const t1restored = t1.replace(/\x00SHL_NEG\x00/g, ' !');
+        const t2 = t1restored.replace(NO_SPACE_AFTER_NON_DOT_PUNCT_RE, (m, p1, _p2, off) => fixNonDotPunct(m, p1, _p2, off, t1restored));
         const t3 = t2.replace(NO_SPACE_AFTER_DOT_RE, (m, off) => fixDotPunct(m, off, t2));
         const t4 = t3.replace(SPACE_BEFORE_ELLIPSIS_RE, '$1 $2');
         if (t4 !== line) {
             changed = true;
             const countBefore = (line.match(SPACE_BEFORE_PUNCT_RE) ?? []).length;
-            const countNonDot = (t1.match(NO_SPACE_AFTER_NON_DOT_PUNCT_RE) ?? []).length;
+            const countNonDot = (t1restored.match(NO_SPACE_AFTER_NON_DOT_PUNCT_RE) ?? []).length;
             const countDot = (t2.match(NO_SPACE_AFTER_DOT_RE) ?? []).length;
             const countEllipsis = (t3.match(SPACE_BEFORE_ELLIPSIS_RE) ?? []).length;
             totalChanges += countBefore + countNonDot + countDot + countEllipsis;

package/dist/shared/formatters/formatters/shell.js

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: MIT
 // @mahoraga-disable ml-deep-nesting
+import { execSync } from 'node:child_process';
 import { corrigirPontuacaoECodigo, limitarLinhasEmBranco, normalizarFimDeLinha, normalizarNewlinesFinais, removerBom } from './commons.js';
 function parseShellLine(raw, ctx) {
     const trimmed = raw.trimEnd();
@@ -129,6 +130,82 @@ function parseShellLine(raw, ctx) {
         }
     };
 }
+/**
+ * Verifica se um índice dentro de uma linha está entre aspas (single ou double).
+ */
+function isIndexInQuotes(line, index) {
+    let inSingle = false;
+    let inDouble = false;
+    let escaped = false;
+    for (let i = 0; i < index && i < line.length; i++) {
+        const ch = line[i];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (ch === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (inSingle) {
+            if (ch === "'")
+                inSingle = false;
+            continue;
+        }
+        if (inDouble) {
+            if (ch === '"')
+                inDouble = false;
+            continue;
+        }
+        if (ch === "'") {
+            inSingle = true;
+            continue;
+        }
+        if (ch === '"') {
+            inDouble = true;
+            continue;
+        }
+    }
+    return inSingle || inDouble;
+}
+/**
+ * Verifica se um caractere pipe (|) está em posição de pipe shell real
+ * (fora de aspas, não dentro de string/regex literal).
+ */
+function isRealShellPipe(line, index) {
+    if (isIndexInQuotes(line, index))
+        return false;
+    // Verificar se o | está precedido por $ ou ` (subshell) - isso é pipe real
+    const before = line.slice(0, index);
+    // Se | está dentro de expressão $() ou `` , é pipe dentro de subshell - ainda é pipe real
+    // Mas se está dentro de '...' ou "..." já foi filtrado acima
+    return true;
+}
+/**
+ * Aplica espaçamento em redirecionamento simples: >file → > file
+ * Mas preserva redirecionamentos atômicos (2>&1, &>, etc.)
+ */
+function aplicarEspacamentoRedirecionamento(line) {
+    // Primeiro, proteger redirecionamentos atômicos com placeholders
+    const atomicos = [];
+    let result = line.replace(
+    // Captura operadores de redirecionamento atômicos (compostos por 2+ caracteres):
+    // &>, &>>, 2>, 2>>, 2>&1, 3>&-, |&, <<, <<-, <>, >|, >>, >&, <&
+    // NÃO captura > ou < simples (esses devem ganhar espaço)
+    /(?:\d+>&?\d*|&>>?|<<[-]?|\|&|<>|>[\|]|>>|>&|<&)/g, (match) => {
+        const id = atomicos.length;
+        atomicos.push(match);
+        return `\x00ATOMIC_REDIR_${id}\x00`;
+    });
+    // Agora aplicar espaçamento em redirecionamentos simples restantes
+    // cmd>file → cmd > file (espaço antes e depois)
+    result = result.replace(/(?<!\x00)([^\s><])([><])([^\s><])/g, '$1 $2 $3');
+    // Restaurar placeholders
+    result = result.replace(/\x00ATOMIC_REDIR_(\d+)\x00/g, (_m, id) => {
+        return atomicos[Number(id)] ?? _m;
+    });
+    return result;
+}
 function corrigirEspacamentoShell(lines) {
     const out = [];
     let ctx = {
@@ -152,6 +229,11 @@ function corrigirEspacamentoShell(lines) {
             out.push(output);
             continue;
         }
+        // Shebang (#!): preservar intacto, sem espaços
+        if (/^\s*#!/.test(output)) {
+            out.push(output);
+            continue;
+        }
         // Comentários: garantir espaço após #
         if (/^\s*#\S/.test(output)) {
             out.push(output.replace(/^(\s*)#(\S)/, '$1# $2'));
@@ -163,23 +245,44 @@ function corrigirEspacamentoShell(lines) {
             out.push(output.replace(/^(\s*[a-zA-Z_][\w]*)\s+=\s/, '$1='));
             continue;
         }
-        // Espaçamento em pipes: | → | (espaços em torno)
+        // Espaçamento em pipes reais do shell (fora de aspas/strings): cmd|cmd → cmd | cmd
         if (/\S\|\S/.test(output)) {
-            out.push(output.replace(/(\S)\|(\S)/g, '$1 | $2'));
-            continue;
-        }
-        // Espaçamento em redirecionamentos: >file → > file
-        if (/\S[><]\S/.test(output)) {
-            out.push(output.replace(/(\S)([><])(\S)/g, '$1 $2 $3'));
-            continue;
+            // Só aplicar espaços em pipes que são reais do shell (fora de aspas)
+            const withPipeSpaces = output.replace(/(\S)\|(\S)/g, (match, before, after, offset) => {
+                if (isRealShellPipe(output, offset + before.length)) {
+                    return `${before} | ${after}`;
+                }
+                return match;
+            });
+            // Se houve mudança, continue; senão cai nos próximos handlers
+            if (withPipeSpaces !== output) {
+                out.push(aplicarEspacamentoRedirecionamento(withPipeSpaces));
+                continue;
+            }
         }
-        out.push(output);
+        // Espaçamento em redirecionamentos: >file → > file (preservando atômicos)
+        out.push(aplicarEspacamentoRedirecionamento(output));
     }
     return out;
 }
+/* ────────────────────────── Validação de sintaxe ────────────────────────── */
+/**
+ * Valida a sintaxe shell usando bash -n.
+ * Retorna true se a sintaxe for válida, false caso contrário.
+ */
+function validarSintaxeShell(code) {
+    try {
+        execSync('bash -n', { input: code, timeout: 5000, stdio: ['pipe', 'ignore', 'ignore'] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /* ────────────────────────── Public API ────────────────────────── */
 /**
  * Shell formatter com detecção de contexto para here-docs, quoting e continuação.
+ * Inclui gate de segurança: se bash -n falhar, retorna o código original sem formatação.
  */
 export function formatarShellMinimo(code) {
     const normalized = normalizarFimDeLinha(removerBom(code));
@@ -193,6 +296,22 @@ export function formatarShellMinimo(code) {
     const formatted = normalizarNewlinesFinais(comPontuacao);
     const baseline = normalizarNewlinesFinais(normalized);
     const anyChanged = formatted !== baseline;
+    // Gate de segurança: validar sintaxe com bash -n, reverter se falhar
+    if (anyChanged && lines.length > 1) {
+        try {
+            execSync('bash -n', { input: formatted, timeout: 5000, stdio: ['pipe', 'ignore', 'ignore'] });
+        }
+        catch {
+            // bash -n falhou → reverter para o código original
+            return {
+                ok: true,
+                parser: 'shell',
+                formatted: baseline,
+                changed: false,
+                reason: 'shell-syntax-error-revert'
+            };
+        }
+    }
     return {
         ok: true,
         parser: 'shell',

package/dist/shared/helpers/ast-visitor-utils.js

@@ -30,6 +30,9 @@ export class DedupeManager {
 export function runUniqueVisitor(ast, relPath, visitor, initialState = {}) {
     const manager = new DedupeManager(relPath);
     const state = { ...initialState, manager, relPath };
+    if (ast === null || ast === undefined) {
+        return [];
+    }
     const nodeToTraverse = ast.node ?? ast;
     if (!nodeToTraverse) {
         return [];

package/dist/shared/helpers/imports.js

@@ -6,7 +6,7 @@
  * Não toca disco; apenas retorna o novo conteúdo.
  */
 import path from 'node:path';
-import { normalizePath } from './index.js';
+import { normalizePath } from './path.js';
 /**
  * Normaliza o caminho de import para uma chave consistente (POSIX).
  */

package/dist/shared/helpers/reader-report.js

@@ -13,6 +13,13 @@ export async function lerRelatorioVersionado(options) {
     try {
         // Ler arquivo
         const conteudo = await lerEstado(caminho);
+        // Verificar se arquivo existe
+        if (conteudo === null || conteudo === undefined) {
+            return {
+                sucesso: false,
+                erro: 'Arquivo não encontrado ou vazio',
+            };
+        }
         let relatorioFinal = conteudo;
         let migrado = false;
         // Validar schema se solicitado
@@ -92,6 +99,12 @@ export async function lerDadosRelatorio(caminho) {
 export async function verificarSchemaRelatorio(caminho) {
     try {
         const conteudo = await lerEstado(caminho);
+        if (conteudo === null || conteudo === undefined) {
+            return {
+                valido: false,
+                erros: ['Arquivo não encontrado ou vazio'],
+            };
+        }
         const validacao = validarSchema(conteudo);
         return {
             valido: validacao.valido,

package/dist/shared/helpers/structure.js

@@ -268,9 +268,9 @@ export function normalizarRel(relPath) {
 export async function carregarConfigEstrategia(baseDir, overrides) {
     const caminho = path.join(baseDir, '.mahoraga', 'estrutura.json');
     const lido = await lerEstado(caminho);
-    const cfgObj = !Array.isArray(lido) && typeof lido === 'object' ? lido : {};
+    const cfgObj = lido !== null && !Array.isArray(lido) && typeof lido === 'object' ? lido : {};
     const nomePreset = overrides?.preset ?? cfgObj['preset'];
-    const preset = nomePreset && PRESETS[nomePreset].nome ? PRESETS[nomePreset] : undefined;
+    const preset = nomePreset && PRESETS[nomePreset]?.nome ? PRESETS[nomePreset] : undefined;
     const base = {
         raizCodigo: 'src',
         criarSubpastasPorEntidade: true,

package/dist/types/guardian/result.js

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Type guard: verifica se um valor é um GuardianResult válido.
+ * Aceita null/undefined como válido (representa "sem resultado ainda").
+ */
+export function isGuardianResult(value) {
+    if (value === null || value === undefined) {
+        return true;
+    }
+    if (typeof value !== 'object') {
+        return false;
+    }
+    const obj = value;
+    if (typeof obj.status !== 'string') {
+        return false;
+    }
+    const knownStatuses = ['ok', 'erro', 'alteracoes-detectadas', 'baseline-aceito', 'baseline-criado'];
+    return knownStatuses.includes(obj.status);
+}
+/**
+ * Converte/conforma um GuardianResult.
+ * - undefined → null
+ * - status 'baseline-aceito' → 'ok'
+ * - status desconhecido retorna null
+ */
+export function converterResultadoGuardian(result) {
+    if (result === undefined) {
+        return null;
+    }
+    if (result.status === 'baseline-aceito') {
+        return { ...result, status: 'ok' };
+    }
+    const knownStatuses = ['ok', 'erro', 'alteracoes-detectadas'];
+    if (!knownStatuses.includes(result.status)) {
+        return null;
+    }
+    return result;
+}

package/dist/types/reports/processing.js

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Verifica se um valor é uma PendenciaProcessavel válida.
+ * Deve ter `arquivo` (string) e `motivo` (string).
+ */
+export function isPendenciaProcessavel(value) {
+    if (value === null || value === undefined || typeof value !== 'object') {
+        return false;
+    }
+    const obj = value;
+    return typeof obj.arquivo === 'string' && typeof obj.motivo === 'string';
+}

package/dist/types/shared/validation.js

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: MIT
+import { SharedCommonMensagens } from '../../core/messages/index.js';
+/**
+ * Extrai mensagem de erro de qualquer valor de forma segura.
+ */
+export function extrairMensagemErro(err) {
+    if (err === null || err === undefined) {
+        return SharedCommonMensagens?.erroDesconhecido ?? 'Erro desconhecido';
+    }
+    if (err instanceof Error) {
+        return err.message;
+    }
+    if (typeof err === 'string') {
+        return err;
+    }
+    if (typeof err === 'object') {
+        const obj = err;
+        if (typeof obj.message === 'string') {
+            return obj.message;
+        }
+        if (obj.message instanceof Error) {
+            return obj.message.message;
+        }
+    }
+    return SharedCommonMensagens?.erroDesconhecido ?? 'Erro desconhecido';
+}
+/**
+ * Valida um valor com type guard e retorna fallback se falhar.
+ */
+export function validarSeguro(validador, valor, fallback) {
+    if (validador(valor)) {
+        return valor;
+    }
+    console.warn('validação falhou, usando fallback', valor);
+    return fallback;
+}
+/**
+ * Converte um valor com type guard e retorna fallback se falhar.
+ */
+export function converterSeguro(valor, validador, fallback) {
+    if (validador(valor)) {
+        return valor;
+    }
+    return fallback;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isErroComMensagem(value) {
+    if (value === null || value === undefined) {
+        return false;
+    }
+    if (typeof value !== 'object') {
+        return false;
+    }
+    return typeof value.message === 'string';
+}
+export function isGlobalComVitest(value) {
+    if (value === null || value === undefined || typeof value !== 'object') {
+        return false;
+    }
+    return 'vi' in value;
+}
+export function isIntlComDisplayNames(value) {
+    if (value === null || value === undefined || typeof value !== 'object') {
+        return false;
+    }
+    // Aceita tanto se tiver DisplayNames quanto qualquer objeto (fallback)
+    return true;
+}
+export function isGlobalComImport(value) {
+    if (value === null || value === undefined || typeof value !== 'object') {
+        return false;
+    }
+    // Aceita tanto se tiver import quanto qualquer objeto (fallback)
+    return true;
+}
+export function isConfigPlugin(value) {
+    return value !== null && value !== undefined && typeof value === 'object';
+}
+export function isPlanoSugestaoEstrutura(value) {
+    if (value === null || value === undefined || typeof value !== 'object') {
+        return false;
+    }
+    const obj = value;
+    return Array.isArray(obj.mover);
+}
+export function isSnapshotAnalise(value) {
+    if (value === null || value === undefined || typeof value !== 'object') {
+        return false;
+    }
+    const obj = value;
+    return typeof obj.timestamp === 'string' && Array.isArray(obj.arquivos);
+}
+export function isEntradaMapaReversao(value) {
+    if (value === null || value === undefined || typeof value !== 'object') {
+        return false;
+    }
+    const obj = value;
+    if (typeof obj.arquivo !== 'string') {
+        return false;
+    }
+    return ['adicionar', 'remover', 'modificar'].includes(obj.operacao);
+}
+export function isStringNaoVazia(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+export function isNumeroValido(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+export function isArrayNaoVazio(value) {
+    return Array.isArray(value) && value.length > 0;
+}

package/dist/vulnerabilities/scanner.js

@@ -31,8 +31,13 @@ export async function scanVulnerabilities(opts = {}) {
     }
     catch (err) {
         if (isNpmAuditError(err)) {
-            const parsed = JSON.parse(err.stdout);
-            return normalizeAuditResult(parsed);
+            try {
+                const parsed = JSON.parse(err.stdout);
+                return normalizeAuditResult(parsed);
+            }
+            catch {
+                return emptyResult();
+            }
         }
         return emptyResult();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mocoto/mahoraga",
-  "version": "0.14.7",
+  "version": "0.14.8",
   "type": "module",
   "description": "C.L.I modular para análise, diagnóstico e manutenção de projetos JavaScript/TypeScript e multi-stack leve",
   "author": "rei macaco",
@@ -122,7 +122,7 @@
     "chalk": "^5.6.2",
     "commander": "^15.0.0",
     "dotenv": "^17.4.2",
-    "fast-xml-parser": "^5.9.3",
+    "fast-xml-parser": "^5.10.0",
     "htmlparser2": "^12.0.0",
     "marked": "^18.0.6",
     "micromatch": "^4.0.8",
@@ -130,7 +130,7 @@
     "openpgp": "^6.3.1",
     "ora": "^9.4.1",
     "p-limit": "^7.3.0",
-    "postcss": "^8.5.16",
+    "postcss": "^8.5.17",
     "postcss-sass": "^0.5.0",
     "postcss-scss": "^4.0.9",
     "xxhashjs": "^0.2.2",