@semacode/cli 4.1.1 → 4.1.2

package/node_modules/@sema/gerador-typescript/dist/index.part01.d.ts

@@ -8,7 +8,7 @@ export declare function gerarComentarioInvariantesTypeScript(invariantes: Expres
 export declare function gerarLiteralCamposTypeScript(campos: IrCampo[]): string;
 export declare function coletarTiposExternos(modulo: IrModulo): string[];
 export declare function gerarLiteralErrosTypeScript(erros: Record<string, string>): string;
-export declare function formatarValorTypeScript(valor: string, camposConhecidos: Set<string>, variavel: string): string;
+export declare function formatarValorTypeScript(valor: string, camposConhecidos: Set<string>, variavel: string, literal?: boolean): string;
 export declare function resolverReferenciaTypeScript(referencia: string, variavel: string): string;
 export declare function gerarExpressaoTypeScript(expressao: ExpressaoSemantica, camposConhecidos: Set<string>, variavel: string): string;
 export declare function valorPadraoTypeScript(tipo: string, nomeCampo: string): string;
@@ -17,7 +17,7 @@ export declare function dividirLiteralNoNivelRaiz(valor: string, separador: ","
 export declare function resolverTipoItemTeste(tipoDeclarado?: string): string | undefined;
 export declare function formatarLiteralTesteTypeScript(valor: string, tipoDeclarado?: string): unknown;
 export declare function converterBlocoTesteParaValorTypeScript(bloco: IrBlocoDeclarativo, tiposDeclarados?: Map<string, string>): Record<string, unknown>;
-export declare function gerarPreparacaoSaida(task: IrTask): string;
+export declare function gerarPreparacaoSaida(task: IrTask, tiposDeclarados?: Map<string, Map<string, string>>): string;
 export declare function gerarValidacoes(task: IrTask): string;
 export declare function gerarGarantias(task: IrTask): string;
 export declare function gerarFuncaoGarantias(task: IrTask): string;

package/node_modules/@sema/gerador-typescript/dist/index.part01.js

@@ -48,7 +48,7 @@ export function gerarLiteralErrosTypeScript(erros) {
     }
     return `{\n${entradas.map(([nome, mensagem]) => `  ${JSON.stringify(nome)}: ${JSON.stringify(mensagem)},`).join("\n")}\n}`;
 }
-export function formatarValorTypeScript(valor, camposConhecidos, variavel) {
+export function formatarValorTypeScript(valor, camposConhecidos, variavel, literal = false) {
     const texto = valor.trim();
     if (/^-?\d+(?:\.\d+)?$/.test(texto)) {
         return texto;
@@ -62,7 +62,7 @@ export function formatarValorTypeScript(valor, camposConhecidos, variavel) {
     if (texto === "nulo") {
         return "null";
     }
-    if (camposConhecidos.has(texto.split(".")[0] ?? texto)) {
+    if (!literal && camposConhecidos.has(texto.split(".")[0] ?? texto)) {
         return `${variavel}.${texto}`;
     }
     return JSON.stringify(texto);
@@ -260,29 +260,131 @@ export function converterBlocoTesteParaValorTypeScript(bloco, tiposDeclarados) {
     }
     return literal;
 }
-export function gerarPreparacaoSaida(task) {
+function achatarGarantiasConjuntivasTypeScript(expressao) {
+    return expressao.tipo === "composta" && expressao.operadorLogico === "e"
+        ? expressao.termos.flatMap(achatarGarantiasConjuntivasTypeScript)
+        : [expressao];
+}
+function sugerirValoresTypeScript(tipo, tiposDeclarados) {
+    if (["Numero", "Inteiro", "Decimal"].includes(tipo))
+        return "[1, 0, -1]";
+    if (tipo === "Booleano")
+        return "[false, true]";
+    if (["Texto", "Id", "Email", "Url", "Data", "DataHora", "Timestamp"].includes(tipo)) {
+        return '["valor_garantido", "outro_valor"]';
+    }
+    if (/^Lista</u.test(tipo) || /\[\]$/u.test(tipo))
+        return "[[]]";
+    if (/^Mapa</u.test(tipo) || ["Json", "Objeto"].includes(tipo) || tiposDeclarados.has(tipo))
+        return "[{}]";
+    return "[1, 0, -1, true, false, \"valor_garantido\", \"outro_valor\", {}]";
+}
+export function gerarPreparacaoSaida(task, tiposDeclarados = new Map()) {
     const camposSaida = new Set(task.output.map((campo) => campo.nome));
     const linhas = [];
     for (const campo of task.output) {
         linhas.push(`    ${campo.nome}: ${valorPadraoTypeScript(campo.tipo, campo.nome)},`);
     }
-    const ajustes = [];
-    for (const garantia of task.garantiasEstruturadas) {
-        if (garantia.tipo === "pertencimento" && garantia.valores && camposSaida.has(garantia.alvo)) {
-            ajustes.push(`  saida.${garantia.alvo} = ${formatarValorTypeScript(garantia.valores[0] ?? "", camposSaida, "saida")} as any;`);
-        }
-        if (garantia.tipo === "comparacao" && garantia.valor && camposSaida.has(garantia.alvo.split(".")[0] ?? garantia.alvo)) {
-            ajustes.push(`  ${resolverReferenciaTypeScript(garantia.alvo, "saida")} = ${formatarValorTypeScript(garantia.valor, camposSaida, "saida")} as any;`);
+    const grupos = new Map();
+    for (const garantia of task.garantiasEstruturadas.flatMap(achatarGarantiasConjuntivasTypeScript)) {
+        if (!("alvo" in garantia) || !camposSaida.has(garantia.alvo.split(".")[0] ?? garantia.alvo))
+            continue;
+        if (garantia.tipo === "comparacao" || garantia.tipo === "pertencimento" || garantia.tipo === "existe") {
+            grupos.set(garantia.alvo, [...(grupos.get(garantia.alvo) ?? []), garantia]);
         }
-        if (garantia.tipo === "existe" && garantia.alvo.includes(".")) {
-            const [raiz, filho] = garantia.alvo.split(".", 2);
-            if (raiz && filho && camposSaida.has(raiz)) {
-                ajustes.push(`  saida.${raiz} = (saida.${raiz} ?? {}) as any;`);
-                ajustes.push(`  (saida.${raiz} as any).${filho} = (saida.${raiz} as any).${filho} ?? "valor_garantido";`);
+    }
+    const referencias = new Set();
+    for (const regras of grupos.values()) {
+        for (const regra of regras) {
+            if (regra.tipo === "comparacao" && !regra.valorLiteral && camposSaida.has(regra.valor.split(".")[0] ?? regra.valor)) {
+                referencias.add(regra.valor);
             }
         }
     }
-    return `  const saida = {\n${linhas.join("\n")}\n  } as ${task.nome}Saida;\n${ajustes.join("\n")}`;
+    for (const referencia of referencias) {
+        if (!grupos.has(referencia)) {
+            grupos.set(referencia, [{ tipo: "existe", alvo: referencia, textoOriginal: `${referencia} existe` }]);
+        }
+    }
+    const caminhos = [...grupos.keys()].sort((a, b) => Number(referencias.has(b)) - Number(referencias.has(a)) || a.split(".").length - b.split(".").length);
+    const ajustes = [];
+    for (const caminho of caminhos) {
+        const regras = grupos.get(caminho);
+        let tipo = task.output.find((campo) => campo.nome === caminho.split(".")[0])?.tipo ?? "Json";
+        for (const segmento of caminho.split(".").slice(1)) {
+            tipo = tiposDeclarados.get(tipo)?.get(segmento) ?? "Json";
+        }
+        const restricoes = regras.map((regra) => {
+            if (regra.tipo === "comparacao") {
+                return `[${JSON.stringify(regra.operador)}, ${formatarValorTypeScript(regra.valor, camposSaida, "saida", regra.valorLiteral)}]`;
+            }
+            if (regra.tipo === "pertencimento") {
+                const valores = (regra.valores ?? []).map((valor) => formatarValorTypeScript(valor, camposSaida, "saida", true));
+                return `["in", [${valores.join(", ")}]]`;
+            }
+            return '["existe", null]';
+        });
+        const caminhoLiteral = JSON.stringify(caminho.split("."));
+        const somenteExistencia = regras.every((regra) => regra.tipo === "existe");
+        const temDescendente = caminhos.some((outro) => outro.startsWith(`${caminho}.`));
+        if (somenteExistencia && temDescendente) {
+            ajustes.push(`  if (semaLerSaida(saida, ${caminhoLiteral}) == null) semaDefinirSaida(saida, ${caminhoLiteral}, {});`);
+            continue;
+        }
+        const inteiro = tipo === "Inteiro" ? "true" : "false";
+        ajustes.push(`  semaDefinirSaida(saida, ${caminhoLiteral}, semaSintetizarSaida(semaLerSaida(saida, ${caminhoLiteral}), [${restricoes.join(", ")}], ${inteiro}, ${sugerirValoresTypeScript(tipo, tiposDeclarados)}));`);
+    }
+    const helpers = grupos.size === 0 ? "" : `
+  const semaLerSaida = (objeto: any, caminho: string[]): any => caminho.reduce((atual, campo) => atual == null ? undefined : atual[campo], objeto);
+  const semaDefinirSaida = (objeto: any, caminho: string[], valor: any): void => {
+    let atual = objeto;
+    for (const campo of caminho.slice(0, -1)) {
+      if (atual[campo] === null || typeof atual[campo] !== "object") atual[campo] = {};
+      atual = atual[campo];
+    }
+    const ultimo = caminho[caminho.length - 1];
+    if (ultimo !== undefined) atual[ultimo] = valor;
+  };
+  const semaSintetizarSaida = (atual: any, restricoes: Array<[string, any]>, inteiro: boolean, sementes: any[]): any => {
+    const aceita = (valor: any): boolean => restricoes.every(([operador, limite]) => {
+      if (operador === "existe") return valor !== undefined && valor !== null;
+      if (operador === "in") return Array.isArray(limite) && limite.some((item: any) => Object.is(item, valor));
+      if (operador === "==") return valor === limite;
+      if (operador === "!=") return valor !== limite;
+      const esquerda: any = valor;
+      const direita: any = limite;
+      if (operador === ">") return esquerda > direita;
+      if (operador === ">=") return esquerda >= direita;
+      if (operador === "<") return esquerda < direita;
+      if (operador === "<=") return esquerda <= direita;
+      return false;
+    });
+    const candidatos: any[] = [atual, ...sementes];
+    const numeros: number[] = [];
+    for (const [operador, limite] of restricoes) {
+      if (operador === "in" && Array.isArray(limite)) candidatos.push(...limite);
+      else if (operador !== "existe") {
+        candidatos.push(limite);
+        if (typeof limite === "number" && Number.isFinite(limite)) {
+          numeros.push(limite);
+          candidatos.push(limite - 1, limite + 1, Math.floor(limite), Math.ceil(limite));
+        } else if (typeof limite === "string") {
+          candidatos.push(limite + "\\u0000", limite.slice(0, -1), "");
+        }
+      }
+    }
+    numeros.sort((a, b) => a - b);
+    for (let indice = 0; indice < numeros.length - 1; indice += 1) {
+      candidatos.push((numeros[indice]! + numeros[indice + 1]!) / 2);
+    }
+    for (const candidato of candidatos) {
+      if (inteiro && (typeof candidato !== "number" || !Number.isInteger(candidato))) continue;
+      if (aceita(candidato)) return candidato;
+    }
+    throw new Error("Nao foi possivel sintetizar uma saida demonstrativa compativel com as garantias.");
+  };
+`;
+    return `  const saida = {\n${linhas.join("\n")}\n  } as ${task.nome}Saida;${helpers}\n${ajustes.join("\n")}`;
 }
 export function gerarValidacoes(task) {
     const linhas = [];

package/node_modules/@sema/gerador-typescript/dist/index.part02.d.ts

@@ -1,7 +1,7 @@
 import type { IrModulo, IrTask } from "@sema/nucleo";
 import { type ArquivoGerado } from "@sema/padroes";
 export declare function gerarRotas(modulo: IrModulo): string;
-export declare function gerarTask(task: IrTask): string;
+export declare function gerarTask(task: IrTask, tiposDeclarados?: Map<string, Map<string, string>>): string;
 export declare function gerarTestes(modulo: IrModulo): string;
 export type TipoCabecalhoSemaTypeScript = "contrato" | "teste" | "dto" | "service" | "controller" | "spec";
 export declare function gerarCabecalhoSemaTypeScript(modulo: IrModulo, tipo?: TipoCabecalhoSemaTypeScript): string;

package/node_modules/@sema/gerador-typescript/dist/index.part02.js

@@ -68,7 +68,7 @@ ${verificacoesErro || "    throw erro;"}
 `;
     }).join("\n");
 }
-export function gerarTask(task) {
+export function gerarTask(task, tiposDeclarados = new Map()) {
     const nomeSimbolo = normalizarNomeParaSimbolo(task.nome);
     const entradaNome = `${nomeSimbolo}_entrada`;
     const saidaNome = `${nomeSimbolo}_saida`;
@@ -130,7 +130,7 @@ ${task.stateContract ? `  // Vinculo de estado: ${task.stateContract.nomeEstado
 ${task.implementacoesExternas.length > 0 ? `  // Implementacoes externas vinculadas:\n${task.implementacoesExternas.map((impl) => `  // - ${impl.origem}: ${impl.caminho} [${impl.statusImpl ?? "nao_verificado"}]`).join("\n")}` : ""}
   // Efeitos declarados:
 ${task.efeitosEstruturados.map((efeito) => `  // - categoria=${efeito.categoria} alvo=${efeito.alvo}${efeito.detalhe ? ` detalhe=${efeito.detalhe}` : ""}${efeito.criticidade ? ` criticidade=${efeito.criticidade}` : ""}`).join("\n") || task.effects.map((efeito) => `  // - ${efeito}`).join("\n") || "  // - Nenhum efeito declarado."}
-${gerarPreparacaoSaida(task)}
+${gerarPreparacaoSaida(task, tiposDeclarados)}
 ${gerarGarantias(task)}
 }
 
@@ -211,6 +211,13 @@ export function gerarCabecalhoSemaTypeScript(modulo, tipo = "contrato") {
 }
 export function gerarTypeScriptBase(modulo) {
     const nomeBase = normalizarNomeModulo(modulo.nome).replace(/\./g, "_");
+    const mapaTiposDeclarados = new Map();
+    for (const entidade of modulo.entities) {
+        mapaTiposDeclarados.set(entidade.nome, new Map(entidade.campos.map((campo) => [campo.nome, campo.tipo])));
+    }
+    for (const tipo of modulo.types) {
+        mapaTiposDeclarados.set(tipo.nome, new Map(tipo.definicao.campos.map((campo) => [campo.nome, campo.tipo])));
+    }
     const interoperabilidades = modulo.interoperabilidades
         .map((interop) => `// Interop externo ${interop.origem}: ${interop.caminho}`)
         .join("\n");
@@ -235,7 +242,7 @@ export function gerarTypeScriptBase(modulo) {
     const routes = modulo.routes
         .map((route) => `// Route ${route.nome}: metodo=${route.metodo ?? "nao_definido"} caminho=${route.caminho ?? "nao_definido"} task=${route.task ?? "nao_definida"} input_publico=${route.inputPublico.map((campo) => campo.nome).join(", ") || "padrao_task"} output_publico=${route.outputPublico.map((campo) => campo.nome).join(", ") || "padrao_task"} erros_publicos=${route.errosPublicos.map((erro) => erro.nome).join(", ") || "padrao_task"} effects_publicos=${route.efeitosPublicos.map((efeito) => `${efeito.categoria}:${efeito.alvo}`).join(", ") || "nenhum"} garantias_publicas=${route.garantiasPublicasMinimas.length}`)
         .join("\n");
-    const tasks = modulo.tasks.map(gerarTask).join("\n");
+    const tasks = modulo.tasks.map((task) => gerarTask(task, mapaTiposDeclarados)).join("\n");
     const contratosPublicos = gerarRotas(modulo);
     const codigo = `${gerarCabecalhoSemaTypeScript(modulo)}${interoperabilidades ? `${interoperabilidades}\n` : ""}\n${tiposExternos}\n${tipos}\n${entidades}\n${enums}\n${states}\n${flows}\n${routes}\n${tasks}\n${contratosPublicos}\n`;
     const testes = `${gerarCabecalhoSemaTypeScript(modulo, "teste")}${gerarTestes(modulo)}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semacode/cli",
-  "version": "4.1.1",
+  "version": "4.1.2",
   "description": "Local-first semantic governance CLI for AI agents, proven with Claude, Codex, zCode (GLM) and Kimi: contracts, drift, impact, docs gates, and code generation.",
   "type": "module",
   "icon": "logo.png",