@semacode/cli 2.3.1 → 3.0.0

package/dist/projetoOrigens.js

@@ -1,6 +1,6 @@
 // SEMA-GOVERNED: sema.produto.governanca_ia.contexto
 // Descrição: resolve base, origens de contratos e diret?rios de c?digo do projeto.
-import { readdir, stat } from 'node:fs/promises';
+import { readdir, realpath, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { listarArquivosSema } from '@sema/nucleo';
 import { caminhoExiste, DIRETORIOS_CODIGO_IGNORADOS, EXTENSOES_CODIGO, listarDiretoriosFilhos, } from './projetoBusca.js';
@@ -10,7 +10,12 @@ const DIRETORIOS_CODIGO_FIXOS = [
     "app",
     "apps",
     "backend",
+    "frontend",
+    "client",
+    "web",
     "lib",
+    "packages",
+    "pacotes",
     "api",
     "server",
     "services",
@@ -21,6 +26,59 @@ const DIRETORIOS_CODIGO_FIXOS = [
     "functions",
     "scripts",
 ];
+export function resolverRaizesLogicasCodigoSemCaminhada(baseProjeto) {
+    return [path.resolve(baseProjeto), ...DIRETORIOS_CODIGO_FIXOS
+            .map((segmento) => path.resolve(baseProjeto, segmento))];
+}
+function caminhoEstaDentro(raiz, alvo) {
+    const relativo = path.relative(path.resolve(raiz), path.resolve(alvo));
+    return relativo === "" || (relativo !== ".."
+        && !relativo.startsWith(`..${path.sep}`)
+        && !path.isAbsolute(relativo));
+}
+function erroEhAusencia(erro) {
+    return ["ENOENT", "ENOTDIR"].includes(erro.code ?? "");
+}
+async function resolverDiretoriosConfiguradosConfinados(baseProjeto, baseConfiguracao, declarados, campo) {
+    const baseLogica = path.resolve(baseProjeto);
+    const baseReal = await realpath(baseLogica);
+    const resolvidos = new Map();
+    for (const [indice, declarado] of declarados.entries()) {
+        const identificadorSeguro = `${campo}[${indice}]`;
+        const absoluto = path.resolve(baseConfiguracao, declarado);
+        if (!caminhoEstaDentro(baseLogica, absoluto)) {
+            throw new Error(`${identificadorSeguro} aponta para fora da base do projeto`);
+        }
+        let canonico = absoluto;
+        try {
+            const [real, informacao] = await Promise.all([realpath(absoluto), stat(absoluto)]);
+            if (!informacao.isDirectory()) {
+                throw new Error(`${identificadorSeguro} nao e diretorio`);
+            }
+            if (!caminhoEstaDentro(baseReal, real)) {
+                throw new Error(`${identificadorSeguro} resolve fora da base do projeto`);
+            }
+            canonico = real;
+        }
+        catch (erro) {
+            if (!erroEhAusencia(erro)) {
+                throw erro;
+            }
+        }
+        const chave = process.platform === "win32" ? canonico.toLowerCase() : canonico;
+        if (!resolvidos.has(chave)) {
+            resolvidos.set(chave, canonico);
+        }
+    }
+    return [...resolvidos.values()].sort((a, b) => a.localeCompare(b, "pt-BR"));
+}
+export async function resolverDiretoriosCodigoConfigurados(baseProjeto, configCarregada) {
+    const declarados = configCarregada?.config.diretoriosCodigo ?? [];
+    if (declarados.length === 0) {
+        return [];
+    }
+    return resolverDiretoriosConfiguradosConfinados(baseProjeto, configCarregada.baseDiretorio, declarados, "diretoriosCodigo");
+}
 export async function resolverEntradaPadrao(cwd, configCarregada) {
     if (configCarregada) {
         return configCarregada.baseDiretorio;
@@ -100,18 +158,19 @@ async function descobrirOrigemPadrao(baseProjeto, entradaResolvida) {
 }
 export async function resolverOrigensProjeto(baseProjeto, entradaResolvida, configCarregada) {
     if (configCarregada) {
+        const confinar = (origens) => resolverDiretoriosConfiguradosConfinados(baseProjeto, configCarregada.baseDiretorio, origens, "origens");
         const infoEntrada = await stat(entradaResolvida);
         if (infoEntrada.isFile()) {
-            return [path.resolve(path.dirname(entradaResolvida))];
+            return confinar([path.dirname(entradaResolvida)]);
         }
         if (path.resolve(entradaResolvida) !== path.resolve(configCarregada.baseDiretorio)) {
-            return [path.resolve(entradaResolvida)];
+            return confinar([entradaResolvida]);
         }
         const declaradas = configCarregada.config.origens ?? (configCarregada.config.origem ? [configCarregada.config.origem] : []);
         if (declaradas.length > 0) {
-            return declaradas.map((origem) => path.resolve(configCarregada.baseDiretorio, origem));
+            return confinar(declaradas);
         }
-        return [configCarregada.baseDiretorio];
+        return confinar([configCarregada.baseDiretorio]);
     }
     const infoEntrada = await stat(entradaResolvida);
     if (infoEntrada.isFile()) {
@@ -149,10 +208,7 @@ async function diretorioTemArquivosCodigo(diretorioBase, profundidadeMaxima = 4)
 }
 export async function inferirDiretoriosCodigo(baseProjeto, configCarregada) {
     if (configCarregada?.config.diretoriosCodigo?.length) {
-        return [...new Set(configCarregada.config.diretoriosCodigo
-                .map((diretorio) => path.resolve(configCarregada.baseDiretorio, diretorio))
-                .filter(Boolean))]
-            .sort((a, b) => a.localeCompare(b, "pt-BR"));
+        return resolverDiretoriosCodigoConfigurados(baseProjeto, configCarregada);
     }
     const candidatosFixos = DIRETORIOS_CODIGO_FIXOS
         .map((segmento) => path.join(baseProjeto, segmento));

package/dist/projetoTipos.d.ts

@@ -4,6 +4,7 @@ import type { EstruturaSaida, FonteLegado, ModoAdocao } from './tipos.js';
 export type EscopoCarregamentoProjeto = "arquivo" | "modulo" | "projeto";
 export interface OpcoesCarregarProjeto {
     escopo?: EscopoCarregamentoProjeto;
+    adiarDescobertaCodigo?: boolean;
 }
 export interface ConfiguracaoPersistenciaProjeto {
     enginesHabilitados?: EngineBanco[];

package/dist/resultadoCli.d.ts

@@ -0,0 +1,20 @@
+export declare const SCHEMA_RESULTADO_CLI_V1: "sema.cli.result/v1";
+export declare const CODIGO_SAIDA_FATAL_RUNTIME_CLI: 70;
+export type TipoResultadoCliV1 = "SUCCESS" | "DOMAIN_ERROR";
+export interface EnvelopeResultadoCliV1 {
+    readonly schemaVersion: typeof SCHEMA_RESULTADO_CLI_V1;
+    readonly ok: boolean;
+    readonly kind: TipoResultadoCliV1;
+    readonly command: string;
+    readonly code: "CLI_SUCCESS" | "CLI_DOMAIN_ERROR";
+    readonly message: string | null;
+    readonly exitCode: number;
+    readonly payload: unknown;
+}
+export interface EntradaEnvelopeResultadoCliV1 {
+    readonly comando: string;
+    readonly codigoSaida: number;
+    readonly stdout: string;
+}
+export declare function interpretarPayloadRuntimeCli(stdout: string): unknown;
+export declare function criarEnvelopeResultadoCliV1(entrada: EntradaEnvelopeResultadoCliV1): EnvelopeResultadoCliV1;

package/dist/resultadoCli.js

@@ -0,0 +1,57 @@
+// SEMA-GOVERNED: sema.produto.cli_invocacao_publica.resultados
+// Descrição: modela o envelope único de resultados JSON da CLI pública 3.0.
+export const SCHEMA_RESULTADO_CLI_V1 = "sema.cli.result/v1";
+export const CODIGO_SAIDA_FATAL_RUNTIME_CLI = 70;
+const COMANDO_CANONICO_VALIDO = /^[a-z][a-z0-9-]{0,63}$/u;
+const MENSAGEM_PUBLICA_ERRO_DOMINIO = "O comando Sema não foi concluído.";
+const SCHEMAS_ENVELOPE_CLI = new Set([
+    SCHEMA_RESULTADO_CLI_V1,
+    "sema.cli.control/v1",
+]);
+function validarComandoCanonico(comando) {
+    if (!COMANDO_CANONICO_VALIDO.test(comando)) {
+        throw new TypeError("Comando canônico inválido.");
+    }
+    return comando;
+}
+function validarCodigoSaida(codigoSaida) {
+    if (!Number.isSafeInteger(codigoSaida) || codigoSaida < 0 || codigoSaida > 255) {
+        throw new TypeError("Código de saída inválido.");
+    }
+    return codigoSaida;
+}
+export function interpretarPayloadRuntimeCli(stdout) {
+    if (stdout.trim().length === 0)
+        return null;
+    let payload;
+    try {
+        payload = JSON.parse(stdout);
+    }
+    catch {
+        return stdout;
+    }
+    if (payload !== null
+        && typeof payload === "object"
+        && !Array.isArray(payload)
+        && Object.prototype.hasOwnProperty.call(payload, "schemaVersion")
+        && SCHEMAS_ENVELOPE_CLI.has(payload.schemaVersion)) {
+        throw new TypeError("Payload não pode conter outro envelope público da CLI.");
+    }
+    return payload;
+}
+export function criarEnvelopeResultadoCliV1(entrada) {
+    const command = validarComandoCanonico(entrada.comando);
+    const exitCode = validarCodigoSaida(entrada.codigoSaida);
+    const sucesso = exitCode === 0;
+    return {
+        schemaVersion: SCHEMA_RESULTADO_CLI_V1,
+        ok: sucesso,
+        kind: sucesso ? "SUCCESS" : "DOMAIN_ERROR",
+        command,
+        code: sucesso ? "CLI_SUCCESS" : "CLI_DOMAIN_ERROR",
+        message: sucesso ? null : MENSAGEM_PUBLICA_ERRO_DOMINIO,
+        exitCode,
+        payload: interpretarPayloadRuntimeCli(entrada.stdout),
+    };
+}
+//# sourceMappingURL=resultadoCli.js.map

package/dist/saidaCli.d.ts

@@ -0,0 +1,35 @@
+import { type EntradaEnvelopeResultadoCliV1, type EnvelopeResultadoCliV1 } from "./resultadoCli.js";
+export { CODIGO_SAIDA_FATAL_RUNTIME_CLI, SCHEMA_RESULTADO_CLI_V1, criarEnvelopeResultadoCliV1, interpretarPayloadRuntimeCli, type EntradaEnvelopeResultadoCliV1, type EnvelopeResultadoCliV1, type TipoResultadoCliV1, } from "./resultadoCli.js";
+export declare const SCHEMA_CONTROLE_CLI_V1: "sema.cli.control/v1";
+export type TipoControleCli = "HELP" | "UNKNOWN_COMMAND" | "ARGUMENT_ERROR" | "FATAL_ERROR";
+export interface EnvelopeControleJsonV1 {
+    readonly schemaVersion: typeof SCHEMA_CONTROLE_CLI_V1;
+    readonly ok: boolean;
+    readonly kind: TipoControleCli;
+    readonly code: string;
+    readonly message: string;
+    readonly exitCode: number;
+}
+export interface EntradaEnvelopeControleJsonV1 {
+    readonly categoria: TipoControleCli;
+    readonly codigoPublico: string;
+    readonly mensagemPublica: string;
+    readonly codigoSaida: number;
+}
+export interface OpcoesInvocacaoPublica {
+    readonly resultado: TipoControleCli;
+    readonly modoJson: boolean;
+    readonly envelopeControle?: EnvelopeControleJsonV1;
+    readonly mensagemTexto?: string;
+}
+export interface RelatorioInvocacaoPublica {
+    readonly codigoSaida: number;
+    readonly envelopeControleEmitido: boolean;
+    readonly stderrVazio: boolean;
+    readonly handlerExecutado: boolean;
+    readonly politicaControleJsonV1Respeitada: boolean;
+    readonly politicaHelpPuroRespeitada: boolean;
+}
+export declare function criarEnvelopeControleJsonV1(entrada: EntradaEnvelopeControleJsonV1): EnvelopeControleJsonV1;
+export declare function emitirResultadoCliJsonV1(entrada: EntradaEnvelopeResultadoCliV1): EnvelopeResultadoCliV1;
+export declare function executarInvocacaoPublica(opcoes: OpcoesInvocacaoPublica): RelatorioInvocacaoPublica;

package/dist/saidaCli.js

@@ -0,0 +1,118 @@
+// SEMA-GOVERNED: sema.produto.cli_invocacao_publica, sema.produto.cli_invocacao_publica.resultados
+// Descrição: cria e emite os envelopes JSON públicos de controle v1 e resultado v1 da CLI.
+import { criarEnvelopeResultadoCliV1, } from "./resultadoCli.js";
+export { CODIGO_SAIDA_FATAL_RUNTIME_CLI, SCHEMA_RESULTADO_CLI_V1, criarEnvelopeResultadoCliV1, interpretarPayloadRuntimeCli, } from "./resultadoCli.js";
+export const SCHEMA_CONTROLE_CLI_V1 = "sema.cli.control/v1";
+const CODIGO_PADRAO = {
+    HELP: "CLI_HELP",
+    UNKNOWN_COMMAND: "CLI_UNKNOWN_COMMAND",
+    ARGUMENT_ERROR: "CLI_ARGUMENT_ERROR",
+    FATAL_ERROR: "CLI_FATAL_ERROR",
+};
+const MENSAGEM_PADRAO = {
+    HELP: "Ajuda da CLI Sema.",
+    UNKNOWN_COMMAND: "Comando Sema desconhecido.",
+    ARGUMENT_ERROR: "Argumentos inválidos. Consulte a ajuda do comando.",
+    FATAL_ERROR: "Falha ao executar a CLI da Sema.",
+};
+const CODIGO_PUBLICO_VALIDO = /^[A-Z][A-Z0-9_]{2,63}$/u;
+const PREFIXO_ERRO_INTERNO = /\b(?:Aggregate|Eval|Internal|Range|Reference|Syntax|Type|URI)?Error\s*:/iu;
+const TRECHO_STACK = /(?:^|[\s;|=(:,])at\s+(?:async\s+)?(?:new\s+)?[^\n]{0,240}?(?:\([^()\n]*:\d+:\d+\)|[^\s()\n]+:\d+:\d+)/iu;
+function decodificarPercentAscii(valor) {
+    return valor.replace(/%([0-9a-f]{2})/giu, (_trecho, hexadecimal) => String.fromCharCode(Number.parseInt(hexadecimal, 16)));
+}
+function variantesTextoPublico(valor) {
+    const variantes = new Set([valor.normalize("NFC")]);
+    let atual = valor;
+    for (let tentativa = 0; tentativa < 3; tentativa += 1) {
+        const decodificado = decodificarPercentAscii(atual);
+        if (decodificado === atual) {
+            break;
+        }
+        variantes.add(decodificado.normalize("NFC"));
+        atual = decodificado;
+    }
+    return [...variantes];
+}
+function contemCaminhoAbsoluto(valor) {
+    return variantesTextoPublico(valor).some((variante) => {
+        const normalizada = variante.replaceAll("\\", "/");
+        const semUrlsPublicas = normalizada.replace(/\b(?:https?|wss?):\/\/[^\s"'<>]+/giu, "");
+        return /(?:^|[^A-Za-z0-9])file:\/{1,3}/iu.test(semUrlsPublicas)
+            || /(?:^|[^A-Za-z0-9])[A-Za-z]:\/(?:[^/\s"'<>]+(?:\/[^/\s"'<>]*)*)?/u.test(semUrlsPublicas)
+            || /(?:^|[^A-Za-z0-9_./])\/\/[^/\s"'<>]+\/[^/\s"'<>]+/u.test(semUrlsPublicas)
+            || /(?:^|[^A-Za-z0-9_./])\/(?!\/)[^/\s"'<>]+(?:\/[^/\s"'<>]*)*/u.test(semUrlsPublicas);
+    });
+}
+function normalizarCodigoPublico(categoria, codigo) {
+    const candidato = codigo.trim();
+    return CODIGO_PUBLICO_VALIDO.test(candidato) ? candidato : CODIGO_PADRAO[categoria];
+}
+function normalizarMensagemPublica(categoria, mensagem) {
+    if (categoria !== "HELP") {
+        return MENSAGEM_PADRAO[categoria];
+    }
+    const candidata = mensagem.trim();
+    if (!candidata
+        || contemCaminhoAbsoluto(candidata)
+        || TRECHO_STACK.test(candidata)
+        || PREFIXO_ERRO_INTERNO.test(candidata)) {
+        return MENSAGEM_PADRAO[categoria];
+    }
+    return candidata;
+}
+export function criarEnvelopeControleJsonV1(entrada) {
+    const help = entrada.categoria === "HELP";
+    const exitCode = help
+        ? 0
+        : entrada.codigoSaida === 0
+            ? 1
+            : entrada.codigoSaida;
+    return {
+        schemaVersion: SCHEMA_CONTROLE_CLI_V1,
+        ok: help,
+        kind: entrada.categoria,
+        code: normalizarCodigoPublico(entrada.categoria, entrada.codigoPublico),
+        message: normalizarMensagemPublica(entrada.categoria, entrada.mensagemPublica),
+        exitCode,
+    };
+}
+export function emitirResultadoCliJsonV1(entrada) {
+    const envelope = criarEnvelopeResultadoCliV1(entrada);
+    // Uma única escrita lógica impede documentos JSON parciais no processo público.
+    console.log(JSON.stringify(envelope, null, 2));
+    return envelope;
+}
+function envelopeSeguroParaInvocacao(resultado, envelope, mensagemTexto) {
+    const coerente = envelope?.kind === resultado ? envelope : undefined;
+    return criarEnvelopeControleJsonV1({
+        categoria: resultado,
+        codigoPublico: coerente?.code ?? CODIGO_PADRAO[resultado],
+        mensagemPublica: resultado === "HELP"
+            ? coerente?.message ?? mensagemTexto ?? MENSAGEM_PADRAO.HELP
+            : MENSAGEM_PADRAO[resultado],
+        codigoSaida: coerente?.exitCode ?? (resultado === "HELP" ? 0 : 1),
+    });
+}
+export function executarInvocacaoPublica(opcoes) {
+    const envelope = envelopeSeguroParaInvocacao(opcoes.resultado, opcoes.envelopeControle, opcoes.mensagemTexto);
+    if (opcoes.modoJson) {
+        // Uma única escrita lógica mantém JSON de controle em um único documento no stdout.
+        console.log(JSON.stringify(envelope, null, 2));
+    }
+    else if (opcoes.resultado === "HELP") {
+        console.log(envelope.message);
+    }
+    else {
+        console.error(envelope.message);
+    }
+    return {
+        codigoSaida: envelope.exitCode,
+        envelopeControleEmitido: opcoes.modoJson,
+        stderrVazio: opcoes.modoJson || opcoes.resultado === "HELP",
+        handlerExecutado: false,
+        politicaControleJsonV1Respeitada: true,
+        politicaHelpPuroRespeitada: true,
+    };
+}
+//# sourceMappingURL=saidaCli.js.map

package/dist/sistemasInterativos/acceptanceEvidence.d.ts

@@ -0,0 +1,22 @@
+import { type AcceptanceLockV1, type AcceptanceOperationValue, type AcceptanceTimeRange, type MultimodalChannelType, type MultimodalEvidenceDescriptorV1, type OperationResult, type Sha256 } from "./operationsTypes.js";
+export declare function validarAcceptanceLock(input: unknown): OperationResult<{
+    readonly lock: AcceptanceLockV1;
+    readonly lockDigest: Sha256;
+}>;
+export declare function operarAcceptanceLock(operation: unknown, lockInput: unknown, contextInput: unknown): OperationResult<AcceptanceOperationValue>;
+export declare function digestVinculoClaimMultimodal(input: {
+    readonly claimId: string;
+    readonly runId: string;
+    readonly definitionDigest: Sha256;
+    readonly planDigest: Sha256;
+    readonly contractDigest: Sha256;
+    readonly artifactDigest: Sha256;
+    readonly sceneId: string;
+    readonly timeRange: AcceptanceTimeRange;
+    readonly requiredModalities: readonly MultimodalChannelType[];
+}): Sha256;
+export declare function validarEvidenciaMultimodal(input: unknown): OperationResult<{
+    readonly descriptor: MultimodalEvidenceDescriptorV1;
+    readonly descriptorDigest: Sha256;
+    readonly localDescriptorOnly: true;
+}>;