@semacode/cli 2.2.0 → 2.3.1

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

@@ -278,15 +278,15 @@ function ordenarModelos(modulo) {
 }
 function gerarStruct(nome, campos, modulo, modo) {
     const linhas = campos.map((campo) => `    ${tipoCampoCpp(campo)} ${identificadorCpp(campo.nome)} = ${valorInicialCpp(campo, modulo, modo)};`);
-    return `struct ${paraPascalCase(nome)} final {
-${linhas.length > 0 ? linhas.join("\n") : "    // Estrutura intencionalmente vazia."}
-    bool operator==(const ${paraPascalCase(nome)}&) const = default;
+    return `struct ${paraPascalCase(nome)} final {
+${linhas.length > 0 ? linhas.join("\n") : "    // Estrutura intencionalmente vazia."}
+    bool operator==(const ${paraPascalCase(nome)}&) const = default;
 };`;
 }
 function gerarEnum(nome, valores) {
     const itens = (valores.length > 0 ? valores : ["VAZIO"]).map((valor) => `    ${paraConstanteCpp(valor)}`).join(",\n");
-    return `enum class ${paraPascalCase(nome)} {
-${itens}
+    return `enum class ${paraPascalCase(nome)} {
+${itens}
 };`;
 }
 function camposPorNome(campos) {
@@ -453,10 +453,10 @@ function nomeClasseErro(task, codigo) {
     return `${paraPascalCase(task.nome)}${paraPascalCase(codigo)}Erro`;
 }
 function gerarErrosTask(task) {
-    return [...coletarErrosTask(task).entries()].map(([codigo, mensagem]) => `class ${nomeClasseErro(task, codigo)} final : public std::runtime_error {
-public:
-    inline static constexpr std::string_view codigo = ${literalStringCpp(codigo)};
-    ${nomeClasseErro(task, codigo)}() : std::runtime_error(${literalStringCpp(mensagem)}) {}
+    return [...coletarErrosTask(task).entries()].map(([codigo, mensagem]) => `class ${nomeClasseErro(task, codigo)} final : public std::runtime_error {
+public:
+    inline static constexpr std::string_view codigo = ${literalStringCpp(codigo)};
+    ${nomeClasseErro(task, codigo)}() : std::runtime_error(${literalStringCpp(mensagem)}) {}
 };`).join("\n\n");
 }
 function literalCamposContrato(campos) {
@@ -471,13 +471,13 @@ function gerarDeclaracoesTask(task, modulo) {
     const nome = identificadorCpp(task.nome);
     const entrada = paraPascalCase(`${task.nome}_entrada`);
     const saida = paraPascalCase(`${task.nome}_saida`);
-    return `${gerarStruct(`${task.nome}_entrada`, task.input, modulo, "entrada")}
-
-${gerarStruct(`${task.nome}_saida`, task.output, modulo, "saida")}
-
-${gerarErrosTask(task)}${coletarErrosTask(task).size > 0 ? "\n\n" : ""}TaskContract contrato_${nome}();
-void validar_${nome}(const ${entrada}& entrada);
-void verificar_garantias_${nome}(const ${saida}& saida);
+    return `${gerarStruct(`${task.nome}_entrada`, task.input, modulo, "entrada")}
+
+${gerarStruct(`${task.nome}_saida`, task.output, modulo, "saida")}
+
+${gerarErrosTask(task)}${coletarErrosTask(task).size > 0 ? "\n\n" : ""}TaskContract contrato_${nome}();
+void validar_${nome}(const ${entrada}& entrada);
+void verificar_garantias_${nome}(const ${saida}& saida);
 ${saida} executar_${nome}(const ${entrada}& entrada, const ExecutionContext& contexto = {});`;
 }
 function valorExistenteCpp(campo, modulo) {
@@ -575,32 +575,32 @@ function gerarImplementacaoTask(task, modulo) {
         ? task.efeitosEstruturados.map((efeito) => `    // Efeito estruturado: categoria=${comentarioCpp(efeito.categoria)} alvo=${comentarioCpp(efeito.alvo)}${efeito.detalhe ? ` detalhe=${comentarioCpp(efeito.detalhe)}` : ""}${efeito.criticidade ? ` criticidade=${efeito.criticidade}` : ""}`).join("\n")
         : task.effects.map((efeito) => `    // Efeito declarado: ${comentarioCpp(efeito)}`).join("\n");
     const metadadosEfeitos = task.efeitosEstruturados.map((efeito) => `${efeito.categoria}:${efeito.alvo}${efeito.detalhe ? `:${efeito.detalhe}` : ""}`);
-    return `TaskContract contrato_${nome}() {
-    return TaskContract{
-        ${literalStringCpp(task.nome)},
-        ${literalCamposContrato(task.input)},
-        ${literalCamposContrato(task.output)},
-        ${literalStringsCpp(task.rules)},
-        ${literalStringsCpp(task.guarantees)},
-        ${literalStringsCpp(metadadosEfeitos.length > 0 ? metadadosEfeitos : task.effects)}
-    };
-}
-
-void validar_${nome}(const ${entrada}& entrada) {
-${gerarValidacoes(task, modulo)}
-}
-
-void verificar_garantias_${nome}(const ${saida}& saida) {
-${gerarGarantias(task, modulo)}
-}
-
-${saida} executar_${nome}(const ${entrada}& entrada, const ExecutionContext& contexto) {
-    (void)contexto;
-${falhas ? `${falhas}\n` : ""}    validar_${nome}(entrada);
-${task.stateContract ? `    // Vínculo de estado: ${comentarioCpp(task.stateContract.nomeEstado ?? "não definido")}\n    // Transições: ${comentarioCpp(task.stateContract.transicoes.map((item) => `${item.origem}->${item.destino}`).join(", ") || "nenhuma")}\n` : ""}${task.implementacoesExternas.map((item) => `    // Implementação externa: origem=${item.origem} caminho=${comentarioCpp(item.caminho)} status=${item.statusImpl ?? "não verificado"}`).join("\n")}${task.implementacoesExternas.length > 0 ? "\n" : ""}${efeitos || "    // Nenhum efeito declarado."}
-    ${saida} saida{};
-${gerarAjustesSaida(task, modulo).join("\n")}${gerarAjustesSaida(task, modulo).length > 0 ? "\n" : ""}    verificar_garantias_${nome}(saida);
-    return saida;
+    return `TaskContract contrato_${nome}() {
+    return TaskContract{
+        ${literalStringCpp(task.nome)},
+        ${literalCamposContrato(task.input)},
+        ${literalCamposContrato(task.output)},
+        ${literalStringsCpp(task.rules)},
+        ${literalStringsCpp(task.guarantees)},
+        ${literalStringsCpp(metadadosEfeitos.length > 0 ? metadadosEfeitos : task.effects)}
+    };
+}
+
+void validar_${nome}(const ${entrada}& entrada) {
+${gerarValidacoes(task, modulo)}
+}
+
+void verificar_garantias_${nome}(const ${saida}& saida) {
+${gerarGarantias(task, modulo)}
+}
+
+${saida} executar_${nome}(const ${entrada}& entrada, const ExecutionContext& contexto) {
+    (void)contexto;
+${falhas ? `${falhas}\n` : ""}    validar_${nome}(entrada);
+${task.stateContract ? `    // Vínculo de estado: ${comentarioCpp(task.stateContract.nomeEstado ?? "não definido")}\n    // Transições: ${comentarioCpp(task.stateContract.transicoes.map((item) => `${item.origem}->${item.destino}`).join(", ") || "nenhuma")}\n` : ""}${task.implementacoesExternas.map((item) => `    // Implementação externa: origem=${item.origem} caminho=${comentarioCpp(item.caminho)} status=${item.statusImpl ?? "não verificado"}`).join("\n")}${task.implementacoesExternas.length > 0 ? "\n" : ""}${efeitos || "    // Nenhum efeito declarado."}
+    ${saida} saida{};
+${gerarAjustesSaida(task, modulo).join("\n")}${gerarAjustesSaida(task, modulo).length > 0 ? "\n" : ""}    verificar_garantias_${nome}(saida);
+    return saida;
 }`;
 }
 function formatarValorTesteCpp(valor, campo, modulo) {
@@ -636,18 +636,18 @@ function gerarFuncaoTeste(task, indice, modulo) {
         return {
             nome,
             rotulo: caso.nome,
-            conteudo: `// SEMA-TEST: ${comentarioCpp(task.nome)} :: ${comentarioCpp(caso.nome)}
-void ${nome}() {
-    ${entrada} entrada{};
-${atribuicoes ? `${atribuicoes}\n` : ""}    ExecutionContext contexto{};
-    contexto.erro_esperado = ${literalStringCpp(tipoErro)};
-    try {
-        (void)executar_${identificadorCpp(task.nome)}(entrada, contexto);
-    } catch (const ${nomeClasseErro(task, tipoErro)}& erro) {
-        assert_sema(erro.codigo == ${literalStringCpp(tipoErro)}, "Código de erro inesperado");
-        return;
-    }
-    throw std::runtime_error(${literalStringCpp(`Caso ${caso.nome} deveria falhar com ${tipoErro}`)});
+            conteudo: `// SEMA-TEST: ${comentarioCpp(task.nome)} :: ${comentarioCpp(caso.nome)}
+void ${nome}() {
+    ${entrada} entrada{};
+${atribuicoes ? `${atribuicoes}\n` : ""}    ExecutionContext contexto{};
+    contexto.erro_esperado = ${literalStringCpp(tipoErro)};
+    try {
+        (void)executar_${identificadorCpp(task.nome)}(entrada, contexto);
+    } catch (const ${nomeClasseErro(task, tipoErro)}& erro) {
+        assert_sema(erro.codigo == ${literalStringCpp(tipoErro)}, "Código de erro inesperado");
+        return;
+    }
+    throw std::runtime_error(${literalStringCpp(`Caso ${caso.nome} deveria falhar com ${tipoErro}`)});
 }`,
         };
     }
@@ -657,27 +657,27 @@ ${atribuicoes ? `${atribuicoes}\n` : ""}    ExecutionContext contexto{};
         return {
             nome,
             rotulo: caso.nome,
-            conteudo: `// SEMA-TEST: ${comentarioCpp(task.nome)} :: ${comentarioCpp(caso.nome)}
-void ${nome}() {
-    ${entrada} entrada{};
-${atribuicoes ? `${atribuicoes}\n` : ""}    try {
-        (void)executar_${identificadorCpp(task.nome)}(entrada);
-    } catch (const std::exception&) {
-        return;
-    }
-    throw std::runtime_error(${literalStringCpp(`Caso ${caso.nome} esperava sucesso falso`)});
+            conteudo: `// SEMA-TEST: ${comentarioCpp(task.nome)} :: ${comentarioCpp(caso.nome)}
+void ${nome}() {
+    ${entrada} entrada{};
+${atribuicoes ? `${atribuicoes}\n` : ""}    try {
+        (void)executar_${identificadorCpp(task.nome)}(entrada);
+    } catch (const std::exception&) {
+        return;
+    }
+    throw std::runtime_error(${literalStringCpp(`Caso ${caso.nome} esperava sucesso falso`)});
 }`,
         };
     }
     return {
         nome,
         rotulo: caso.nome,
-        conteudo: `// SEMA-TEST: ${comentarioCpp(task.nome)} :: ${comentarioCpp(caso.nome)}
-void ${nome}() {
-    ${entrada} entrada{};
-${atribuicoes ? `${atribuicoes}\n` : ""}    const auto resultado = executar_${identificadorCpp(task.nome)}(entrada);
-    (void)resultado;
-${assercoes || `    assert_sema(true, ${literalStringCpp(`Caso ${caso.nome} executado`)});`}
+        conteudo: `// SEMA-TEST: ${comentarioCpp(task.nome)} :: ${comentarioCpp(caso.nome)}
+void ${nome}() {
+    ${entrada} entrada{};
+${atribuicoes ? `${atribuicoes}\n` : ""}    const auto resultado = executar_${identificadorCpp(task.nome)}(entrada);
+    (void)resultado;
+${assercoes || `    assert_sema(true, ${literalStringCpp(`Caso ${caso.nome} executado`)});`}
 }`,
     };
 }
@@ -702,8 +702,8 @@ function gerarCabecalhoSemaCpp(modulo, tipo) {
 function gerarHeader(modulo) {
     const namespace = nomeNamespace(modulo);
     const enums = modulo.enums.map((item) => gerarEnum(item.nome, item.valores));
-    const externos = coletarTiposExternos(modulo).map((item) => `struct ${paraPascalCase(item)} final {
-    bool operator==(const ${paraPascalCase(item)}&) const = default;
+    const externos = coletarTiposExternos(modulo).map((item) => `struct ${paraPascalCase(item)} final {
+    bool operator==(const ${paraPascalCase(item)}&) const = default;
 };`);
     const modelos = ordenarModelos(modulo).map((item) => `${gerarStruct(item.nome, item.campos, modulo, "modelo")}\n// Origem Sema: ${item.origem} ${comentarioCpp(item.nome)}`);
     const tasks = modulo.tasks.map((task) => gerarDeclaracoesTask(task, modulo));
@@ -712,56 +712,56 @@ function gerarHeader(modulo) {
     const flows = modulo.flows.map((item) => `// Flow ${comentarioCpp(item.nome)}: etapas=${item.etapasEstruturadas.length} tasks=${comentarioCpp(item.tasksReferenciadas.join(", ") || "nenhuma")}`);
     const routes = modulo.routes.map((item) => `// Route ${comentarioCpp(item.nome)}: método=${item.metodo ?? "não definido"} caminho=${comentarioCpp(item.caminho ?? "não definido")} task=${comentarioCpp(item.task ?? "não definida")}`);
     const secoes = [...interops, ...enums, ...externos, ...modelos, ...tasks, ...estados, ...flows, ...routes].filter(Boolean).join("\n\n");
-    return `${gerarCabecalhoSemaCpp(modulo, "cabecalho")}#pragma once
-
-#include <cmath>
-#include <cstdint>
-#include <map>
-#include <optional>
-#include <stdexcept>
-#include <string>
-#include <string_view>
-#include <variant>
-#include <vector>
-
-namespace ${namespace} {
-
-using JsonValue = std::string;
-
-struct CampoContrato final {
-    std::string_view nome;
-    std::string_view tipo;
-    bool obrigatorio;
-};
-
-struct TaskContract final {
-    std::string_view nome;
-    std::vector<CampoContrato> input;
-    std::vector<CampoContrato> output;
-    std::vector<std::string_view> regras;
-    std::vector<std::string_view> garantias;
-    std::vector<std::string_view> efeitos;
-};
-
-struct ExecutionContext final {
-    std::string erro_esperado{};
-};
-
-${secoes}
-
-} // namespace ${namespace}
+    return `${gerarCabecalhoSemaCpp(modulo, "cabecalho")}#pragma once
+
+#include <cmath>
+#include <cstdint>
+#include <map>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <variant>
+#include <vector>
+
+namespace ${namespace} {
+
+using JsonValue = std::string;
+
+struct CampoContrato final {
+    std::string_view nome;
+    std::string_view tipo;
+    bool obrigatorio;
+};
+
+struct TaskContract final {
+    std::string_view nome;
+    std::vector<CampoContrato> input;
+    std::vector<CampoContrato> output;
+    std::vector<std::string_view> regras;
+    std::vector<std::string_view> garantias;
+    std::vector<std::string_view> efeitos;
+};
+
+struct ExecutionContext final {
+    std::string erro_esperado{};
+};
+
+${secoes}
+
+} // namespace ${namespace}
 `;
 }
 function gerarSource(modulo, arquivoHeader) {
     const namespace = nomeNamespace(modulo);
     const implementacoes = modulo.tasks.map((task) => gerarImplementacaoTask(task, modulo)).join("\n\n");
-    return `${gerarCabecalhoSemaCpp(modulo, "implementacao")}#include ${literalStringCpp(path.posix.basename(arquivoHeader))}
-
-namespace ${namespace} {
-
-${implementacoes || "// Nenhuma task declarada no módulo."}
-
-} // namespace ${namespace}
+    return `${gerarCabecalhoSemaCpp(modulo, "implementacao")}#include ${literalStringCpp(path.posix.basename(arquivoHeader))}
+
+namespace ${namespace} {
+
+${implementacoes || "// Nenhuma task declarada no módulo."}
+
+} // namespace ${namespace}
 `;
 }
 function gerarTestes(modulo, arquivoHeader) {
@@ -771,75 +771,75 @@ function gerarTestes(modulo, arquivoHeader) {
     const funcoes = funcoesDeclaradas.length > 0 ? funcoesDeclaradas : [{
             nome: "test_smoke_modulo",
             rotulo: "smoke do módulo sem casos declarados",
-            conteudo: `// SEMA-TEST: smoke :: módulo sem casos declarados
-void test_smoke_modulo() {
-    assert_sema(true, "Runner C++ autocontido disponível");
+            conteudo: `// SEMA-TEST: smoke :: módulo sem casos declarados
+void test_smoke_modulo() {
+    assert_sema(true, "Runner C++ autocontido disponível");
 }`,
         }];
     const registros = funcoes.map((item) => `        {${literalStringCpp(item.rotulo)}, &${item.nome}}`).join(",\n");
-    return `${gerarCabecalhoSemaCpp(modulo, "teste")}#include ${literalStringCpp(path.posix.basename(arquivoHeader))}
-
-#include <iostream>
-#include <stdexcept>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-using namespace ${namespace};
-
-namespace {
-
-void assert_sema(bool condicao, std::string_view mensagem) {
-    if (!condicao) throw std::runtime_error(std::string{mensagem});
-}
-
-${funcoes.map((item) => item.conteudo).join("\n\n")}
-
-} // namespace
-
-int main() {
-    const std::vector<std::pair<std::string_view, void (*)()>> testes{
-${registros}
-    };
-    for (const auto& [nome, executar] : testes) {
-        std::cout << "test " << nome << '\\n';
-        executar();
-    }
-    std::cout << "ok " << testes.size() << " testes\\n";
-    return 0;
-}
+    return `${gerarCabecalhoSemaCpp(modulo, "teste")}#include ${literalStringCpp(path.posix.basename(arquivoHeader))}
+
+#include <iostream>
+#include <stdexcept>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+using namespace ${namespace};
+
+namespace {
+
+void assert_sema(bool condicao, std::string_view mensagem) {
+    if (!condicao) throw std::runtime_error(std::string{mensagem});
+}
+
+${funcoes.map((item) => item.conteudo).join("\n\n")}
+
+} // namespace
+
+int main() {
+    const std::vector<std::pair<std::string_view, void (*)()>> testes{
+${registros}
+    };
+    for (const auto& [nome, executar] : testes) {
+        std::cout << "test " << nome << '\\n';
+        executar();
+    }
+    std::cout << "ok " << testes.size() << " testes\\n";
+    return 0;
+}
 `;
 }
 function gerarCmake(modulo, arquivoSource, arquivoTeste) {
     const nomeProjeto = `sema_${identificadorCpp(normalizarNomeModulo(modulo.nome).replace(/\./g, "_").toLowerCase())}`;
     const alvoBiblioteca = `${nomeProjeto}_lib`;
     const alvoTeste = `test_${nomeProjeto}`;
-    return `${gerarCabecalhoSemaCpp(modulo, "cmake")}cmake_minimum_required(VERSION 3.16)
-project(${nomeProjeto} LANGUAGES CXX)
-
-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_CXX_EXTENSIONS OFF)
-
-add_library(${alvoBiblioteca} STATIC ${path.posix.basename(arquivoSource)})
-target_include_directories(${alvoBiblioteca} PUBLIC "\${CMAKE_CURRENT_SOURCE_DIR}")
-target_compile_features(${alvoBiblioteca} PUBLIC cxx_std_20)
-
-add_executable(${alvoTeste} ${path.posix.basename(arquivoTeste)})
-target_link_libraries(${alvoTeste} PRIVATE ${alvoBiblioteca})
-
-if(MSVC)
-  target_compile_options(${alvoBiblioteca} PRIVATE /W4 /permissive-)
-  target_compile_options(${alvoTeste} PRIVATE /W4 /permissive-)
-else()
-  target_compile_options(${alvoBiblioteca} PRIVATE -Wall -Wextra -Wpedantic)
-  target_compile_options(${alvoTeste} PRIVATE -Wall -Wextra -Wpedantic)
-endif()
-
-include(CTest)
-if(BUILD_TESTING)
-  add_test(NAME ${alvoTeste} COMMAND ${alvoTeste})
-endif()
+    return `${gerarCabecalhoSemaCpp(modulo, "cmake")}cmake_minimum_required(VERSION 3.16)
+project(${nomeProjeto} LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+add_library(${alvoBiblioteca} STATIC ${path.posix.basename(arquivoSource)})
+target_include_directories(${alvoBiblioteca} PUBLIC "\${CMAKE_CURRENT_SOURCE_DIR}")
+target_compile_features(${alvoBiblioteca} PUBLIC cxx_std_20)
+
+add_executable(${alvoTeste} ${path.posix.basename(arquivoTeste)})
+target_link_libraries(${alvoTeste} PRIVATE ${alvoBiblioteca})
+
+if(MSVC)
+  target_compile_options(${alvoBiblioteca} PRIVATE /W4 /permissive-)
+  target_compile_options(${alvoTeste} PRIVATE /W4 /permissive-)
+else()
+  target_compile_options(${alvoBiblioteca} PRIVATE -Wall -Wextra -Wpedantic)
+  target_compile_options(${alvoTeste} PRIVATE -Wall -Wextra -Wpedantic)
+endif()
+
+include(CTest)
+if(BUILD_TESTING)
+  add_test(NAME ${alvoTeste} COMMAND ${alvoTeste})
+endif()
 `;
 }
 export function gerarCpp(modulo) {

package/node_modules/@sema/gerador-cpp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema/gerador-cpp",
-  "version": "2.1.0",
+  "version": "2.3.1",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts"

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

@@ -32,19 +32,19 @@ export function gerarEstilosState(state) {
     return estilos.join("\n");
 }
 export function gerarEstilosEnum(enumeracao) {
-    return enumeracao.valores.map((valor) => `.sema-select option[value="${valor}"] {
-  color: var(--sema-cor-texto);
-}
+    return enumeracao.valores.map((valor) => `.sema-select option[value="${valor}"] {
+  color: var(--sema-cor-texto);
+}
 `).join("");
 }
 export function gerarCabecalhoSemaCss(modulo) {
-    return `/* SEMA-GOVERNED
- * Módulo de origem: ${modulo.nome}
- * Consulte o contrato .sema aplicável antes de editar este arquivo.
- * Rastreabilidade: outros contratos .sema podem governar este mesmo arquivo via vinculos.
- * Para IA fraca/média/forte: chame Sema, rode docs-impacto e drift antes de alterar código.
- * Descrição: CSS gerado para materializar o design system do contrato Sema.
- */
+    return `/* SEMA-GOVERNED
+ * Módulo de origem: ${modulo.nome}
+ * Consulte o contrato .sema aplicável antes de editar este arquivo.
+ * Rastreabilidade: outros contratos .sema podem governar este mesmo arquivo via vinculos.
+ * Para IA fraca/média/forte: chame Sema, rode docs-impacto e drift antes de alterar código.
+ * Descrição: CSS gerado para materializar o design system do contrato Sema.
+ */
 `;
 }
 //# sourceMappingURL=index.part01.js.map