@semacode/cli 2.2.0 → 2.3.1

package/dist/driftEscopoReferencias.js

@@ -0,0 +1,265 @@
+// SEMA-GOVERNED: sema.produto.governanca_ia.drift
+// Descricao: extrai e resolve candidatos exatos de dependencias locais sem caminhada de filesystem.
+import path from "node:path";
+const EXTENSOES_DEPENDENCIA_CODIGO = [
+    ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".dart", ".lua", ".cs", ".java",
+    ".go", ".rs", ".php", ".cpp", ".cc", ".cxx", ".hpp", ".h",
+    ".sql", ".psql", ".ddl", ".prisma", ".html", ".htm", ".css",
+];
+const EXTENSOES_TYPESCRIPT_DEPENDENCIA = [
+    ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".html", ".htm", ".css",
+];
+const PREFIXO_REFERENCIA_PYTHON = "python:";
+function chaveCaminho(caminho) {
+    const absoluto = path.normalize(path.resolve(caminho));
+    return process.platform === "win32" ? absoluto.toLowerCase() : absoluto;
+}
+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 mascararIntervalo(codigo, saida, inicio, fim) {
+    for (let indice = inicio; indice < fim; indice += 1) {
+        if (codigo[indice] !== "\n" && codigo[indice] !== "\r") {
+            saida[indice] = " ";
+        }
+    }
+}
+/** Remove comentarios/docstrings sem alterar offsets ou caminhos em literais de imports reais. */
+function removerComentariosDependencias(codigo) {
+    const saida = [...codigo];
+    let indice = 0;
+    while (indice < codigo.length) {
+        const atual = codigo[indice];
+        const proximo = codigo[indice + 1];
+        if ((atual === "'" || atual === '"') && codigo.slice(indice, indice + 3) === atual.repeat(3)) {
+            const delimitador = atual.repeat(3);
+            const fimEncontrado = codigo.indexOf(delimitador, indice + 3);
+            const fim = fimEncontrado < 0 ? codigo.length : fimEncontrado + 3;
+            mascararIntervalo(codigo, saida, indice, fim);
+            indice = fim;
+            continue;
+        }
+        if (atual === "`") {
+            const inicio = indice;
+            indice += 1;
+            while (indice < codigo.length) {
+                if (codigo[indice] === "\\") {
+                    indice += 2;
+                    continue;
+                }
+                if (codigo[indice] === "`") {
+                    indice += 1;
+                    break;
+                }
+                indice += 1;
+            }
+            mascararIntervalo(codigo, saida, inicio, indice);
+            continue;
+        }
+        if (atual === "'" || atual === '"') {
+            const delimitador = atual;
+            indice += 1;
+            while (indice < codigo.length) {
+                if (codigo[indice] === "\\") {
+                    indice += 2;
+                    continue;
+                }
+                if (codigo[indice] === delimitador) {
+                    indice += 1;
+                    break;
+                }
+                indice += 1;
+            }
+            continue;
+        }
+        if (atual === "/" && proximo === "/") {
+            const fimLinha = codigo.indexOf("\n", indice + 2);
+            const fim = fimLinha < 0 ? codigo.length : fimLinha;
+            mascararIntervalo(codigo, saida, indice, fim);
+            indice = fim;
+            continue;
+        }
+        if (atual === "/" && proximo === "*") {
+            const fimEncontrado = codigo.indexOf("*/", indice + 2);
+            const fim = fimEncontrado < 0 ? codigo.length : fimEncontrado + 2;
+            mascararIntervalo(codigo, saida, indice, fim);
+            indice = fim;
+            continue;
+        }
+        if (atual === "#") {
+            const inicioLinha = codigo.lastIndexOf("\n", indice - 1) + 1;
+            const prefixoLinha = codigo.slice(inicioLinha, indice);
+            if (/^\s*$/u.test(prefixoLinha) && codigo.slice(indice).startsWith("#include")) {
+                indice += 1;
+                continue;
+            }
+            const fimLinha = codigo.indexOf("\n", indice + 1);
+            const fim = fimLinha < 0 ? codigo.length : fimLinha;
+            mascararIntervalo(codigo, saida, indice, fim);
+            indice = fim;
+            continue;
+        }
+        indice += 1;
+    }
+    return saida.join("");
+}
+function referenciaTypescriptLocal(referencia) {
+    return referencia.startsWith(".") || referencia.startsWith("@/");
+}
+function adicionarImportacoesPython(codigo, referencias) {
+    const adicionarModulo = (modulo) => {
+        const normalizado = modulo.trim();
+        if (/^\.*[A-Za-z_][A-Za-z0-9_.]*$/u.test(normalizado)) {
+            referencias.add(`${PREFIXO_REFERENCIA_PYTHON}${normalizado}`);
+        }
+    };
+    for (const ocorrencia of codigo.matchAll(/^\s*import\s+([^\r\n;]+)$/gmu)) {
+        for (const item of (ocorrencia[1] ?? "").split(",")) {
+            adicionarModulo(item.trim().split(/\s+as\s+/iu)[0] ?? "");
+        }
+    }
+    for (const ocorrencia of codigo.matchAll(/^\s*from\s+(\.*[A-Za-z_][A-Za-z0-9_.]*|\.+)\s+import\s+([^\r\n;]+)$/gmu)) {
+        const modulo = ocorrencia[1] ?? "";
+        adicionarModulo(modulo);
+        const importados = (ocorrencia[2] ?? "").replace(/[()\\]/gu, "");
+        for (const item of importados.split(",")) {
+            const nome = item.trim().split(/\s+as\s+/iu)[0] ?? "";
+            if (nome && nome !== "*" && /^[A-Za-z_][A-Za-z0-9_]*$/u.test(nome)) {
+                adicionarModulo(`${modulo}${modulo.endsWith(".") ? "" : "."}${nome}`);
+            }
+        }
+    }
+}
+export function extrairReferenciasLocaisDrift(codigo) {
+    const referencias = new Set();
+    const codigoExecutavel = removerComentariosDependencias(codigo);
+    const padroesTypescript = [
+        /^\s*(?:import|export)\s+(?:type\s+)?(?:[A-Za-z_$][\w$]*\s*,\s*)?\{[^}]*\}\s+from\s+["'`]([^"'`\r\n]+)["'`]/gmu,
+        /^\s*(?:import|export)\s+(?:type\s+)?(?:[^;"'`\r\n]*?\s+from\s+)?["'`]([^"'`\r\n]+)["'`]/gmu,
+        /\b(?:import|require)\s*\(\s*["'`]([^"'`\r\n]+)["'`]\s*\)/gu,
+        /\b(?:templateUrl|styleUrls?)\s*:\s*(?:\[\s*)?["'`]([^"'`\r\n]+)["'`]/gu,
+        /^\s*@import\s+(?:url\(\s*)?["'`]([^"'`\r\n]+)["'`]/gmu,
+    ];
+    for (const padrao of padroesTypescript) {
+        for (const ocorrencia of codigoExecutavel.matchAll(padrao)) {
+            const referencia = ocorrencia[1]?.trim();
+            if (referencia && referenciaTypescriptLocal(referencia)) {
+                referencias.add(referencia);
+            }
+        }
+    }
+    for (const ocorrencia of codigoExecutavel.matchAll(/^\s*#include\s+["']([^"'\r\n]+)["']/gmu)) {
+        const referencia = ocorrencia[1]?.trim();
+        if (referencia && !referencia.includes(":")) {
+            referencias.add(referencia);
+        }
+    }
+    for (const ocorrencia of codigoExecutavel.matchAll(/\b(?:require|include)(?:_once)?\s*\(?\s*["']([^"'\r\n]+)["']/gu)) {
+        const referencia = ocorrencia[1]?.trim();
+        const extensao = path.posix.extname(referencia ?? "").toLowerCase();
+        if (referencia
+            && !referencia.includes(":")
+            && (referencia.startsWith(".") || EXTENSOES_DEPENDENCIA_CODIGO.includes(extensao))) {
+            referencias.add(referencia);
+        }
+    }
+    adicionarImportacoesPython(codigoExecutavel, referencias);
+    return [...referencias];
+}
+export function raizesCodigoLogicasDrift(contexto) {
+    const candidatas = contexto.diretoriosCodigo.length > 0
+        ? contexto.diretoriosCodigo
+        : [contexto.baseProjeto];
+    return [...new Map(candidatas
+            .map((raiz) => path.resolve(raiz))
+            .filter((raiz) => caminhoEstaDentro(contexto.baseProjeto, raiz))
+            .map((raiz) => [chaveCaminho(raiz), raiz])).values()];
+}
+function adicionarVariantesArquivo(candidatos, base, extensoesPermitidas) {
+    const extensao = path.extname(base).toLowerCase();
+    const extensaoConhecida = extensoesPermitidas.includes(extensao);
+    const adicionar = (caminho) => {
+        const absoluto = path.resolve(caminho);
+        const chave = chaveCaminho(absoluto);
+        if (!candidatos.has(chave)) {
+            candidatos.set(chave, absoluto);
+        }
+    };
+    adicionar(base);
+    if ([".js", ".jsx", ".mjs", ".cjs"].includes(extensao)) {
+        const semExtensao = base.slice(0, -extensao.length);
+        for (const alternativa of [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]) {
+            adicionar(`${semExtensao}${alternativa}`);
+        }
+    }
+    else if (!extensaoConhecida) {
+        for (const alternativa of extensoesPermitidas) {
+            adicionar(`${base}${alternativa}`);
+            adicionar(path.join(base, `index${alternativa}`));
+        }
+    }
+}
+function candidatosModuloPython(contexto, arquivoOrigem, moduloDeclarado) {
+    const candidatos = new Map();
+    const correspondencia = /^(\.*)(.*)$/u.exec(moduloDeclarado);
+    const prefixoRelativo = correspondencia?.[1] ?? "";
+    const modulo = correspondencia?.[2] ?? "";
+    const segmentos = modulo.split(".").filter(Boolean);
+    const bases = new Map();
+    const adicionarBase = (base, segmentosBase) => {
+        const caminhoModulo = path.resolve(base, ...segmentosBase);
+        bases.set(chaveCaminho(caminhoModulo), caminhoModulo);
+    };
+    if (prefixoRelativo.length > 0) {
+        let baseRelativa = path.dirname(arquivoOrigem);
+        for (let nivel = 1; nivel < prefixoRelativo.length; nivel += 1) {
+            baseRelativa = path.dirname(baseRelativa);
+        }
+        adicionarBase(baseRelativa, segmentos);
+    }
+    else {
+        const raizes = raizesCodigoLogicasDrift(contexto);
+        for (const base of [path.dirname(arquivoOrigem), contexto.baseProjeto, ...raizes]) {
+            adicionarBase(base, segmentos);
+            const nomeBase = path.basename(base).toLowerCase();
+            if (segmentos[0]?.toLowerCase() === nomeBase) {
+                adicionarBase(base, segmentos.slice(1));
+            }
+        }
+    }
+    for (const base of bases.values()) {
+        const arquivoModulo = `${base}.py`;
+        candidatos.set(chaveCaminho(arquivoModulo), arquivoModulo);
+        const inicializador = path.join(base, "__init__.py");
+        candidatos.set(chaveCaminho(inicializador), inicializador);
+    }
+    return [...candidatos.values()];
+}
+export function candidatosReferenciaLocalDrift(contexto, arquivoOrigem, referencia) {
+    if (referencia.startsWith(PREFIXO_REFERENCIA_PYTHON)) {
+        if (path.extname(arquivoOrigem).toLowerCase() !== ".py") {
+            return [];
+        }
+        return candidatosModuloPython(contexto, arquivoOrigem, referencia.slice(PREFIXO_REFERENCIA_PYTHON.length));
+    }
+    const candidatos = new Map();
+    if (referencia.startsWith("@/")) {
+        const relativoAlias = referencia.slice(2);
+        const raizes = raizesCodigoLogicasDrift(contexto).sort((a, b) => {
+            const aContemOrigem = caminhoEstaDentro(a, arquivoOrigem) ? 1 : 0;
+            const bContemOrigem = caminhoEstaDentro(b, arquivoOrigem) ? 1 : 0;
+            return bContemOrigem - aContemOrigem || b.length - a.length || a.localeCompare(b, "pt-BR");
+        });
+        for (const raiz of raizes) {
+            adicionarVariantesArquivo(candidatos, path.resolve(raiz, relativoAlias), EXTENSOES_TYPESCRIPT_DEPENDENCIA);
+        }
+    }
+    else {
+        adicionarVariantesArquivo(candidatos, path.resolve(path.dirname(arquivoOrigem), referencia), EXTENSOES_DEPENDENCIA_CODIGO);
+    }
+    return [...candidatos.values()];
+}
+//# sourceMappingURL=driftEscopoReferencias.js.map

package/dist/driftOrcamento.d.ts

@@ -4,6 +4,7 @@ export declare const LIMITE_AVISO_LINHAS_CONTRATO_SEMA = 300;
 export declare const LIMITE_BLOQUEIO_LINHAS_CONTRATO_SEMA = 500;
 export declare const LIMITE_AVISO_LINHAS_ORCAMENTO_SEMANTICO = 1000;
 export declare const LIMITE_BLOQUEIO_LINHAS_ORCAMENTO_SEMANTICO = 2000;
+export declare function workspaceExigeCabecalhoCodigoGovernado(baseProjeto: string, modoEstrito: boolean): Promise<boolean>;
 export type TipoArquivoOrcamento = "contrato" | "codigo" | "documentacao" | "gerado" | "migracao_historica";
 export type SeveridadeOrcamentoSemantico = "ok" | "aviso" | "erro";
 export type TipoDiagnosticoOrcamento = "contrato_monolitico" | "codigo_monolitico" | "codigo_governado_sem_cabecalho";
@@ -35,6 +36,16 @@ export interface DiagnosticoOrcamentoArquivo {
     limite_aviso_linhas: number;
     limite_bloqueio_linhas: number;
 }
+/**
+ * Leitor limitado a um conjunto de arquivos previamente catalogado.
+ *
+ * Quando fornecido, o gate de orcamento nao faz fallback para o filesystem:
+ * um caminho fora do leitor e simplesmente ignorado nesta etapa.
+ */
+export interface LeitorArquivosOrcamento {
+    contem(caminho: string): boolean;
+    lerTexto(caminho: string): Promise<string>;
+}
 export interface LimitesOrcamentoSemantico {
     aviso: number;
     bloqueio: number;
@@ -76,4 +87,5 @@ export declare function emitirDiagnosticosArquivosOrcamento(opcoes: {
     arquivos: string[];
     baseProjeto?: string;
     exigirCabecalhoCodigoGovernado?: boolean;
+    leitorArquivos?: LeitorArquivosOrcamento;
 }): Promise<DiagnosticoOrcamentoArquivo[]>;

package/dist/driftOrcamento.js

@@ -2,7 +2,7 @@
 // Módulo: sema.produto.orcamento_semantico
 // Contrato: contratos/sema/orcamento_semantico.sema
 // Descrição: centraliza os gates de linhas e cabeçalho Sema para drift, finalização e snapshots.
-import { readFile } from "node:fs/promises";
+import { lstat, readFile } from "node:fs/promises";
 import path from "node:path";
 export const LIMITE_AVISO_LINHAS_CODIGO_GOVERNADO = 1000;
 export const LIMITE_BLOQUEIO_LINHAS_CODIGO_GOVERNADO = 2000;
@@ -10,6 +10,16 @@ export const LIMITE_AVISO_LINHAS_CONTRATO_SEMA = 300;
 export const LIMITE_BLOQUEIO_LINHAS_CONTRATO_SEMA = 500;
 export const LIMITE_AVISO_LINHAS_ORCAMENTO_SEMANTICO = LIMITE_AVISO_LINHAS_CODIGO_GOVERNADO;
 export const LIMITE_BLOQUEIO_LINHAS_ORCAMENTO_SEMANTICO = LIMITE_BLOQUEIO_LINHAS_CODIGO_GOVERNADO;
+export async function workspaceExigeCabecalhoCodigoGovernado(baseProjeto, modoEstrito) {
+    if (!modoEstrito)
+        return false;
+    try {
+        return (await lstat(path.resolve(baseProjeto, "AGENTS.md"))).isFile();
+    }
+    catch {
+        return false;
+    }
+}
 const EXTENSOES_CODIGO_GOVERNAVEL = new Set([
     ".ts",
     ".tsx",
@@ -289,13 +299,19 @@ export async function emitirDiagnosticosArquivosOrcamento(opcoes) {
         const absoluto = path.isAbsolute(arquivoInformado)
             ? arquivoInformado
             : path.resolve(baseProjeto, arquivoInformado);
-        const chave = path.resolve(absoluto);
+        const resolvido = path.resolve(absoluto);
+        const chave = process.platform === "win32" ? resolvido.toLowerCase() : resolvido;
         if (vistos.has(chave)) {
             continue;
         }
         vistos.add(chave);
+        if (opcoes.leitorArquivos && !opcoes.leitorArquivos.contem(absoluto)) {
+            continue;
+        }
         try {
-            const conteudo = await readFile(absoluto, "utf8");
+            const conteudo = opcoes.leitorArquivos
+                ? await opcoes.leitorArquivos.lerTexto(absoluto)
+                : await readFile(absoluto, "utf8");
             const relativo = path.relative(baseProjeto, absoluto).replace(/\\/g, "/") || arquivoInformado.replace(/\\/g, "/");
             diagnosticos.push(...avaliarOrcamentoArquivo({
                 arquivo: relativo,

package/dist/execucoesExternas.js

@@ -1,6 +1,7 @@
-// SEMA-GOVERNED: sema.produto.cli_toolchain_local
-// Contrato: contratos/sema/cli_toolchain_local.sema
-// Descrição: detecção de comandos externos usados por doctor, testes gerados e runners opcionais.
+// SEMA-GOVERNED
+// M?dulo: sema.produto.orcamento_semantico
+// Contrato: contratos/sema/orcamento_semantico.sema
+// Descri??o: detec??o de comandos externos usados por doctor, testes gerados e runners opcionais.
 import { spawnSync } from "node:child_process";
 import { createRequire } from "node:module";
 const requireRuntimeCli = createRequire(import.meta.url);
@@ -15,29 +16,14 @@ function resolverImportadorNodeOpcional(especificador) {
 export const TSX_IMPORTADOR_CLI = resolverImportadorNodeOpcional("tsx");
 export const TSX_EXECUTOR_CLI = resolverImportadorNodeOpcional("tsx/cli");
 const TIMEOUT_CHECAGEM_COMANDO_MS = 5_000;
-const disponibilidadeComandosNoProcesso = new Map();
 export function comandoDisponivel(comando, argumentos = ["--version"]) {
-    const chaveSondagem = JSON.stringify({
-        comando,
-        argumentos,
-        cwd: process.cwd(),
-        path: process.env.PATH ?? "",
-        pathExt: process.env.PATHEXT ?? "",
-        comSpec: process.env.COMSPEC ?? "",
-    });
-    const resultadoMemorizado = disponibilidadeComandosNoProcesso.get(chaveSondagem);
-    if (resultadoMemorizado !== undefined) {
-        return resultadoMemorizado;
-    }
     const execucao = spawnSync(comando, argumentos, {
         stdio: "ignore",
         shell: process.platform === "win32",
         timeout: TIMEOUT_CHECAGEM_COMANDO_MS,
         windowsHide: true,
     });
-    const disponivel = !execucao.error && execucao.signal === null && (execucao.status ?? 1) === 0;
-    disponibilidadeComandosNoProcesso.set(chaveSondagem, disponivel);
-    return disponivel;
+    return !execucao.error && execucao.signal === null && (execucao.status ?? 1) === 0;
 }
 export function resolverExecucaoPython() {
     if (comandoDisponivel("python")) {

package/dist/exemplosOficiais.js

@@ -6,6 +6,32 @@ import { fileURLToPath } from "node:url";
 import { caminhoEhDiretorio } from "./fsGovernado.js";
 import { escreverArquivoWorkspaceSeguro, validarDestinosEscritaWorkspace, } from "./workspaceWrite.js";
 const DIRETORIO_CLI_ATUAL = path.dirname(fileURLToPath(import.meta.url));
+const EXTENSOES_EXEMPLOS_OFICIAIS = new Set([".sema", ".json", ".md"]);
+async function listarArquivosExemplosOficiais(origem, diretorioAtual = origem) {
+    const arquivos = [];
+    const entradas = await readdir(diretorioAtual, { withFileTypes: true });
+    for (const entrada of entradas) {
+        const origemArquivo = path.join(diretorioAtual, entrada.name);
+        const relativoOrigem = path.relative(origem, origemArquivo);
+        if (entrada.isSymbolicLink()) {
+            throw new Error(`Exemplo oficial nao pode atravessar symlink ou junction: ${relativoOrigem}`);
+        }
+        if (entrada.isDirectory()) {
+            arquivos.push(...await listarArquivosExemplosOficiais(origem, origemArquivo));
+            continue;
+        }
+        if (!entrada.isFile() ||
+            !EXTENSOES_EXEMPLOS_OFICIAIS.has(path.extname(entrada.name).toLowerCase())) {
+            continue;
+        }
+        arquivos.push({
+            nome: relativoOrigem,
+            origemArquivo,
+            caminhoRelativo: path.join("exemplos", relativoOrigem),
+        });
+    }
+    return arquivos;
+}
 export async function localizarDiretorioExemplosOficiais() {
     const candidatos = [
         path.resolve(DIRETORIO_CLI_ATUAL, "..", "exemplos"),
@@ -23,16 +49,11 @@ export async function planejarExemplosOficiais() {
     if (!origem) {
         return { origem: undefined, arquivos: [] };
     }
-    const entradas = (await readdir(origem, { withFileTypes: true }))
-        .filter((entrada) => entrada.isFile() && entrada.name.endsWith(".sema"))
-        .sort((a, b) => a.name.localeCompare(b.name, "pt-BR"));
+    const arquivos = await listarArquivosExemplosOficiais(origem);
+    arquivos.sort((a, b) => a.caminhoRelativo.localeCompare(b.caminhoRelativo, "pt-BR"));
     return {
         origem,
-        arquivos: entradas.map((entrada) => ({
-            nome: entrada.name,
-            origemArquivo: path.join(origem, entrada.name),
-            caminhoRelativo: path.join("exemplos", entrada.name),
-        })),
+        arquivos,
     };
 }
 export async function materializarExemplosOficiais(baseProjeto = process.cwd(), preservarExistentes = true) {

package/dist/iaPrompts.d.ts

@@ -3,4 +3,4 @@ export declare const PROMPT_BASE_IA = "Voce esta trabalhando com Sema, um contra
 export declare const PROMPT_IA_UI = "Atue como Engenheiro de Software Senior e UX/UI Designer de elite.\n\nQuero que voce trabalhe com Sema como fonte de verdade semantica do sistema e com React + TypeScript como camada de interface.\n\nEntregue obrigatoriamente duas partes integradas:\n1. os arquivos `.sema` do dominio\n2. a proposta ou implementacao da interface em React + TypeScript\n\nRegras:\n- nao entregue apenas HTML solto em arquivo unico\n- nao trate a Sema como enfeite conceitual\n- a interface deve nascer do contrato semantico definido em Sema\n- use os exemplos oficiais da Sema como referencia de estilo e semantica\n- nao invente sintaxe fora da gramatica suportada\n\nA Sema deve modelar, quando fizer sentido:\n- `module`\n- `use`\n- `entity`\n- `enum`\n- `state`\n- `task`\n- `flow`\n- `route`\n- `effects`\n- `error`\n- `guarantees`\n- `tests`\n- `docs`\n\nA interface deve refletir visualmente:\n- `state` como status e progresso observavel\n- `flow` como etapas ou orquestracao visivel\n- `error` como falhas tratadas com clareza\n- `effects` como operacoes relevantes para usuario ou operacao\n- `guarantees` como confianca, confirmacao ou consistencia final\n\nEstruture a entrega assim:\n1. visao do produto\n2. dominio modelado em Sema\n3. arquitetura de pastas em React + TypeScript\n4. componentes principais\n5. estrategia visual\n6. codigo principal da interface\n7. explicacao curta de como a UI conversa com a semantica da Sema\n\nSe a tarefa envolver app visual, a Sema governa o significado e o React renderiza a experiencia. Nao atropele essa separacao.\n";
 export declare const PROMPT_IA_REACT = "Crie uma solucao com Sema + React + TypeScript.\n\nRegras principais:\n- a Sema deve ser a fonte de verdade semantica do dominio\n- React + TypeScript deve ser a camada de interface e experiencia\n- nao entregue HTML unico solto\n- nao trate a Sema como enfeite\n\nEntregue obrigatoriamente:\n1. arquivos `.sema` do dominio\n2. arquitetura de pastas do frontend\n3. componentes React principais\n4. contratos e tipos derivados da semantica\n5. interface elegante e implementavel\n\nA modelagem Sema deve cobrir, quando fizer sentido:\n- `entity`\n- `enum`\n- `state`\n- `task`\n- `flow`\n- `route`\n- `effects`\n- `error`\n- `guarantees`\n- `tests`\n\nA interface React deve tornar visiveis:\n- estado atual e transicoes relevantes\n- fluxo operacional\n- erros publicos\n- efeitos operacionais importantes\n- garantias ou confirmacoes finais\n\nEstruture a entrega assim:\n1. visao do produto\n2. arquivos `.sema`\n3. arquitetura React + TypeScript\n4. componentes e telas\n5. codigo principal\n6. explicacao de como a UI deriva da semantica da Sema\n\nSe houver duvida, siga os exemplos oficiais e mantenha a separacao:\n- Sema governa o significado\n- React governa a apresentacao\n";
 export declare const PROMPT_IA_SEMA_PRIMEIRO = "Quero que voce trabalhe no modo \"Sema primeiro\".\n\nRegra principal:\n- modele primeiro o dominio em arquivos `.sema`\n- se a intencao mudar, crie, edite ou remova o contrato antes de qualquer acao operacional\n- so depois proponha ou gere codigo de aplicacao derivado disso\n\nFluxo obrigatorio:\n1. entender o dominio pedido\n2. modelar o contrato em Sema\n3. validar coerencia entre `task`, `route`, `state`, `flow`, `error`, `effects` e `guarantees`\n4. so depois gerar TypeScript, Python, React ou outra camada de implementacao\n\nNao entregue apenas codigo de interface ou codigo imperativo direto sem antes entregar a camada semantica.\n\nA modelagem em Sema deve:\n- preservar a intencao do dominio\n- explicitar entradas, saidas, erros, efeitos e garantias\n- usar apenas blocos e sintaxe oficiais\n- incluir testes embutidos quando fizer sentido\n\nSe houver interface grafica:\n- entregue a modelagem Sema primeiro\n- depois explique como a interface deve refletir a semantica\n- se gerar UI, use React + TypeScript em vez de HTML unico solto\n\nSe houver backend:\n- entregue a modelagem Sema primeiro\n- depois gere a borda publica e a implementacao derivada\n\nNao pule a etapa semantica. A camada `.sema` e a ancora principal da solucao.\n";
-export declare const EXEMPLOS_PROMPT_IA = "Exemplos de prompt oficial para trabalhar com Sema\n\n1. Sema primeiro\n\nCrie uma solucao seguindo a estrategia \"Sema primeiro\".\nEntregue primeiro os arquivos `.sema` do dominio e so depois a implementacao derivada.\nNao entregue apenas codigo imperativo.\nUse Sema como fonte de verdade para contratos, estados, erros, efeitos e garantias.\n\n2. Sema + React + TypeScript\n\nCrie um projeto com Sema + React + TypeScript.\nEntregue:\n- os arquivos `.sema` do dominio\n- a arquitetura de pastas do frontend\n- componentes React que reflitam `state`, `flow`, `error`, `effects` e `guarantees`\n- uma interface elegante e implementavel\n- nao entregue HTML solto em arquivo unico\n\n3. Revisar ou corrigir um modulo Sema\n\nRevise e corrija um modulo `.sema`.\nAntes de editar:\n- leia os exemplos oficiais parecidos\n- consulte AST e IR\nDepois de editar:\n- rode `sema formatar`\n- rode `sema validar --json`\n- use `diagnosticos --json` se houver falha\n- feche com `sema verificar`\n\n4. Caso de UI sem perder a semantica\n\nQuero uma interface premium para este dominio, mas a solucao deve continuar ancorada em Sema.\nModele primeiro o dominio em `.sema`.\nDepois proponha uma interface em React + TypeScript que torne visiveis:\n- estado\n- fluxo\n- erros\n- efeitos\n- garantias\nNao transforme isso em um `index.html` solto.\n\nComandos uteis da CLI para esse fluxo:\n- `sema starter-ia`\n- `sema ajuda-ia`\n- `sema resumo <arquivo-ou-pasta>`\n- `sema prompt-curto <arquivo-ou-pasta>`\n- `sema prompt-ia`\n- `sema prompt-ia-ui`\n- `sema prompt-ia-react`\n- `sema prompt-ia-sema-primeiro`\n- `sema contexto-ia <arquivo.sema>`\n";
+export declare const EXEMPLOS_PROMPT_IA = "Exemplos de prompt oficial para trabalhar com Sema\n\n1. Sema primeiro\n\nCrie uma solucao seguindo a estrategia \"Sema primeiro\".\nEntregue primeiro os arquivos `.sema` do dominio e so depois a implementacao derivada.\nNao entregue apenas codigo imperativo.\nUse Sema como fonte de verdade para contratos, estados, erros, efeitos e garantias.\n\n2. Sema + React + TypeScript\n\nCrie um projeto com Sema + React + TypeScript.\nEntregue:\n- os arquivos `.sema` do dominio\n- a arquitetura de pastas do frontend\n- componentes React que reflitam `state`, `flow`, `error`, `effects` e `guarantees`\n- uma interface elegante e implementavel\n- nao entregue HTML solto em arquivo unico\n\n3. Revisar ou corrigir um modulo Sema\n\nRevise e corrija um modulo `.sema`.\nAntes de editar:\n- leia os exemplos oficiais parecidos\n- consulte AST e IR\nDepois de editar:\n- rode `sema formatar`\n- rode `sema validar --json`\n- use `diagnosticos --json` se houver falha\n- feche com `sema verificar`\n\n4. Caso de UI sem perder a semantica\n\nQuero uma interface premium para este dominio, mas a solucao deve continuar ancorada em Sema.\nModele primeiro o dominio em `.sema`.\nDepois proponha uma interface em React + TypeScript que torne visiveis:\n- estado\n- fluxo\n- erros\n- efeitos\n- garantias\nNao transforme isso em um `index.html` solto.\n\nComandos uteis da CLI para esse fluxo:\n- `sema starter-ia`\n- `sema ajuda-ia`\n- `sema descobrir catalogo --json`\n- `sema descobrir recomendar --intencao \"<objetivo>\" --json`\n- `sema interativo pipelines --json`\n- `sema resumo <arquivo-ou-pasta>`\n- `sema prompt-curto <arquivo-ou-pasta>`\n- `sema prompt-ia`\n- `sema prompt-ia-ui`\n- `sema prompt-ia-react`\n- `sema prompt-ia-sema-primeiro`\n- `sema contexto-ia <arquivo.sema>`\n";