@semacode/cli 2.3.0 → 3.0.0

package/dist/bin.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+// SEMA-GOVERNED: sema.produto.cli_invocacao_publica, sema.produto.cli_invocacao_publica.resultados, sema.produto.cli_invocacao_publica.handlers, sema.produto.distribuicao_global
+// Descrição: bootstrap executável puro; ajuda e versão encerram antes do runtime operacional.
+import pacoteCli from "../package.json" with { type: "json" };
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { ehCliControlError } from "./cliControlError.js";
+import { validarSintaxeInvocacaoPublica } from "./cliGrammar.js";
+import { detectarHelpAntesDispatch } from "./cliHelp.js";
+import { criarAjudaRaiz } from "./cliHelpTexto.js";
+import { criarAjudaPipelineConteudo } from "./pipelineConteudo/help.js";
+import { CODIGO_SAIDA_FATAL_RUNTIME_CLI, criarEnvelopeControleJsonV1, emitirResultadoCliJsonV1, executarInvocacaoPublica, } from "./saidaCli.js";
+const FLAGS_VERSAO = new Set(["--versao", "--version", "-v"]);
+const CAMINHO_RUNTIME_CLI = fileURLToPath(new URL("./cliRuntime.js", import.meta.url));
+const LIMITE_BUFFER_RUNTIME_JSON = 16 * 1024 * 1024;
+function executarRuntimeJsonCapturado(argv) {
+    const execucao = spawnSync(process.execPath, [CAMINHO_RUNTIME_CLI, ...argv], {
+        cwd: process.cwd(),
+        env: process.env,
+        encoding: "utf8",
+        maxBuffer: LIMITE_BUFFER_RUNTIME_JSON,
+        shell: false,
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+    });
+    if (execucao.error
+        || execucao.signal !== null
+        || execucao.status === null
+        || execucao.status === CODIGO_SAIDA_FATAL_RUNTIME_CLI) {
+        return null;
+    }
+    return {
+        codigoSaida: execucao.status,
+        stdout: execucao.stdout ?? "",
+    };
+}
+function mensagemAjudaPublica(argv) {
+    if (argv[0] === "conteudo") {
+        const ajudaConteudo = criarAjudaPipelineConteudo();
+        if (typeof ajudaConteudo.mensagem === "string") {
+            return ajudaConteudo.mensagem;
+        }
+    }
+    return criarAjudaRaiz(pacoteCli.version);
+}
+function emitirAjuda(argv, modoJson) {
+    const mensagemTexto = mensagemAjudaPublica(argv);
+    const relatorio = executarInvocacaoPublica({
+        resultado: "HELP",
+        modoJson,
+        mensagemTexto,
+        envelopeControle: modoJson
+            ? criarEnvelopeControleJsonV1({
+                categoria: "HELP",
+                codigoPublico: "CLI_HELP",
+                mensagemPublica: argv[0] === "conteudo" ? mensagemTexto : "Sema CLI help",
+                codigoSaida: 0,
+            })
+            : undefined,
+    });
+    return relatorio.codigoSaida;
+}
+function emitirFalhaControle(argv, categoria, codigoPublico, mensagemPublica, codigoSaida) {
+    const modoJson = argv.includes("--json");
+    const relatorio = executarInvocacaoPublica({
+        resultado: categoria,
+        modoJson,
+        mensagemTexto: mensagemPublica,
+        envelopeControle: modoJson
+            ? criarEnvelopeControleJsonV1({
+                categoria,
+                codigoPublico,
+                mensagemPublica,
+                codigoSaida,
+            })
+            : undefined,
+    });
+    if (!modoJson && categoria === "UNKNOWN_COMMAND") {
+        console.log(criarAjudaRaiz(pacoteCli.version));
+    }
+    return relatorio.codigoSaida;
+}
+/**
+ * Única entrada executável pública. O import do runtime ocorre somente depois
+ * de ajuda, argv vazio e versão encerrarem sem resolver handlers.
+ */
+export async function executarCliPublica(argv = process.argv.slice(2)) {
+    if (argv.length === 0) {
+        return emitirAjuda(argv, false);
+    }
+    const deteccaoHelp = detectarHelpAntesDispatch(argv);
+    if (deteccaoHelp.ajudaSolicitada) {
+        return emitirAjuda(argv, deteccaoHelp.modoJson);
+    }
+    if (FLAGS_VERSAO.has(argv[0])) {
+        console.log(pacoteCli.version);
+        return 0;
+    }
+    try {
+        const sintaxe = validarSintaxeInvocacaoPublica(argv);
+        if (!sintaxe.dispatchPermitido)
+            return 0;
+        if (argv.includes("--json")) {
+            const execucao = executarRuntimeJsonCapturado(argv);
+            if (!execucao) {
+                return emitirFalhaControle(argv, "FATAL_ERROR", "CLI_FATAL_ERROR", "Falha ao executar a CLI da Sema.", 1);
+            }
+            return emitirResultadoCliJsonV1({
+                comando: sintaxe.comando,
+                codigoSaida: execucao.codigoSaida,
+                stdout: execucao.stdout,
+            }).exitCode;
+        }
+        const { principal } = await import("./index.part08.js");
+        return await principal();
+    }
+    catch (erro) {
+        if (ehCliControlError(erro)) {
+            return emitirFalhaControle(argv, erro.categoria, erro.codigoPublico, erro.mensagemPublica, erro.codigoSaida);
+        }
+        return emitirFalhaControle(argv, "FATAL_ERROR", "CLI_FATAL_ERROR", "Falha ao executar a CLI da Sema.", 1);
+    }
+}
+void executarCliPublica().then((codigoSaida) => {
+    process.exitCode = codigoSaida;
+}, () => {
+    console.error("Falha ao executar a CLI da Sema.");
+    process.exitCode = 1;
+});
+//# sourceMappingURL=bin.js.map

package/dist/cliArgs.js

@@ -1,7 +1,5 @@
-// SEMA-GOVERNED
-// M?dulo: sema.produto.orcamento_semantico
-// Contrato: contratos/sema/orcamento_semantico.sema
-// Descri??o: parse comum de argumentos e flags da CLI.
+// SEMA-GOVERNED: sema.produto.orcamento_semantico, sema.produto.governanca_ia.drift.cache.modos
+// Descrição: classifica flags públicas da CLI sem perder os modos explícitos de drift.
 export function obterOpcao(args, nome, padrao) {
     const nomes = [nome, ...Object.entries(ALIAS_OPCOES).filter(([, v]) => v === nome).map(([k]) => k)];
     for (const n of nomes) {
@@ -28,6 +26,8 @@ export const OPCOES_COM_VALOR = new Set([
     "--template",
     "--alvo", "-a",
     "--escopo",
+    "--cache",
+    "--drift",
     "--saida", "-s",
     "--estrutura",
     "--framework",

package/dist/cliControlError.d.ts

@@ -0,0 +1,12 @@
+export type CategoriaFalhaControleCli = "UNKNOWN_COMMAND" | "ARGUMENT_ERROR" | "FATAL_ERROR";
+export declare class CliControlError extends Error {
+    readonly categoria: CategoriaFalhaControleCli;
+    readonly codigoPublico: string;
+    readonly mensagemPublica: string;
+    readonly codigoSaida: number;
+    constructor(categoria: CategoriaFalhaControleCli);
+}
+export declare function erroComandoDesconhecido(): CliControlError;
+export declare function erroArgumentoInvalido(): CliControlError;
+export declare function erroFatalCli(): CliControlError;
+export declare function ehCliControlError(valor: unknown): valor is CliControlError;

package/dist/cliControlError.js

@@ -0,0 +1,47 @@
+// SEMA-GOVERNED: sema.produto.cli_invocacao_publica.argumentos
+// Descrição: representa falhas públicas de controle sem carregar argv, stack ou caminhos na mensagem.
+const DEFINICOES_FALHA_CONTROLE = Object.freeze({
+    UNKNOWN_COMMAND: Object.freeze({
+        codigoPublico: "CLI_UNKNOWN_COMMAND",
+        mensagemPublica: "Comando Sema desconhecido.",
+        codigoSaida: 1,
+    }),
+    ARGUMENT_ERROR: Object.freeze({
+        codigoPublico: "CLI_ARGUMENT_ERROR",
+        mensagemPublica: "Argumentos inválidos. Consulte a ajuda do comando.",
+        codigoSaida: 1,
+    }),
+    FATAL_ERROR: Object.freeze({
+        codigoPublico: "CLI_FATAL_ERROR",
+        mensagemPublica: "Falha ao executar a CLI da Sema.",
+        codigoSaida: 1,
+    }),
+});
+export class CliControlError extends Error {
+    categoria;
+    codigoPublico;
+    mensagemPublica;
+    codigoSaida;
+    constructor(categoria) {
+        const definicao = DEFINICOES_FALHA_CONTROLE[categoria];
+        super(definicao.mensagemPublica);
+        this.name = "CliControlError";
+        this.categoria = categoria;
+        this.codigoPublico = definicao.codigoPublico;
+        this.mensagemPublica = definicao.mensagemPublica;
+        this.codigoSaida = definicao.codigoSaida;
+    }
+}
+export function erroComandoDesconhecido() {
+    return new CliControlError("UNKNOWN_COMMAND");
+}
+export function erroArgumentoInvalido() {
+    return new CliControlError("ARGUMENT_ERROR");
+}
+export function erroFatalCli() {
+    return new CliControlError("FATAL_ERROR");
+}
+export function ehCliControlError(valor) {
+    return valor instanceof CliControlError;
+}
+//# sourceMappingURL=cliControlError.js.map

package/dist/cliGrammar.d.ts

@@ -0,0 +1,11 @@
+import { type CategoriaFalhaControleCli } from "./cliControlError.js";
+export interface ResultadoSintaxeInvocacaoPublica {
+    readonly comando: string;
+    readonly sintaxeValida: true;
+    readonly dispatchPermitido: boolean;
+    readonly handlerResolvido: false;
+    readonly efeitosPermitidos: boolean;
+    readonly categoriaFalha: CategoriaFalhaControleCli | null;
+    readonly codigoPublico: string | null;
+}
+export declare function validarSintaxeInvocacaoPublica(argv: readonly string[]): ResultadoSintaxeInvocacaoPublica;