@semacode/cli 2.3.1 → 3.0.0

package/node_modules/@sema/gerador-php/dist/index.js

@@ -120,43 +120,43 @@ function coletarTiposExternos(modulo) {
 function gerarClasseDados(nome, campos) {
     const classe = paraPascalCase(nome);
     if (campos.length === 0) {
-        return `final class ${classe}
-{
-    public function __construct()
-    {
-    }
-}
+        return `final class ${classe}
+{
+    public function __construct()
+    {
+    }
+}
 `;
     }
     const parametros = ordenarCamposConstrutor(campos).map((campo) => {
         const tipo = tipoParametroPhp(campo);
         const padrao = campo.modificadores.includes("required") ? "" : ` = ${valorPadraoPhp(campo)}`;
-        return `        /** @var ${tipoDocPhp(campo)} */
+        return `        /** @var ${tipoDocPhp(campo)} */
         public ${tipo} $${campo.nome}${padrao}`;
     }).join(",\n");
-    return `final class ${classe}
-{
-    public function __construct(
-${parametros}
-    ) {
-    }
-}
+    return `final class ${classe}
+{
+    public function __construct(
+${parametros}
+    ) {
+    }
+}
 `;
 }
 function gerarEnum(enumeracao) {
     const constantes = enumeracao.valores.map((valor) => `    public const ${paraConstantePhp(valor)} = ${literalPhp(valor)};`).join("\n");
-    return `final class ${paraPascalCase(enumeracao.nome)}
-{
-${constantes || "    public const VAZIO = \"\";"}
-}
+    return `final class ${paraPascalCase(enumeracao.nome)}
+{
+${constantes || "    public const VAZIO = \"\";"}
+}
 `;
 }
 function gerarLiteralCamposPhp(campos) {
     if (campos.length === 0) {
         return "[]";
     }
-    return `[
-${campos.map((campo) => `        ["nome" => ${literalPhp(campo.nome)}, "tipo" => ${literalPhp(campo.tipo)}, "obrigatorio" => ${campo.modificadores.includes("required") ? "true" : "false"}],`).join("\n")}
+    return `[
+${campos.map((campo) => `        ["nome" => ${literalPhp(campo.nome)}, "tipo" => ${literalPhp(campo.tipo)}, "obrigatorio" => ${campo.modificadores.includes("required") ? "true" : "false"}],`).join("\n")}
     ]`;
 }
 function gerarArrayStringsPhp(valores) {
@@ -170,8 +170,8 @@ function gerarMapaErrosPhp(erros) {
     if (entradas.length === 0) {
         return "[]";
     }
-    return `[
-${entradas.map(([codigo, mensagem]) => `        ${literalPhp(codigo)} => ${literalPhp(mensagem)},`).join("\n")}
+    return `[
+${entradas.map(([codigo, mensagem]) => `        ${literalPhp(codigo)} => ${literalPhp(mensagem)},`).join("\n")}
     ]`;
 }
 function resolverReferenciaPhp(referencia, variavel) {
@@ -248,15 +248,15 @@ function gerarValidacoes(task) {
     const linhas = [
         ...task.input
             .filter((campo) => campo.modificadores.includes("required"))
-            .map((campo) => `    if ($entrada->${campo.nome} === null) {
-        throw new \\InvalidArgumentException(${literalPhp(`Campo obrigatorio ausente: ${campo.nome}`)});
+            .map((campo) => `    if ($entrada->${campo.nome} === null) {
+        throw new \\InvalidArgumentException(${literalPhp(`Campo obrigatorio ausente: ${campo.nome}`)});
     }`),
         ...task.regrasEstruturadas.map((regra) => {
             if (regra.tipo === "predicado") {
                 return `    // Predicado declarado em Sema: ${regra.textoOriginal}`;
             }
-            return `    if (!(${resolverExpressaoPhp(regra, camposEntrada, "entrada")})) {
-        throw new \\InvalidArgumentException(${literalPhp(`Regra violada: ${regra.textoOriginal}`)});
+            return `    if (!(${resolverExpressaoPhp(regra, camposEntrada, "entrada")})) {
+        throw new \\InvalidArgumentException(${literalPhp(`Regra violada: ${regra.textoOriginal}`)});
     }`;
         }),
         ...task.rules
@@ -276,8 +276,8 @@ function gerarGarantias(task) {
             if (!garantiaComparacaoExecutavel(garantia, camposSaidaMap)) {
                 return `    // Garantia condicional declarada em Sema: ${garantia.textoOriginal}`;
             }
-            return `    if (!(${resolverExpressaoPhp(garantia, camposSaida, "saida")})) {
-        throw new \\RuntimeException(${literalPhp(`Garantia violada: ${garantia.textoOriginal}`)});
+            return `    if (!(${resolverExpressaoPhp(garantia, camposSaida, "saida")})) {
+        throw new \\RuntimeException(${literalPhp(`Garantia violada: ${garantia.textoOriginal}`)});
     }`;
         }),
         ...task.guarantees
@@ -300,33 +300,33 @@ function classeErroTask(task, codigo) {
     return `${paraPascalCase(task.nome)}${paraPascalCase(codigo)}Erro`;
 }
 function gerarClassesErro(task) {
-    return [...coletarErrosTask(task).entries()].map(([codigo, mensagem]) => `final class ${classeErroTask(task, codigo)} extends \\RuntimeException
-{
-    public string $codigo = ${literalPhp(codigo)};
-
-    public function __construct()
-    {
-        parent::__construct(${literalPhp(mensagem)});
-    }
-}
+    return [...coletarErrosTask(task).entries()].map(([codigo, mensagem]) => `final class ${classeErroTask(task, codigo)} extends \\RuntimeException
+{
+    public string $codigo = ${literalPhp(codigo)};
+
+    public function __construct()
+    {
+        parent::__construct(${literalPhp(mensagem)});
+    }
+}
 `).join("\n");
 }
 function gerarMetadadosTask(task) {
     const nome = normalizarNomeParaSimbolo(task.nome);
     const efeitos = task.efeitosEstruturados.map((efeito) => `${efeito.categoria}:${efeito.alvo}${efeito.detalhe ? `:${efeito.detalhe}` : ""}`);
     const impl = task.implementacoesExternas.map((item) => `${item.origem}:${item.caminho}[${item.statusImpl ?? "nao_verificado"}]`);
-    return `function contrato_${nome}(): array
-{
-    return [
-        "nome" => ${literalPhp(task.nome)},
-        "input" => ${gerarLiteralCamposPhp(task.input)},
-        "output" => ${gerarLiteralCamposPhp(task.output)},
-        "effects" => ${gerarArrayStringsPhp(efeitos)},
-        "impl" => ${gerarArrayStringsPhp(impl)},
-        "errors" => ${gerarMapaErrosPhp(Object.fromEntries(coletarErrosTask(task)))},
-        "guarantees" => ${gerarArrayStringsPhp(task.guarantees)},
-    ];
-}
+    return `function contrato_${nome}(): array
+{
+    return [
+        "nome" => ${literalPhp(task.nome)},
+        "input" => ${gerarLiteralCamposPhp(task.input)},
+        "output" => ${gerarLiteralCamposPhp(task.output)},
+        "effects" => ${gerarArrayStringsPhp(efeitos)},
+        "impl" => ${gerarArrayStringsPhp(impl)},
+        "errors" => ${gerarMapaErrosPhp(Object.fromEntries(coletarErrosTask(task)))},
+        "guarantees" => ${gerarArrayStringsPhp(task.guarantees)},
+    ];
+}
 `;
 }
 function gerarPreparacaoSaida(task) {
@@ -348,37 +348,37 @@ function gerarPreparacaoSaida(task) {
 function gerarTask(task) {
     const nome = normalizarNomeParaSimbolo(task.nome);
     const erros = [...coletarErrosTask(task).keys()];
-    const blocosErroContexto = erros.map((codigo) => `    if (($contexto["erro_esperado"] ?? null) === ${literalPhp(codigo)}) {
-        throw new ${classeErroTask(task, codigo)}();
+    const blocosErroContexto = erros.map((codigo) => `    if (($contexto["erro_esperado"] ?? null) === ${literalPhp(codigo)}) {
+        throw new ${classeErroTask(task, codigo)}();
     }`).join("\n");
     const efeitos = task.efeitosEstruturados.length > 0
         ? task.efeitosEstruturados.map((efeito) => `    // Efeito estruturado: categoria=${efeito.categoria} alvo=${efeito.alvo}${efeito.detalhe ? ` detalhe=${efeito.detalhe}` : ""}${efeito.criticidade ? ` criticidade=${efeito.criticidade}` : ""}`).join("\n")
         : task.effects.map((efeito) => `    // Efeito declarado: ${efeito}`).join("\n") || "    // Nenhum efeito declarado.";
-    return `
-${gerarClasseDados(`${task.nome}_entrada`, task.input)}
-${gerarClasseDados(`${task.nome}_saida`, task.output)}
-${gerarClassesErro(task)}
-${gerarMetadadosTask(task)}
-
-function validar_${nome}(${paraPascalCase(`${task.nome}_entrada`)} $entrada): void
-{
-${gerarValidacoes(task)}
-}
-
-function verificar_garantias_${nome}(${paraPascalCase(`${task.nome}_saida`)} $saida): void
-{
-${gerarGarantias(task)}
-}
-
-function executar_${nome}(${paraPascalCase(`${task.nome}_entrada`)} $entrada, array $contexto = []): ${paraPascalCase(`${task.nome}_saida`)}
-{
-${blocosErroContexto ? `${blocosErroContexto}\n` : ""}    validar_${nome}($entrada);
-${task.stateContract ? `    // Vinculo de estado: ${task.stateContract.nomeEstado ?? "nao_definido"}\n    // Transicoes declaradas: ${task.stateContract.transicoes.map((transicao) => `${transicao.origem}->${transicao.destino}`).join(", ") || "nenhuma"}\n` : ""}${task.implementacoesExternas.map((impl) => `    // Implementacao externa: origem=${impl.origem} caminho=${impl.caminho} status=${impl.statusImpl ?? "nao_verificado"}`).join("\n")}
-${efeitos}
-${gerarPreparacaoSaida(task)}
-    verificar_garantias_${nome}($saida);
-    return $saida;
-}
+    return `
+${gerarClasseDados(`${task.nome}_entrada`, task.input)}
+${gerarClasseDados(`${task.nome}_saida`, task.output)}
+${gerarClassesErro(task)}
+${gerarMetadadosTask(task)}
+
+function validar_${nome}(${paraPascalCase(`${task.nome}_entrada`)} $entrada): void
+{
+${gerarValidacoes(task)}
+}
+
+function verificar_garantias_${nome}(${paraPascalCase(`${task.nome}_saida`)} $saida): void
+{
+${gerarGarantias(task)}
+}
+
+function executar_${nome}(${paraPascalCase(`${task.nome}_entrada`)} $entrada, array $contexto = []): ${paraPascalCase(`${task.nome}_saida`)}
+{
+${blocosErroContexto ? `${blocosErroContexto}\n` : ""}    validar_${nome}($entrada);
+${task.stateContract ? `    // Vinculo de estado: ${task.stateContract.nomeEstado ?? "nao_definido"}\n    // Transicoes declaradas: ${task.stateContract.transicoes.map((transicao) => `${transicao.origem}->${transicao.destino}`).join(", ") || "nenhuma"}\n` : ""}${task.implementacoesExternas.map((impl) => `    // Implementacao externa: origem=${impl.origem} caminho=${impl.caminho} status=${impl.statusImpl ?? "nao_verificado"}`).join("\n")}
+${efeitos}
+${gerarPreparacaoSaida(task)}
+    verificar_garantias_${nome}($saida);
+    return $saida;
+}
 `;
 }
 function formatarLiteralTestePhp(valor, tipoDeclarado) {
@@ -453,45 +453,45 @@ function gerarTestesPhp(modulo, arquivoModulo) {
         const entrada = gerarInstanciaEntradaTeste(task, caso.given);
         const tipoErro = caso.error?.campos.find((campo) => campo.nome === "tipo")?.tipo ?? caso.error?.campos[0]?.tipo;
         if (tipoErro) {
-            return `function ${nomeTeste}(): void
-{
-    try {
-        executar_${normalizarNomeParaSimbolo(task.nome)}(${entrada}, ["erro_esperado" => ${literalPhp(tipoErro)}]);
-    } catch (${classeErroTask(task, tipoErro)} $erro) {
-        assert_sema($erro->codigo === ${literalPhp(tipoErro)}, "codigo de erro inesperado");
-        return;
-    }
-    throw new \\RuntimeException(${literalPhp(`Caso ${caso.nome} deveria falhar com ${tipoErro}`)});
+            return `function ${nomeTeste}(): void
+{
+    try {
+        executar_${normalizarNomeParaSimbolo(task.nome)}(${entrada}, ["erro_esperado" => ${literalPhp(tipoErro)}]);
+    } catch (${classeErroTask(task, tipoErro)} $erro) {
+        assert_sema($erro->codigo === ${literalPhp(tipoErro)}, "codigo de erro inesperado");
+        return;
+    }
+    throw new \\RuntimeException(${literalPhp(`Caso ${caso.nome} deveria falhar com ${tipoErro}`)});
 }`;
         }
-        return `function ${nomeTeste}(): void
-{
-    $resultado = executar_${normalizarNomeParaSimbolo(task.nome)}(${entrada});
-    assert_sema($resultado !== null, ${literalPhp(`Caso ${caso.nome} nao retornou resultado`)});
+        return `function ${nomeTeste}(): void
+{
+    $resultado = executar_${normalizarNomeParaSimbolo(task.nome)}(${entrada});
+    assert_sema($resultado !== null, ${literalPhp(`Caso ${caso.nome} nao retornou resultado`)});
 }`;
     });
     const lista = testes.map(({ task, caso, indice }) => `    [${literalPhp(caso.nome)}, "test_${normalizarNomeParaSimbolo(task.nome)}_${indice + 1}"],`).join("\n");
-    return `${gerarCabecalhoSemaPhp(modulo, "teste")}require_once __DIR__ . "/${path.posix.basename(arquivoModulo)}";
-
-function assert_sema(bool $condicao, string $mensagem): void
-{
-    if (!$condicao) {
-        throw new \\RuntimeException($mensagem);
-    }
-}
-
-${funcoes.join("\n\n")}
-
-$testes = [
-${lista}
-];
-
-foreach ($testes as [$nome, $funcao]) {
-    fwrite(STDOUT, "test " . $nome . PHP_EOL);
-    $funcao();
-}
-
-fwrite(STDOUT, "ok " . count($testes) . " testes" . PHP_EOL);
+    return `${gerarCabecalhoSemaPhp(modulo, "teste")}require_once __DIR__ . "/${path.posix.basename(arquivoModulo)}";
+
+function assert_sema(bool $condicao, string $mensagem): void
+{
+    if (!$condicao) {
+        throw new \\RuntimeException($mensagem);
+    }
+}
+
+${funcoes.join("\n\n")}
+
+$testes = [
+${lista}
+];
+
+foreach ($testes as [$nome, $funcao]) {
+    fwrite(STDOUT, "test " . $nome . PHP_EOL);
+    $funcao();
+}
+
+fwrite(STDOUT, "ok " . count($testes) . " testes" . PHP_EOL);
 `;
 }
 function gerarCabecalhoSemaPhp(modulo, tipo = "contrato") {
@@ -516,9 +516,9 @@ export function gerarPhp(modulo) {
     const nomeBase = normalizarNomeModulo(modulo.nome).replace(/\./g, "_");
     const estrutura = descreverEstruturaModulo(modulo.nome);
     const interops = modulo.interoperabilidades.map((interop) => `// Interop externo ${interop.origem}: ${interop.caminho}`).join("\n");
-    const tiposExternos = coletarTiposExternos(modulo).map((tipo) => `final class ${paraPascalCase(tipo)}
-{
-}
+    const tiposExternos = coletarTiposExternos(modulo).map((tipo) => `final class ${paraPascalCase(tipo)}
+{
+}
 `).join("\n");
     const tipos = modulo.types.map((tipo) => gerarClasseDados(tipo.nome, tipo.definicao.campos)).join("\n");
     const entidades = modulo.entities.map((entity) => gerarClasseDados(entity.nome, entity.campos)).join("\n");

package/node_modules/@sema/nucleo/dist/semantico/analisador.d.ts

@@ -1,3 +1,4 @@
 export { SimboloSemantico, CampoSemantico, ErroSemanticoTask, ResumoTaskSemantico, InteropSemantico, ImplementacaoTaskSemantica, ContextoSemantico, ResultadoSemantico, OpcoesAnaliseSemantica } from "./analisador.part01.js";
 export { criarContextoLocal, validarTesteSemanticoForte, emitirDiagnosticosContratoFrouxo } from "./analisador.part07.js";
+export { listarCandidatosUseRelativo } from "./analisador.part04.js";
 export { analisarSemantica } from "./analisador.part08.js";

package/node_modules/@sema/nucleo/dist/semantico/analisador.js

@@ -1,3 +1,4 @@
 export { criarContextoLocal, validarTesteSemanticoForte, emitirDiagnosticosContratoFrouxo } from "./analisador.part07.js";
+export { listarCandidatosUseRelativo } from "./analisador.part04.js";
 export { analisarSemantica } from "./analisador.part08.js";
 //# sourceMappingURL=analisador.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semacode/cli",
-  "version": "2.3.1",
+  "version": "3.0.0",
   "description": "Codex-native local semantic governance CLI for contracts, drift, impact, documentation gates, and code generation.",
   "type": "module",
   "icon": "logo.png",
@@ -34,7 +34,7 @@
     "access": "public"
   },
   "bin": {
-    "sema": "dist/index.js"
+    "sema": "dist/bin.js"
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -45,10 +45,15 @@
       "default": "./dist/index.js"
     }
   },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.mjs"
+  },
   "files": [
     "dist",
     "docs",
     "exemplos",
+    "skills",
+    "scripts/postinstall.mjs",
     "logo.png",
     "README.md",
     "LICENSE"
@@ -63,8 +68,8 @@
     "@sema/gerador-html": "1.5.53",
     "@sema/gerador-css": "1.5.53",
     "@sema/gerador-php": "1.5.55",
-    "@sema/gerador-dotnet": "2.3.1",
-    "@sema/gerador-cpp": "2.3.1",
+    "@sema/gerador-dotnet": "2.1.0",
+    "@sema/gerador-cpp": "2.1.0",
     "@sema/padroes": "1.5.53",
     "typescript": "^5.8.3"
   },

package/scripts/postinstall.mjs

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+// SEMA-GOVERNED: sema.produto.fronteira_repositorios.empacotamento, sema.produto.fronteira_repositorios.empacotamento.postinstall
+// Consulte contratos/sema/fronteira_repositorios_empacotamento_postinstall.sema antes de editar.
+// Descricao: sincroniza launcher e skill globais somente no lifecycle npm --global.
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const raizPacotePadrao = path.resolve(fileURLToPath(new URL("../", import.meta.url)));
+const moduloDistribuicao = new URL("../dist/distribuicao/index.js", import.meta.url);
+const ERROS_PUBLICOS = {
+  FALHA_CARREGAR_DISTRIBUICAO: "não foi possível carregar a distribuição global Sema",
+  API_DISTRIBUICAO_INVALIDA: "a API compilada de distribuição global Sema é inválida",
+  DIRETORIO_USUARIO_INVALIDO: "o diretório de usuário da distribuição global Sema é inválido",
+  RAIZ_PACOTE_INVALIDA: "a raiz do pacote da distribuição global Sema é inválida",
+  FALHA_SINCRONIZAR_DISTRIBUICAO: "não foi possível sincronizar a distribuição global Sema",
+  DISTRIBUICAO_NAO_PRONTA: "a distribuição global Sema não atingiu o estado READY",
+};
+
+function erroPublico(codigo) {
+  return new Error(`${codigo}: ${ERROS_PUBLICOS[codigo]}.`);
+}
+
+export function mensagemErroPostinstallPublica(erro) {
+  const mensagem = erro instanceof Error ? erro.message : "";
+  return Object.keys(ERROS_PUBLICOS).some((codigo) => mensagem.startsWith(`${codigo}:`))
+    ? mensagem
+    : "FALHA_POSTINSTALL_GLOBAL: a distribuição global Sema não foi concluída.";
+}
+
+export function instalacaoGlobalSolicitada(ambiente = process.env) {
+  const valor = ambiente.npm_config_global ?? ambiente.NPM_CONFIG_GLOBAL;
+  return /^(?:1|true)$/iu.test(String(valor ?? "").trim());
+}
+
+function caminhoAbsolutoOuErro(valor) {
+  const candidato = valor?.trim();
+  if (!candidato) return undefined;
+  if (!path.isAbsolute(candidato)) {
+    throw erroPublico("DIRETORIO_USUARIO_INVALIDO");
+  }
+  return path.resolve(candidato);
+}
+
+export function resolverDiretorioUsuario(ambiente, plataforma) {
+  if (plataforma === "win32") {
+    const perfil = caminhoAbsolutoOuErro(ambiente.USERPROFILE);
+    if (perfil) {
+      return perfil;
+    }
+    const unidade = ambiente.HOMEDRIVE?.trim();
+    const caminho = ambiente.HOMEPATH?.trim();
+    if (unidade && caminho) {
+      return caminhoAbsolutoOuErro(`${unidade}${caminho}`);
+    }
+  } else {
+    const diretorio = caminhoAbsolutoOuErro(ambiente.HOME);
+    if (diretorio) {
+      return diretorio;
+    }
+  }
+  const fallback = caminhoAbsolutoOuErro(os.homedir());
+  if (!fallback) throw erroPublico("DIRETORIO_USUARIO_INVALIDO");
+  return fallback;
+}
+
+function resolverRaizPacote(valor) {
+  if (typeof valor !== "string" || !valor.trim() || !path.isAbsolute(valor)) {
+    throw erroPublico("RAIZ_PACOTE_INVALIDA");
+  }
+  return path.resolve(valor);
+}
+
+export async function executarPostinstall({
+  ambiente = process.env,
+  plataforma = process.platform,
+  executavelNode = process.execPath,
+  raizPacote = raizPacotePadrao,
+  importar = (referencia) => import(referencia),
+} = {}) {
+  if (!instalacaoGlobalSolicitada(ambiente)) {
+    return {
+      estado: "no_op",
+      motivo: "install_scope_local",
+      instalacao_local_no_op: true,
+      distribuicao_pronta: false,
+      alterado: false,
+    };
+  }
+
+  const diretorioUsuario = resolverDiretorioUsuario(ambiente, plataforma);
+  const raizPacoteAbsoluta = resolverRaizPacote(raizPacote);
+
+  let api;
+  try {
+    api = await importar(moduloDistribuicao.href);
+  } catch {
+    throw erroPublico("FALHA_CARREGAR_DISTRIBUICAO");
+  }
+  if (typeof api.sincronizarDistribuicaoGlobal !== "function") {
+    throw erroPublico("API_DISTRIBUICAO_INVALIDA");
+  }
+
+  let resultado;
+  try {
+    resultado = await api.sincronizarDistribuicaoGlobal({
+      plataforma,
+      diretorioUsuario,
+      executavelNode,
+      raizPacote: raizPacoteAbsoluta,
+    });
+  } catch {
+    throw erroPublico("FALHA_SINCRONIZAR_DISTRIBUICAO");
+  }
+  if (
+    resultado?.estado !== "READY" ||
+    resultado.launcher?.estado !== "READY" ||
+    resultado.skill?.estado !== "READY" ||
+    typeof resultado.alterado !== "boolean"
+  ) {
+    throw erroPublico("DISTRIBUICAO_NAO_PRONTA");
+  }
+  return {
+    estado: "READY",
+    motivo: "distribution_ready",
+    instalacao_local_no_op: false,
+    distribuicao_pronta: true,
+    alterado: resultado.alterado,
+  };
+}
+
+function executadoDiretamente() {
+  return Boolean(process.argv[1]) && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+}
+
+if (executadoDiretamente()) {
+  executarPostinstall()
+    .then((resultado) => {
+      if (resultado?.estado !== "no_op") {
+        console.log("Sema global launcher and AI skill synchronized.");
+      }
+    })
+    .catch((erro) => {
+      console.error("Failed to synchronize the global Sema distribution.");
+      console.error(mensagemErroPostinstallPublica(erro));
+      process.exitCode = 1;
+    });
+}