@mocoto/mahoraga 0.14.7 → 0.14.9

package/dist/core/schema/version.js

@@ -1,14 +1,5 @@
-// SPDX-License-Identifier: MIT
-/**
- * Sistema de Versionamento de Schema para Relatórios JSON
- *
- * Este módulo gerencia versões de schema para relatórios JSON do Mahoraga,
- * garantindo compatibilidade futura e evolução controlada dos formatos.
- */
 import { messages } from '../messages/index.js';
-/** Versão atual do schema */
 export const VERSAO_ATUAL = '1.0.0';
-/** Histórico de versões do schema */
 export const HISTORICO_VERSOES = {
     '1.0.0': {
         versao: '1.0.0',
@@ -19,9 +10,6 @@ export const HISTORICO_VERSOES = {
         camposOpcionais: ['_schema.compatibilidade', '_schema.camposObrigatorios', '_schema.camposOpcionais']
     }
 };
-/**
- * Cria metadados de schema para a versão atual
- */
 export function criarSchemaMetadata(versao = VERSAO_ATUAL, descricaoPersonalizada) {
     if (!(versao in HISTORICO_VERSOES)) {
         throw new Error(messages.ExcecoesMensagens.versaoSchemaDesconhecida(versao));
@@ -34,20 +22,15 @@ export function criarSchemaMetadata(versao = VERSAO_ATUAL, descricaoPersonalizad
         })
     };
 }
-/**
- * Valida se um relatório tem schema válido
- */
 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,
             erros
         };
     }
-    // Verificar presença do schema
     if (!('_schema' in relatorio) || !relatorio._schema) {
         erros.push('Campo _schema é obrigatório');
         return {
@@ -56,18 +39,15 @@ export function validarSchema(relatorio) {
         };
     }
     const schema = relatorio._schema;
-    // Verificar campos obrigatórios do schema
     const camposObrigatorios = ['versao', 'criadoEm', 'descricao'];
     for (const campo of camposObrigatorios) {
         if (!(campo in schema)) {
             erros.push(`Campo _schema.${campo} é obrigatório`);
         }
     }
-    // Verificar se a versão existe no histórico
     if (schema.versao && typeof schema.versao === 'string' && !(schema.versao in HISTORICO_VERSOES)) {
         erros.push(`Versão de schema desconhecida: ${schema.versao}`);
     }
-    // Verificar presença dos dados
     if (!('dados' in relatorio)) {
         erros.push('Campo dados é obrigatório');
     }
@@ -76,48 +56,28 @@ export function validarSchema(relatorio) {
         erros
     };
 }
-/**
- * Migra um relatório para a versão atual se necessário
- */
 export function migrarParaVersaoAtual(relatorio) {
-    // Se já tem schema válido, retornar como está
     const validacao = validarSchema(relatorio);
     if (validacao.valido && relatorio._schema) {
         return relatorio;
     }
-    // Se não tem schema, rejeitar: relatórios sem `_schema` são considerados formatos antigos
-    // e devem ser migrados explicitamente pelo consumidor antes de chamar esta função.
-    // Se não tem schema, considerar que é um relatório legado e migrar explicitamente
-    // Chamadas a esta função são a migração explícita, então embrulhamos o relatório
-    // antigo com os metadados de versão atuais.
     if (!('_schema' in relatorio) || !relatorio._schema) {
         return criarRelatorioComVersao(relatorio);
     }
-    // Para futuras migrações, implementar lógica aqui
-    // Por enquanto, apenas revalidar
     if (!validacao.valido) {
         throw new Error(messages.ExcecoesMensagens.relatorioSchemaInvalido(validacao.erros.join(', ')));
     }
     return relatorio;
 }
-/**
- * Cria um relatório com versão atual
- */
 export function criarRelatorioComVersao(dados, versao = VERSAO_ATUAL, descricao) {
     return {
         _schema: criarSchemaMetadata(versao, descricao),
         dados
     };
 }
-/**
- * Extrai apenas os dados de um relatório versionado
- */
 export function extrairDados(relatorio) {
     return relatorio.dados;
 }
-/**
- * Verifica se uma versão é compatível com a atual
- */
 export function versaoCompativel(versao) {
     if (!(versao in HISTORICO_VERSOES)) {
         return false;

package/dist/core/utils/chalk.js

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

package/dist/core/utils/exec-safe.js

@@ -1,14 +1,7 @@
-// SPDX-License-Identifier: MIT
 import { execFileSync } from 'node:child_process';
 import path from 'node:path';
 import { config } from '../config/index.js';
 import { getMessages } from '../messages/index.js';
-/**
- * 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.
- */
 const BINARIOS_PERMITIDOS = new Set([
     'git',
     'npm',
@@ -18,11 +11,6 @@ const BINARIOS_PERMITIDOS = new Set([
     '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)) {
@@ -34,38 +22,11 @@ function verificarSafeMode() {
         throw new Error(getMessages().ExecSafeMensagens.safeModeBloqueado);
     }
 }
-/**
- * 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.
- * 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,
- *         se o binário não estiver na allowlist,
- *         ou se a execução falhar
- */
 export function executarShellSeguro(bin, args = [], opts = {}) {
     validarBinario(bin);
     verificarSafeMode();
     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 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,
- *         se o binário não estiver na allowlist,
- *         ou se a execução falhar
- */
 export function executarShellSeguroAsync(bin, args = [], opts = {}) {
     return executarShellSeguro(bin, args, opts);
 }

package/dist/core/utils/import-safe.js

@@ -1,4 +1,3 @@
-// SPDX-License-Identifier: MIT
 import { config, resolverPluginSeguro } from '../config/index.js';
 import { messages } from '../messages/index.js';
 export async function importarModuloSeguro(baseDir, pluginRel) {
@@ -12,6 +11,5 @@ export async function importarModuloSeguro(baseDir, pluginRel) {
     if (!resolvido.caminho) {
         throw new Error(messages.ExcecoesMensagens.caminhoPluginNaoResolvido);
     }
-    // permite que o chamador capture exceções do plugin
     return import(resolvido.caminho);
 }

package/dist/core/utils/index.js

@@ -1,7 +1,3 @@
-// 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';

package/dist/core/workers/index.js

@@ -1,6 +1,2 @@
-// SPDX-License-Identifier: MIT
-/**
- * @fileoverview Core worker pool management
- */
 export * from './worker-executor.js';
 export * from './worker-pool.js';

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

@@ -1,16 +1,8 @@
-// @mahoraga-disable ml-deep-nesting
-// 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') {
@@ -66,7 +58,6 @@ async function processarLote(lote, contexto) {
     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);
@@ -82,7 +73,6 @@ async function processarLote(lote, contexto) {
                     }
                 }
                 catch {
-                    // Se falhar parsing, segue sem AST (analistas que precisam de AST tratarão null)
                 }
             }
         }
@@ -142,13 +132,11 @@ 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);
@@ -178,7 +166,6 @@ async function main() {
             }
         }
         catch {
-            // ignore
         }
     }
     finally {

package/dist/guardian/baseline.js

@@ -1,11 +1,6 @@
-// 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);
@@ -19,9 +14,6 @@ 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), {

package/dist/guardian/constants.js

@@ -1,23 +1,5 @@
-// 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;
+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;

package/dist/guardian/diff.js

@@ -1,20 +1,15 @@
-// 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;
-    globalAny.__SUKUNA_DIFF_CACHE__ ??= new Map();
-    const cache = globalAny.__SUKUNA_DIFF_CACHE__;
+    globalAny.__MAHORAGA_DIFF_CACHE__ ??= new Map();
+    const cache = globalAny.__MAHORAGA_DIFF_CACHE__;
     if (cache.has(cacheChave)) {
         const globAny = globalAny;
-        globAny.__SUKUNA_DIFF_CACHE_HITS__ = (globAny.__SUKUNA_DIFF_CACHE_HITS__ ?? 0) + 1;
+        globAny.__MAHORAGA_DIFF_CACHE_HITS__ = (globAny.__MAHORAGA_DIFF_CACHE_HITS__ ?? 0) + 1;
         const hit = cache.get(cacheChave);
         if (hit) {
             return hit;
@@ -31,9 +26,6 @@ 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) {

package/dist/guardian/gpg.js

@@ -1,4 +1,3 @@
-// SPDX-License-Identifier: MIT
 import { CHAVE_PRIVADA_CAMINHO, CHAVE_PUBLICA_CAMINHO } from './index.js';
 import * as openpgp from 'openpgp';
 import { messages } from '../core/messages/index.js';

package/dist/guardian/hash.js

@@ -1,19 +1,8 @@
-// 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);

package/dist/guardian/index.js

@@ -1,7 +1,3 @@
-// SPDX-License-Identifier: MIT
-/**
- * @fileoverview Guardian: baseline, diff, hash, sentinela, verificador
- */
 export * from './baseline.js';
 export * from './constants.js';
 export * from './diff.js';

package/dist/guardian/integrity.js

@@ -1,4 +1,3 @@
-// SPDX-License-Identifier: MIT
 import { IntegridadeStatus } from '../types/guardian/integrity.js';
 export { IntegridadeStatus };
 export class GuardianError extends Error {

package/dist/guardian/records.js

@@ -1,4 +1,3 @@
-// SPDX-License-Identifier: MIT
 import path from 'node:path';
 import { gerarSnapshotDoConteudo } from './index.js';
 import { config } from '../core/config/index.js';
@@ -6,14 +5,10 @@ import { getMessages } from '../core/messages/index.js';
 import { ensureDir } from '../shared/helpers/index.js';
 import { lerEstado, salvarEstado } from '../shared/persistence/index.js';
 const DESTINO_PADRAO = path.join(config.STATE_DIR, 'integridade.json');
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function getLog() {
     const { log, GuardianMensagens } = getMessages();
     return { log, GuardianMensagens };
 }
-/**
- * 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) {
@@ -28,9 +23,6 @@ export async function salvarRegistros(fileEntries, destino = DESTINO_PADRAO) {
     const { log, GuardianMensagens } = getLog();
     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);

package/dist/guardian/result.js

@@ -1,11 +1,4 @@
-// SPDX-License-Identifier: MIT
-/**
- * Tipos para resultados do Guardian
- */
 import { IntegridadeStatus } from './index.js';
-/**
- * Type guard para verificar se é resultado válido do Guardian
- */
 export function isGuardianResult(value) {
     if (value === null || value === undefined) {
         return true;
@@ -20,18 +13,13 @@ export function isGuardianResult(value) {
     const status = obj.status;
     return (status === 'ok' || status === 'alteracoes-detectadas' || status === 'erro');
 }
-/**
- * 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 {
@@ -59,6 +47,5 @@ export function converterResultadoGuardian(resultado) {
             message: resultado.detalhes?.join('; ') ?? 'Alterações detectadas',
         };
     }
-    // Outros casos
     return null;
 }

package/dist/guardian/sentinel.js

@@ -1,13 +1,9 @@
-// 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 { ensureDir, normalizePath } from '../shared/helpers/index.js';
 import { GuardianError, IntegridadeStatus } from '../types/index.js';
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function getLog() {
     const { log, GuardianMensagens } = getMessages();
     return { log, GuardianMensagens };
@@ -42,7 +38,6 @@ export async function scanSystemIntegrity(fileEntries, options) {
     catch (err) {
         log.aviso(GuardianMensagens.baselineInvalido(getErrMsg(err)));
     }
-    // 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);
@@ -52,7 +47,6 @@ 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) {
@@ -68,7 +62,6 @@ 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,
@@ -116,7 +109,6 @@ export async function scanSystemIntegrity(fileEntries, options) {
 }
 export async function acceptNewBaseline(fileEntries) {
     const 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);

package/dist/guardian/snapshot.js

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

package/dist/guardian/verifier.js

@@ -1,13 +1,4 @@
-// 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 = [];

package/dist/guardian/watcher-hidden.js

@@ -1,7 +1,5 @@
-// SPDX-License-Identifier: MIT
 import { carregarRegistros, inicializarChaves, REGISTRO_VIGIA_CAMINHO_PADRAO, salvarRegistros, verificarAssinatura } from './index.js';
 import { getMessages } from '../core/messages/index.js';
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function getLog() {
     const { log, VigiaOcultaMensagens } = getMessages();
     return { log, VigiaOcultaMensagens };

package/dist/lib/api.js

@@ -0,0 +1,13 @@
+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/licenses/disclaimer.js

@@ -1,5 +1,3 @@
-// @mahoraga-disable ml-deep-nesting
-// SPDX-License-Identifier: MIT
 import { execFile as _execFile } from 'node:child_process';
 import { promises as fs } from 'node:fs';
 import path from 'node:path';

package/dist/licenses/fs-utils.js

@@ -1,10 +1,5 @@
-// SPDX-License-Identifier: MIT
 import fs from 'node:fs';
 import path from 'node:path';
-/**
- * Check whether a path exists on the filesystem.
- * @param p - Path to check
- */
 export function exists(caminho) {
     try {
         fs.statSync(caminho);
@@ -14,11 +9,6 @@ export function exists(caminho) {
         return false;
     }
 }
-/**
- * Read and parse a package.json file synchronously.
- * Returns null on error.
- * @param pkgPath - Path to package.json
- */
 export function readPackageJsonSync(pkgCaminho) {
     try {
         const data = fs.readFileSync(pkgCaminho, 'utf8');
@@ -32,10 +22,6 @@ export function readPackageJsonSync(pkgCaminho) {
         return null;
     }
 }
-/**
- * Locate a probable license file in a package directory and return its text where possible.
- * @param dir - package directory
- */
 export function findLicenseFile(dir) {
     try {
         const candidates = fs.readdirSync(dir).filter(arquivo => /^(license|licence|copying)/i.test(arquivo));

package/dist/licenses/generate-notices.js

@@ -1,5 +1,3 @@
-// @mahoraga-disable ml-deep-nesting
-// SPDX-License-Identifier: MIT
 import { execFile as _execFile } from 'node:child_process';
 import fs from 'node:fs/promises';
 import path from 'node:path';
@@ -105,7 +103,6 @@ export async function generateNotices({ root = process.cwd(), ptBr = false, outp
             });
         }
         catch {
-            // ignore
         }
     }
     if (!results) {

package/dist/licenses/header-options.js

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

package/dist/licenses/index.js

@@ -1,7 +1,3 @@
-// SPDX-License-Identifier: MIT
-/**
- * @fileoverview License scanning and management
- */
 export { addDisclaimer, disclaimerModule, verifyDisclaimer } from './disclaimer.js';
 export * from './fs-utils.js';
 export { generateNotices } from './generate-notices.js';

package/dist/licenses/licenses.js

@@ -1,5 +1 @@
-// SPDX-License-Identifier: MIT
-/**
- * Tipos para o módulo de licenciamento (licensas).
- */
 export {};

package/dist/licenses/normalizer.js

@@ -1,8 +1,3 @@
-// @mahoraga-disable ml-deep-nesting
-// SPDX-License-Identifier: MIT
-/**
- * License normalizer ported from original JS implementation.
- */
 import { getMessages } from '../core/messages/index.js';
 const { log } = getMessages();
 const LicensasMensagens = getMessages().LicensasMensagens;
@@ -98,11 +93,6 @@ function fallbackNormalize(raw) {
         return token;
     }).join(' ');
 }
-/**
- * Normalize a license value into a canonical string (preferably SPDX-like).
- * Supports strings, arrays and simple objects ({ type }).
- * Falls back to a heuristic normalizer when full SPDX libraries are not available.
- */
 export async function normalizeLicense(raw) {
     await tryLoadSpdx();
     if (spdxParse && typeof raw === 'string' && /\b(OR|AND)\b/i.test(raw)) {
@@ -120,7 +110,6 @@ export async function normalizeLicense(raw) {
         }
         catch (err) {
             log.debug(`${LicensasMensagens.erroNormalizarLicencaComplexa} - ${err instanceof Error ? err.message : String(err)}`);
-            // fallthrough
         }
     }
     return fallbackNormalize(raw);