@mocoto/mahoraga 0.14.6 → 0.14.8

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/messages/zh/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/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

@@ -1,15 +1,41 @@
 // SPDX-License-Identifier: MIT
-import { createRequire } from 'module';
+import { parse as babelParse } from '@babel/parser';
 import { getCurrentParsingFile, logCore, wrapMinimal } from '../utils.js';
-const localRequire = createRequire(import.meta.url);
-/** Analisa código TypeScript usando parser nativo TSC */
+/**
+ * Analisa código TypeScript/TSX.
+ * Nota de migração (TS 7 / compilador nativo em Go): o compilador TypeScript
+ * não expõe mais a API programática (ts.createSourceFile etc.). Usamos o
+ * @babel/parser (já dependência do projeto) para obter o AST de forma estável
+ * e compatível com o TS 7.
+ */
 export function parseComTypeScript(codigo, tsx = false) {
     try {
-        const ts = localRequire('typescript');
-        const sf = ts.createSourceFile(tsx ? 'file.tsx' : 'file.ts', codigo, ts.ScriptTarget.Latest, false, tsx ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+        // Lista de plugins alinhada aos demais parsers do projeto (babel 8).
+        // Tipada como string[] para acomodar plugins que deixaram de figurar no
+        // enum ParserPlugin do babel 8 (passaram a ser comportamento padrão).
+        const plugins = [
+            'decorators-legacy', 'classProperties', 'classPrivateProperties',
+            'classPrivateMethods', 'optionalChaining', 'nullishCoalescingOperator',
+            'topLevelAwait', 'importAttributes'
+        ];
+        if (tsx) {
+            plugins.unshift('jsx');
+        }
+        plugins.unshift('typescript');
+        const ast = babelParse(codigo, {
+            sourceType: 'unambiguous',
+            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: sf.kind,
-            statements: sf.statements.length
+            kind: 'SourceFile',
+            statements: ast.program.body.length
         });
     }
     catch (erro) {

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/core/utils/exec-safe.js

@@ -1,19 +1,32 @@
 // SPDX-License-Identifier: MIT
-import { execSync } from 'node:child_process';
+import { execFileSync } from 'node:child_process';
+import path from 'node:path';
 import { config } from '../config/index.js';
 import { getMessages } from '../messages/index.js';
-// Expressão regular para detectar shell metacharacters perigosos
-// que permitiriam injeção de comandos adicionais.
-// Bloqueia: ; | & ` $() ${} <> \n
-const SHELL_INJECTION_RE = /[;|&`]|\$[({]|\${|>|<|\\n/;
 /**
- * Valida que o comando não contém caracteres de injeção shell.
- * @param cmd - Comando a validar
- * @throws Error se o comando contiver padrões perigosos
+ * Allowlist de binários que o CLI pode executar externamente.
+ * Apenas comandos essenciais para operação do ferramenta são permitidos.
+ * Isso substitui a abordagem anterior de blacklist de caracteres shell,
+ * eliminando o vetor de injeção por shell intermediário.
  */
-function validarComando(cmd) {
-    if (SHELL_INJECTION_RE.test(cmd)) {
-        throw new Error(`Comando rejeitado por segurança: contém caracteres de injeção shell.`);
+const BINARIOS_PERMITIDOS = new Set([
+    'git',
+    'npm',
+    'npx',
+    'node',
+    'pnpm',
+    'yarn',
+    'corepack',
+]);
+/**
+ * Valida que o binário está na allowlist.
+ * @param bin - Caminho ou nome do binário
+ * @throws Error se o binário não for permitido
+ */
+function validarBinario(bin) {
+    const nome = path.basename(bin);
+    if (!BINARIOS_PERMITIDOS.has(nome)) {
+        throw new Error(getMessages().ExecSafeMensagens.binarioNaoPermitido(bin));
     }
 }
 function verificarSafeMode() {
@@ -22,28 +35,37 @@ function verificarSafeMode() {
     }
 }
 /**
- * Executa um comando shell de forma segura.
+ * Executa um binário de forma segura sem shell intermediário.
+ *
  * Bloqueia a execução quando SAFE_MODE está ativo e ALLOW_EXEC não está habilitado.
- * Também valida o comando contra injeção shell mesmo quando a execução é permitida.
- * @param cmd - Comando shell a executar
- * @param opts - Opções do execSync do Node.js
+ * Valida o binário contra uma allowlist de comandos permitidos.
+ * Força `shell: false` para eliminar o risco de injeção de comandos.
+ *
+ * @param bin - Binário a executar (ex: 'git', 'npm')
+ * @param args - Argumentos do binário (array de strings)
+ * @param opts - Opções adicionais do child_process
  * @returns Buffer ou string com a saída do comando
- * @throws Error se SAFE_MODE estiver ativo sem ALLOW_EXEC ou se o comando for inválido
+ * @throws Error se SAFE_MODE estiver ativo sem ALLOW_EXEC,
+ *         se o binário não estiver na allowlist,
+ *         ou se a execução falhar
  */
-export function executarShellSeguro(cmd, opts = {}) {
-    validarComando(cmd);
+export function executarShellSeguro(bin, args = [], opts = {}) {
+    validarBinario(bin);
     verificarSafeMode();
-    return execSync(cmd, opts);
+    return execFileSync(bin, args, { ...opts, shell: false });
 }
 /**
  * Versão assíncrona do `executarShellSeguro`.
  * Wrapper async que delega ao sync, útil em contextos que já utilizam await.
- * @param cmd - Comando shell a executar
- * @param opts - Opções do execSync do Node.js
+ *
+ * @param bin - Binário a executar (ex: 'git', 'npm')
+ * @param args - Argumentos do binário (array de strings)
+ * @param opts - Opções adicionais do child_process
  * @returns Promise resolvida com Buffer ou string da saída do comando
- * @throws Error se SAFE_MODE estiver ativo sem ALLOW_EXEC
+ * @throws Error se SAFE_MODE estiver ativo sem ALLOW_EXEC,
+ *         se o binário não estiver na allowlist,
+ *         ou se a execução falhar
  */
-export function executarShellSeguroAsync(cmd, opts = {}) {
-    // wrapper assíncrono que delega ao sync (usado onde já há await)
-    return executarShellSeguro(cmd, opts);
+export function executarShellSeguroAsync(bin, args = [], opts = {}) {
+    return executarShellSeguro(bin, args, opts);
 }

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';
+}