@mocoto/mahoraga 0.14.0 → 0.14.1

package/dist/core/utils/index.js

@@ -1,3 +1,7 @@
+// SPDX-License-Identifier: MIT
+/**
+ * @fileoverview Core utilities: exec-safe and import-safe
+ */
+export * from './chalk.js';
 export * from './exec-safe.js';
 export * from './import-safe.js';
-//# sourceMappingURL=index.js.map

package/dist/core/workers/index.js

@@ -1,3 +1,6 @@
+// SPDX-License-Identifier: MIT
+/**
+ * @fileoverview Core worker pool management
+ */
 export * from './worker-executor.js';
 export * from './worker-pool.js';
-//# sourceMappingURL=index.js.map

package/dist/core/workers/worker-executor.js

@@ -1,16 +1,24 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Executor de worker para processamento paralelo de arquivos
+ * Este arquivo é executado em threads separadas pelos Worker Threads
+ * Formato ESM (compatível com "type": "module")
+ */
 import * as path from 'node:path';
 import { parentPort, workerData } from 'node:worker_threads';
 import { getMessages } from '../messages/index.js';
 import { decifrarSintaxe } from '../parsing/index.js';
 const port = parentPort;
+// Cache de AST local por worker (evita re-parsar mesmo arquivo dentro do mesmo lote)
 const workerAstCache = new Map();
 async function executarTecnicaEmArquivo(tecnica, arquivo, contexto, timeoutMs) {
-    if (typeof tecnica?.aplicar !== 'function')
+    if (typeof tecnica.aplicar !== 'function') {
         return [];
+    }
     const execPromise = tecnica.aplicar(arquivo.content ?? '', arquivo.relPath, arquivo.ast ?? null, arquivo.fullCaminho ?? '', contexto);
     if (timeoutMs && timeoutMs > 0) {
         const msgs = getMessages().ExecutorExtraMensagens;
-        return Promise.race([execPromise, new Promise((_, reject) => setTimeout(() => reject(new Error(msgs.timeoutTecnica(tecnica.nome, timeoutMs))), timeoutMs))]).then(result => Array.isArray(result) ? result : [], (err) => {
+        return Promise.race([execPromise, new Promise((_, reject) => setTimeout(() => { reject(new Error(msgs.timeoutTecnica(tecnica.nome, timeoutMs))); }, timeoutMs))]).then(result => Array.isArray(result) ? result : [], (err) => {
             return [{
                     arquivo: arquivo.relPath,
                     linha: 1,
@@ -53,10 +61,11 @@ function yieldEventLoop() {
 async function processarLote(lote, contexto) {
     const resultados = [];
     const wd = workerData;
-    const timeoutMs = Number(wd?.timeoutMs) || 0;
-    const techniques = Array.isArray(wd?.techniques) ? wd.techniques : [];
-    const files = Array.isArray(wd?.files) ? wd.files : [];
+    const timeoutMs = Number(wd.timeoutMs) || 0;
+    const techniques = Array.isArray(wd.techniques) ? wd.techniques : [];
+    const files = Array.isArray(wd.files) ? wd.files : [];
     for (const file of files) {
+        // Parallel AST parsing: parseia o AST dentro do worker se não veio pré-parseado
         if (!file.ast && file.content) {
             const ext = path.extname(file.relPath);
             const cached = workerAstCache.get(file.relPath);
@@ -72,6 +81,7 @@ async function processarLote(lote, contexto) {
                     }
                 }
                 catch {
+                    // Se falhar parsing, segue sem AST (analistas que precisam de AST tratarão null)
                 }
             }
         }
@@ -82,14 +92,16 @@ async function processarLote(lote, contexto) {
             erros: []
         };
         for (const tecnica of techniques) {
-            if (tecnica.test && !tecnica.test(file.relPath))
+            if (tecnica.test && !tecnica.test(file.relPath)) {
                 continue;
+            }
             try {
                 const inicio = Date.now();
                 const out = await executarTecnicaEmArquivo(tecnica, file, contexto, timeoutMs);
                 const dur = Date.now() - inicio;
-                if (out && Array.isArray(out))
+                if (out && Array.isArray(out)) {
                     fileResultado.ocorrencias.push(...out);
+                }
                 fileResultado.tempos.push({
                     tecnica: tecnica.nome,
                     duracaoMs: dur
@@ -117,7 +129,7 @@ async function main() {
     let heartbeatInterval = null;
     try {
         const wd = workerData;
-        const contexto = wd?.contexto;
+        const contexto = wd.contexto;
         try {
             if (port && typeof port.postMessage === 'function') {
                 heartbeatInterval = setInterval(() => {
@@ -129,17 +141,19 @@ async function main() {
                         });
                     }
                     catch {
+                        // ignore
                     }
                 }, HEARTBEAT_MS);
             }
         }
         catch {
+            /* ignore */
         }
         const resultados = await processarLote(wd.lote ?? wd.files ?? [], contexto);
         const occurrences = resultados.flatMap(raiz => raiz.ocorrencias || []);
         const metrics = resultados.flatMap(raiz => raiz.tempos || []);
         const processedArquivos = Array.isArray(wd.files) ? wd.files.length : resultados.length || 0;
-        if (port)
+        if (port) {
             port.postMessage({
                 sucesso: true,
                 resultados,
@@ -149,32 +163,36 @@ async function main() {
                 processedArquivos,
                 duration: Date.now()
             });
+        }
     }
     catch (erro) {
         try {
-            if (port)
+            if (port) {
                 port.postMessage({
                     sucesso: false,
                     erro: erro instanceof Error ? erro.message : String(erro),
                     stack: erro instanceof Error ? erro.stack : undefined,
                     workerId: process.pid
                 });
+            }
         }
         catch {
+            // ignore
         }
     }
     finally {
-        if (heartbeatInterval)
+        if (heartbeatInterval) {
             clearInterval(heartbeatInterval);
+        }
     }
 }
-main().catch(erro => {
-    if (port)
+main().catch((erro) => {
+    if (port) {
         port.postMessage({
             sucesso: false,
             erro: erro instanceof Error ? erro.message : String(erro),
             stack: erro instanceof Error ? erro.stack : undefined,
             workerId: process.pid
         });
+    }
 });
-//# sourceMappingURL=worker-executor.js.map

package/dist/guardian/baseline.js

@@ -1,6 +1,11 @@
+// SPDX-License-Identifier: MIT
 import path from 'node:path';
 import { LINHA_BASE_CAMINHO } from './index.js';
 import { lerEstado, salvarEstado } from '../shared/persistence/index.js';
+/**
+ * Lê o baseline atual do sistema de integridade.
+ * Retorna null se o arquivo não existir ou estiver malformado.
+ */
 export async function carregarBaseline() {
     try {
         const json = await lerEstado(LINHA_BASE_CAMINHO);
@@ -14,6 +19,9 @@ export async function carregarBaseline() {
         return null;
     }
 }
+/**
+ * Salva um novo baseline de integridade em disco, sobrescrevendo qualquer estado anterior.
+ */
 export async function salvarBaseline(snapshot) {
     const fs = await import('node:fs');
     await fs.promises.mkdir(path.dirname(LINHA_BASE_CAMINHO), {
@@ -21,4 +29,3 @@ export async function salvarBaseline(snapshot) {
     });
     await salvarEstado(LINHA_BASE_CAMINHO, snapshot);
 }
-//# sourceMappingURL=baseline.js.map

package/dist/guardian/constants.js

@@ -1,6 +1,23 @@
-import { MAHORAGA_ARQUIVOS } from '../core/registry/index.js';
-export const LINHA_BASE_CAMINHO = MAHORAGA_ARQUIVOS.GUARDIAN_BASELINE;
-export const REGISTRO_VIGIA_CAMINHO_PADRAO = MAHORAGA_ARQUIVOS.REGISTRO_VIGIA;
-export const CHAVE_PUBLICA_CAMINHO = MAHORAGA_ARQUIVOS.GUARDIAN_CHAVE_PUBLICA;
-export const CHAVE_PRIVADA_CAMINHO = MAHORAGA_ARQUIVOS.GUARDIAN_CHAVE_PRIVADA;
-//# sourceMappingURL=constants.js.map
+// SPDX-License-Identifier: MIT
+import { SUKUNA_ARQUIVOS } from '../core/registry/index.js';
+/**
+ * [PIN] Caminho absoluto para o arquivo de baseline principal (usado pelo Sentinela).
+ *
+ * Usa o sistema de paths centralizado: .mahoraga/guardian.baseline.json
+ * Com fallback automático para baseline.json legado se necessário.
+ */
+export const LINHA_BASE_CAMINHO = SUKUNA_ARQUIVOS.GUARDIAN_BASELINE;
+/**
+ * [PIN] Caminho padrão para os registros da Vigia Oculta.
+ *
+ * Integridade de execução armazenada em .mahoraga/integridade.json
+ */
+export const REGISTRO_VIGIA_CAMINHO_PADRAO = SUKUNA_ARQUIVOS.REGISTRO_VIGIA;
+/**
+ * [KEY] Caminho para a chave pública GPG do Guardian.
+ */
+export const CHAVE_PUBLICA_CAMINHO = SUKUNA_ARQUIVOS.GUARDIAN_CHAVE_PUBLICA;
+/**
+ * [KEY] Caminho para a chave privada GPG do Guardian.
+ */
+export const CHAVE_PRIVADA_CAMINHO = SUKUNA_ARQUIVOS.GUARDIAN_CHAVE_PRIVADA;

package/dist/guardian/diff.js

@@ -1,19 +1,24 @@
+// SPDX-License-Identifier: MIT
 import { config } from '../core/config/index.js';
+/**
+ * Compara dois snapshots de integridade (hash por arquivo) e retorna as diferenças encontradas.
+ */
 export function diffSnapshots(before, after) {
+    // Cache intra-processo para evitar recomputar diffs idênticos em execuções repetidas
     const key = `${Object.keys(before).length}:${Object.keys(after).length}`;
     const hashBefore = config.GUARDIAN_ENFORCE_PROTECTION ? Object.values(before).join('|') : '';
     const hashAfter = config.GUARDIAN_ENFORCE_PROTECTION ? Object.values(after).join('|') : '';
     const cacheChave = `${key}:${hashBefore}>${hashAfter}`;
     const globalAny = global;
-    if (!globalAny.__MAHORAGA_DIFF_CACHE__)
-        globalAny.__MAHORAGA_DIFF_CACHE__ = new Map();
-    const cache = globalAny.__MAHORAGA_DIFF_CACHE__;
+    globalAny.__SUKUNA_DIFF_CACHE__ ??= new Map();
+    const cache = globalAny.__SUKUNA_DIFF_CACHE__;
     if (cache.has(cacheChave)) {
         const globAny = globalAny;
-        globAny.__MAHORAGA_DIFF_CACHE_HITS__ = (globAny.__MAHORAGA_DIFF_CACHE_HITS__ || 0) + 1;
+        globAny.__SUKUNA_DIFF_CACHE_HITS__ = (globAny.__SUKUNA_DIFF_CACHE_HITS__ ?? 0) + 1;
         const hit = cache.get(cacheChave);
-        if (hit)
+        if (hit) {
             return hit;
+        }
     }
     const removidos = Object.keys(before).filter(key => !(key in after));
     const adicionados = Object.keys(after).filter(key => !(key in before));
@@ -26,6 +31,9 @@ export function diffSnapshots(before, after) {
     cache.set(cacheChave, resultado);
     return resultado;
 }
+/**
+ * Gera mensagens de erro de integridade com base nas permissões configuradas.
+ */
 export function verificarErros(diffs) {
     const erros = [];
     if (diffs.removidos.length > 0 && !config.GUARDIAN_ALLOW_DELS) {
@@ -39,4 +47,3 @@ export function verificarErros(diffs) {
     }
     return erros;
 }
-//# sourceMappingURL=diff.js.map

package/dist/guardian/gpg.js

@@ -1,7 +1,8 @@
-import { messages } from '../core/messages/index.js';
+// SPDX-License-Identifier: MIT
 import { CHAVE_PRIVADA_CAMINHO, CHAVE_PUBLICA_CAMINHO } from './index.js';
-import { lerEstado, salvarEstado } from '../shared/persistence/index.js';
 import * as openpgp from 'openpgp';
+import { messages } from '../core/messages/index.js';
+import { lerEstado, salvarEstado } from '../shared/persistence/index.js';
 export async function gerarParDeChaves() {
     const { privateKey, publicKey } = await openpgp.generateKey({
         type: 'ecc',
@@ -12,7 +13,7 @@ export async function gerarParDeChaves() {
     return { chavePrivada: privateKey, chavePublica: publicKey };
 }
 export async function assinarConteudo(conteudo, chavePrivadaArmored) {
-    const chavePrivada = chavePrivadaArmored || await carregarChavePrivada();
+    const chavePrivada = chavePrivadaArmored ?? await carregarChavePrivada();
     if (!chavePrivada) {
         throw new Error(messages.GuardianMensagens.gpgChavePrivadaIndisponivel);
     }
@@ -28,7 +29,7 @@ export async function assinarConteudo(conteudo, chavePrivadaArmored) {
     return assinatura;
 }
 export async function verificarAssinatura(conteudo, assinaturaArmored, chavePublicaArmored) {
-    const chavePublica = chavePublicaArmored || await carregarChavePublica();
+    const chavePublica = chavePublicaArmored ?? await carregarChavePublica();
     if (!chavePublica) {
         throw new Error(messages.GuardianMensagens.gpgChavePublicaIndisponivel);
     }
@@ -82,4 +83,3 @@ export async function inicializarChaves() {
     await salvarChavePrivada(par.chavePrivada);
     return par;
 }
-//# sourceMappingURL=gpg.js.map

package/dist/guardian/hash.js

@@ -1,8 +1,19 @@
+// SPDX-License-Identifier: MIT
 import { assinarConteudo, inicializarChaves } from './index.js';
+/**
+ * Gera uma assinatura GPG a partir do conteúdo fornecido.
+ * Se as chaves ainda não existirem, gera um novo par automaticamente.
+ */
 export async function gerarHashHex(conteudo) {
     await inicializarChaves();
     return assinarConteudo(conteudo);
 }
+/**
+ * Gera um snapshot do conteúdo incluindo:
+ * - Assinatura GPG de integridade
+ * - Número de linhas
+ * - Amostra textual do início do arquivo
+ */
 export async function gerarSnapshotDoConteudo(conteudo) {
     await inicializarChaves();
     const assinatura = await assinarConteudo(conteudo);
@@ -14,4 +25,3 @@ export async function gerarSnapshotDoConteudo(conteudo) {
     };
     return snapshot.assinatura;
 }
-//# sourceMappingURL=hash.js.map

package/dist/guardian/index.js

@@ -1,10 +1,16 @@
+// SPDX-License-Identifier: MIT
+/**
+ * @fileoverview Guardian: baseline, diff, hash, sentinela, verificador
+ */
 export * from './baseline.js';
 export * from './constants.js';
 export * from './diff.js';
 export * from './gpg.js';
 export * from './hash.js';
+export * from './integrity.js';
 export * from './records.js';
+export * from './result.js';
 export * from './sentinel.js';
+export * from './snapshot.js';
 export * from './verifier.js';
 export * from './watcher-hidden.js';
-//# sourceMappingURL=index.js.map

package/dist/guardian/integrity.js

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+export var IntegridadeStatus;
+(function (IntegridadeStatus) {
+    IntegridadeStatus["Criado"] = "baseline-criado";
+    IntegridadeStatus["Aceito"] = "baseline-aceito";
+    IntegridadeStatus["Ok"] = "ok";
+    IntegridadeStatus["AlteracoesDetectadas"] = "alteracoes-detectadas";
+})(IntegridadeStatus || (IntegridadeStatus = {}));
+export class GuardianError extends Error {
+    detalhes;
+    constructor(erros) {
+        super('Integridade comprometida - execuções bloqueadas.');
+        this.name = 'GuardianError';
+        this.detalhes = erros;
+    }
+}

package/dist/guardian/records.js

@@ -1,16 +1,21 @@
+// SPDX-License-Identifier: MIT
 import path from 'node:path';
+import { gerarSnapshotDoConteudo } from './index.js';
 import { config } from '../core/config/index.js';
 import { getMessages } from '../core/messages/index.js';
-import { gerarSnapshotDoConteudo } from './index.js';
 import { ensureDir } from '../shared/helpers/index.js';
 import { lerEstado, salvarEstado } from '../shared/persistence/index.js';
 const { log, GuardianMensagens } = getMessages();
 const DESTINO_PADRAO = path.join(config.STATE_DIR, 'integridade.json');
+/**
+ * Salva as assinaturas GPG dos arquivos fornecidos em um arquivo de integridade.
+ */
 export async function salvarRegistros(fileEntries, destino = DESTINO_PADRAO) {
     const registros = [];
     for (const { relPath, content } of fileEntries) {
-        if (!relPath || typeof content !== 'string' || !content.trim())
+        if (!relPath || typeof content !== 'string' || !content.trim()) {
             continue;
+        }
         const assinatura = await gerarSnapshotDoConteudo(content);
         registros.push({ arquivo: relPath, assinatura });
     }
@@ -18,6 +23,9 @@ export async function salvarRegistros(fileEntries, destino = DESTINO_PADRAO) {
     await salvarEstado(destino, registros);
     log.sucesso(GuardianMensagens.registroIntegridadeSalvo(destino));
 }
+/**
+ * Carrega os registros de integridade persistidos. Retorna lista vazia se não existir.
+ */
 export async function carregarRegistros(caminho = DESTINO_PADRAO) {
     try {
         return await lerEstado(caminho);
@@ -27,4 +35,3 @@ export async function carregarRegistros(caminho = DESTINO_PADRAO) {
         return [];
     }
 }
-//# sourceMappingURL=records.js.map

package/dist/guardian/result.js

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Tipos para resultados do Guardian
+ */
+/**
+ * Type guard para verificar se é resultado válido do Guardian
+ */
+export function isGuardianResult(value) {
+    if (value === null || value === undefined) {
+        return true;
+    }
+    if (typeof value !== 'object') {
+        return false;
+    }
+    const obj = value;
+    if (!('status' in obj)) {
+        return false;
+    }
+    const status = obj.status;
+    return (status === 'ok' || status === 'alteracoes-detectadas' || status === 'erro');
+}
+import { IntegridadeStatus } from './integrity.js';
+/**
+ * Converte ResultadoGuardian (tipo legado) para GuardianResult
+ */
+export function converterResultadoGuardian(resultado) {
+    if (!resultado) {
+        return null;
+    }
+    // Se já for GuardianResult, retorna como está
+    if (isGuardianResult(resultado)) {
+        return resultado;
+    }
+    // Converter de ResultadoGuardian para GuardianResult
+    const status = resultado.status;
+    if (status === IntegridadeStatus.Ok || status === IntegridadeStatus.Aceito) {
+        return {
+            status: 'ok',
+            baseline: {
+                chavePublica: '',
+                timestamp: Date.now(),
+                files: {},
+            },
+            message: resultado.detalhes?.join('; '),
+        };
+    }
+    if (status === IntegridadeStatus.AlteracoesDetectadas) {
+        return {
+            status: 'alteracoes-detectadas',
+            baseline: {
+                chavePublica: '',
+                timestamp: Date.now(),
+                files: {},
+            },
+            violations: (resultado.detalhes ?? []).map((msg) => ({
+                tipo: 'alteracao',
+                mensagem: msg,
+            })),
+            message: resultado.detalhes?.join('; ') ?? 'Alterações detectadas',
+        };
+    }
+    // Outros casos
+    return null;
+}

package/dist/guardian/sentinel.js

@@ -1,8 +1,11 @@
+// SPDX-License-Identifier: MIT
+// @mahoraga-disable tipo-inseguro-unknown
+// Justificativa: getErrMsg recebe unknown de catch blocks intencionalmente.
+import { carregarBaseline, diffSnapshots, gerarSnapshotDoConteudo, LINHA_BASE_CAMINHO, salvarBaseline, verificarErros } from './index.js';
+import micromatch from 'micromatch';
 import { config } from '../core/config/index.js';
 import { getMessages } from '../core/messages/index.js';
-import { carregarBaseline, diffSnapshots, gerarSnapshotDoConteudo, LINHA_BASE_CAMINHO, salvarBaseline, verificarErros } from './index.js';
 import { ensureDir, normalizePath } from '../shared/helpers/index.js';
-import micromatch from 'micromatch';
 import { GuardianError, IntegridadeStatus } from '../types/index.js';
 const { log, GuardianMensagens } = getMessages();
 function getErrMsg(err) {
@@ -11,8 +14,9 @@ function getErrMsg(err) {
 async function construirSnapshot(fileEntries) {
     const snapshot = {};
     for (const { relPath, content } of fileEntries) {
-        if (typeof content !== 'string' || !content.trim())
+        if (typeof content !== 'string' || !content.trim()) {
             continue;
+        }
         try {
             snapshot[relPath] = await gerarSnapshotDoConteudo(content);
         }
@@ -32,7 +36,8 @@ export async function scanSystemIntegrity(fileEntries, options) {
     catch (err) {
         log.aviso(GuardianMensagens.baselineInvalido(getErrMsg(err)));
     }
-    const ignorados = config.INCLUDE_EXCLUDE_RULES && config.INCLUDE_EXCLUDE_RULES.globalExcludeGlob || [];
+    // Filtra entradas conforme padrões ignorados específicos do Guardian
+    const ignorados = config.INCLUDE_EXCLUDE_RULES.globalExcludeGlob ?? [];
     const filtrados = fileEntries.filter(arquivo => {
         const rel = normalizePath(arquivo.relPath);
         return !micromatch.isMatch(rel, ignorados);
@@ -41,11 +46,13 @@ export async function scanSystemIntegrity(fileEntries, options) {
         const removidos = fileEntries.length - filtrados.length;
         log.info(GuardianMensagens.filtroAplicado(filtrados.length, removidos));
     }
+    // Usa import dinâmico para alinhar com mocks de teste (vi.mock/vi.doMock)
     const { gerarSnapshotDoConteudo: gerar } = await import('./hash.js');
     const snapshotAtual = {};
     for (const { relPath, content } of filtrados) {
-        if (typeof content !== 'string' || !content.trim())
+        if (typeof content !== 'string' || !content.trim()) {
             continue;
+        }
         try {
             snapshotAtual[relPath] = await gerar(content);
         }
@@ -55,6 +62,7 @@ export async function scanSystemIntegrity(fileEntries, options) {
     }
     if (!baselineAnterior) {
         if (options?.justDiff) {
+            // Em modo justDiff, ausência de baseline implica sem alterações reportáveis
             return {
                 status: IntegridadeStatus.Ok,
                 timestamp: agora,
@@ -102,7 +110,8 @@ export async function scanSystemIntegrity(fileEntries, options) {
 }
 export async function acceptNewBaseline(fileEntries) {
     const ignorados = [];
-    const ignoradosDyn = config.INCLUDE_EXCLUDE_RULES && config.INCLUDE_EXCLUDE_RULES.globalExcludeGlob || ignorados;
+    // Preferir configuração dinâmica quando disponível
+    const ignoradosDyn = config.INCLUDE_EXCLUDE_RULES.globalExcludeGlob ?? ignorados;
     const filtrados = fileEntries.filter(arquivo => {
         const rel = normalizePath(arquivo.relPath);
         return !micromatch.isMatch(rel, ignoradosDyn);
@@ -111,4 +120,3 @@ export async function acceptNewBaseline(fileEntries) {
     await ensureDir(LINHA_BASE_CAMINHO);
     await salvarBaseline(snapshotAtual);
 }
-//# sourceMappingURL=sentinel.js.map

package/dist/guardian/snapshot.js

@@ -0,0 +1,2 @@
+// SPDX-License-Identifier: MIT
+export {};

package/dist/guardian/verifier.js

@@ -1,11 +1,21 @@
+// SPDX-License-Identifier: MIT
 import { inicializarChaves, verificarAssinatura } from './index.js';
+/**
+ * Compara os arquivos atuais com os registros de integridade salvos e detecta divergências
+ * usando verificação de assinatura GPG.
+ *
+ * @param fileEntries Arquivos atuais lidos do sistema
+ * @param registrosSalvos Registros prévios salvos (assinaturas de referência)
+ * @returns Resultado contendo lista de arquivos corrompidos e total verificado
+ */
 export async function verificarRegistros(fileEntries, registrosSalvos) {
     const registrosMap = new Map(registrosSalvos.map(raiz => [raiz.arquivo, raiz.assinatura]));
     const corrompidos = [];
     await inicializarChaves();
     for (const { relPath, content } of fileEntries) {
-        if (!relPath || typeof content !== 'string' || !content.trim())
+        if (!relPath || typeof content !== 'string' || !content.trim()) {
             continue;
+        }
         const assinaturaEsperada = registrosMap.get(relPath);
         if (assinaturaEsperada) {
             const valido = await verificarAssinatura(content, assinaturaEsperada);
@@ -19,4 +29,3 @@ export async function verificarRegistros(fileEntries, registrosSalvos) {
         verificados: registrosSalvos.length
     };
 }
-//# sourceMappingURL=verifier.js.map

package/dist/guardian/watcher-hidden.js

@@ -1,5 +1,6 @@
-import { getMessages } from '../core/messages/index.js';
+// SPDX-License-Identifier: MIT
 import { carregarRegistros, inicializarChaves, REGISTRO_VIGIA_CAMINHO_PADRAO, salvarRegistros, verificarAssinatura } from './index.js';
+import { getMessages } from '../core/messages/index.js';
 const { log, VigiaOcultaMensagens } = getMessages();
 export async function vigiaOculta(arquivos, caminhoRegistro = REGISTRO_VIGIA_CAMINHO_PADRAO, autoReset = true) {
     const registros = await carregarRegistros(caminhoRegistro);
@@ -7,8 +8,9 @@ export async function vigiaOculta(arquivos, caminhoRegistro = REGISTRO_VIGIA_CAM
     const corrompidos = [];
     await inicializarChaves();
     for (const { relPath, content } of arquivos) {
-        if (!relPath || typeof content !== 'string' || !content.trim())
+        if (!relPath || typeof content !== 'string' || !content.trim()) {
             continue;
+        }
         const assinaturaEsperada = mapaAnterior.get(relPath);
         if (assinaturaEsperada) {
             const valido = await verificarAssinatura(content, assinaturaEsperada);
@@ -28,4 +30,3 @@ export async function vigiaOculta(arquivos, caminhoRegistro = REGISTRO_VIGIA_CAM
         }
     }
 }
-//# sourceMappingURL=watcher-hidden.js.map

package/dist/index.js

@@ -1,2 +1,2 @@
+// SPDX-License-Identifier: MIT
 export { analyzeFile, analyzeProject } from './sdk/analyzer.js';
-//# sourceMappingURL=index.js.map

package/dist/licenses/disclaimer.js

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: MIT
 import { execFile as _execFile } from 'node:child_process';
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
@@ -8,11 +9,13 @@ function execFileAsync(cmd, args, opts = {}) {
             shell: false,
             ...opts
         }, (err, stdout, stderr) => {
-            if (err)
-                return reject(Object.assign(err, {
+            if (err) {
+                reject(Object.assign(err, {
                     stdout,
                     stderr
                 }));
+                return;
+            }
             resolve({
                 stdout: String(stdout || ''),
                 stderr: String(stderr || '')
@@ -38,8 +41,9 @@ async function listMarkdown(root) {
             for (const erro of entries) {
                 const caminho = path.join(dir, erro.name);
                 if (erro.isDirectory()) {
-                    if (/^(node_modules|dist|\.git|pre-public|preview-mahoraga|coverage|relatorios|\.mahoraga)$/i.test(erro.name))
+                    if (/^(node_modules|dist|\.git|pre-public|preview-mahoraga|coverage|relatorios|\.mahoraga)$/i.test(erro.name)) {
                         continue;
+                    }
                     out.push(...(await walk(caminho)));
                 }
                 else if (/\.md$/i.test(erro.name)) {
@@ -61,14 +65,17 @@ export async function addDisclaimer({ root = process.cwd(), disclaimerPath = def
     for (const rel of files) {
         const abs = path.join(root, rel);
         const content = await fs.readFile(abs, 'utf8').catch(() => null);
-        if (content === null)
+        if (content === null) {
             continue;
+        }
         const head = content.split('\n').slice(0, 30).join('\n');
-        if (marker.test(head))
+        if (marker.test(head)) {
             continue;
+        }
         const updated = `${disclaimerText}\n\n${content.trimStart()}\n`;
-        if (!dryRun)
+        if (!dryRun) {
             await fs.writeFile(abs, updated, 'utf8');
+        }
         updatedArquivos.push(rel);
     }
     return {
@@ -81,11 +88,13 @@ export async function verifyDisclaimer({ root = process.cwd(), disclaimerPath =
     for (const rel of files) {
         const abs = path.join(root, rel);
         const content = await fs.readFile(abs, 'utf8').catch(() => null);
-        if (content === null)
+        if (content === null) {
             continue;
+        }
         const head = content.split('\n').slice(0, 30).join('\n');
-        if (!marker.test(head))
+        if (!marker.test(head)) {
             missing.push(rel);
+        }
     }
     return {
         missing
@@ -95,4 +104,3 @@ export const disclaimerModule = {
     addDisclaimer,
     verifyDisclaimer
 };
-//# sourceMappingURL=disclaimer.js.map