@semacode/cli 1.5.36 → 1.5.37

package/dist/iaPrompts.js

@@ -0,0 +1,318 @@
+// SEMA-GOVERNED
+// M?dulo: sema.produto.orcamento_semantico
+// Contrato: contratos/sema/orcamento_semantico.sema
+// Descri??o: textos oficiais de prompt e onboarding IA-first usados pela CLI.
+export const STARTER_IA = `Voce esta trabalhando com Sema, um contrato semantico IA-first para agentes operarem software vivo em backend e front consumer.
+
+Importante:
+- a Sema se apresenta publicamente como protocolo e funciona tecnicamente como linguagem de intencao
+- a Sema e protocolo de governanca semantica desenhado para IA, nao para ergonomia humana
+- humanos sao autores/aprovadores; agentes sao os consumidores primarios do contrato
+- leitura humana e bonus toleravel, nao objetivo de produto
+- a Sema nao e gerador magico que deveria fazer tudo
+- a Sema modela contratos, estados, fluxos, erros, efeitos, garantias, vinculos e execucao
+- a Sema gera codigo e scaffolding real para TypeScript, Python e Dart
+- a Sema usa \`importar\` para bootstrap revisavel, nao para contrato final automatico
+- a Sema usa \`impl\` para ligar task a simbolo real do runtime
+- a Sema usa \`vinculos\` para ligar contrato a arquivo, simbolo, recurso e superficie real
+- a Sema usa \`execucao\` para explicitar timeout, retry, compensacao e criticidade
+- a Sema usa \`drift\` para medir diferenca entre contrato e codigo vivo com score, confianca e lacunas
+- a Sema usa \`resumo\` e \`prompt-curto\` para IA fraca, gratuita ou com pouco contexto
+- a Sema usa \`contexto-ia\` para gerar \`ast.json\`, \`ir.json\`, \`drift.json\`, \`briefing.json\` e artefatos compactos antes da edicao
+- timeout definido pelo agente nao e falha do Sema; aumente o timeout e tente de novo antes de concluir falha
+- a Sema pode servir de base para interfaces graficas elegantes e coerentes
+- a Sema nao gera uma interface completa sozinha no estado atual
+- trate a Sema como cerebro semantico da aplicacao, nao como gerador magico de front-end pronto
+- se a tarefa envolver UI, prefira pedir Sema + React + TypeScript ou Sema + arquitetura de front-end
+- evite pedir HTML unico solto quando a intencao for testar a Sema de verdade
+
+Regras:
+- nao invente sintaxe fora da gramatica e dos exemplos oficiais
+- antes de qualquer acao, crie, edite ou remova o contrato .sema aplicavel; isso vale para Software, Author, Workflow, Ops, Game, Legal e Research
+- se a IA for fraca, nao tente abrir tudo de uma vez
+- use \`sema resumo\` e \`briefing.min.json\` antes de subir para o pacote completo
+- se \`sema resumo . --micro\` estourar timeout local, repita com timeout maior ou escopo menor; nao avance com codigo
+- trate \`ir --json\` como fonte de verdade semantica
+- trate \`briefing.json\` como plano de intervencao antes de editar projeto vivo
+- trate \`diagnosticos --json\` como fonte de correcao
+- use \`sema formatar\` como fonte unica de estilo
+- preserve a intencao do contrato
+- nao cobre da Sema adivinhacao de negocio que nao esta no contrato nem no codigo
+
+Comandos essenciais:
+- resumo compacto por capacidade: \`sema resumo <arquivo-ou-pasta> [--micro|--curto|--medio] [--para <resumo|onboarding|review|mudanca|bug|arquitetura>]\`
+- prompt curto para IA fraca: \`sema prompt-curto <arquivo-ou-pasta> [--micro|--curto|--medio] [--para <resumo|onboarding|review|mudanca|bug|arquitetura>]\`
+- descoberta do projeto: \`sema inspecionar [arquivo-ou-pasta] --json\`
+- auditoria do contrato vivo: \`sema drift <arquivo-ou-pasta> [--escopo <arquivo|modulo|projeto>] [--json]\`
+- mapa de impacto: \`sema impacto <arquivo-ou-pasta> --alvo <token> [--mudanca <descricao>] [--json]\`
+- renomeacao assistida: \`sema renomear-semantico <arquivo-ou-pasta> --de <nome-atual> --para <nome-novo> [--json]\`
+- contexto completo do modulo: \`sema contexto-ia <arquivo.sema>\`
+- estrutura sintatica: \`sema ast <arquivo.sema> --json\`
+- estrutura semantica: \`sema ir <arquivo.sema> --json\`
+- validacao: \`sema validar <arquivo.sema> --json\`
+- diagnosticos: \`sema diagnosticos <arquivo.sema> --json\`
+- formatacao: \`sema formatar <arquivo.sema>\`
+- importacao assistida de legado: \`sema importar <nestjs|fastapi|flask|nextjs|nextjs-consumer|react-vite-consumer|angular-consumer|flutter-consumer|firebase|dotnet|java|go|rust|cpp|typescript|python|dart> <diretorio> --saida <diretorio>\`
+- exemplos oficiais no projeto: \`sema instalar-exemplos\`
+- geracao de codigo: \`sema compilar <arquivo-ou-pasta> --alvo <typescript|python|dart|lua> --saida <diretorio>\`
+- verificacao final: \`sema verificar <arquivo-ou-pasta> [--json]\`
+
+Antes de editar:
+1. leia README, docs de IA e um exemplo oficial parecido
+2. se a IA for fraca, rode \`sema resumo <arquivo> --micro\` e leia \`briefing.min.json\`
+   - se timeout local estourar, aumente o timeout e tente de novo; timeout nao significa Sema inativo
+3. se a IA aguentar mais, rode \`sema drift\` para medir impls, vinculos, rotas, score e lacunas
+4. se a tarefa for pesada, rode \`sema contexto-ia\` e leia \`briefing.json\`
+5. consulte AST e IR do modulo alvo so quando a capacidade realmente aguentar
+
+Depois de editar:
+1. rode \`sema formatar\`
+2. rode \`sema validar --json\`
+3. se houver falha, use \`diagnosticos --json\`
+4. rode \`sema drift\` de novo quando mexer em codigo vivo
+5. se a tarefa pedir codigo derivado, rode \`sema compilar\`
+6. feche com \`sema verificar <arquivo-ou-pasta> --json\`
+
+Priorize sempre:
+- exemplos oficiais
+- JSON da CLI
+- o menor artefato que resolva a tarefa da IA atual
+- score, confianca e lacunas do \`drift\`
+- \`briefing.json\` como guia de mudanca
+- consistencia semantica
+
+Superficies que a IA deve enxergar como first-class:
+- \`route\`
+- \`worker\`
+- \`evento\`
+- \`fila\`
+- \`cron\`
+- \`webhook\`
+- \`cache\`
+- \`storage\`
+- \`policy\`
+
+Nao improvise quando faltar contexto.
+`;
+export const PROMPT_BASE_IA = `Voce esta trabalhando com Sema, um contrato semantico IA-first para agentes operarem software vivo.
+
+Trate a Sema como protocolo de governanca semantica e linguagem de intencao feita para IA, nao para leitura humana confortavel. Humanos escrevem e aprovam; agentes consomem. Nao invente sintaxe, palavras-chave ou blocos fora da gramatica e dos exemplos oficiais.
+
+Fontes de verdade, em ordem:
+1. se o projeto expuser \`SEMA_CONTEXT.md\`, comece por ele
+2. \`AGENT_CONTEXT_PACK.json\`
+3. \`SEMA_BRIEF.md\`
+4. \`SEMA_INDEX.json\`
+5. \`AGENTS.md\`
+6. README do projeto
+7. gramatica e documentacao de sintaxe da Sema
+8. exemplos oficiais, com prioridade para o vertical de pagamento
+9. \`sema resumo\` e \`briefing.min.json\` quando a IA for fraca
+10. AST, IR e diagnosticos exportados pela CLI em JSON quando a capacidade aguentar
+
+Regras de operacao:
+- contrato vem antes da acao: crie, edite ou remova o .sema aplicavel antes de codigo, docs operacionais, texto Author, workflow, jogo, pesquisa, legal ou ops
+- preserve o significado semantico
+- use o formatador oficial da Sema como fonte unica de estilo
+- use diagnosticos estruturados como contrato de correcao
+- use a IR como fonte de verdade semantica quando houver duvida
+- use predicados canonicos como normalizacao opcional, preservando a forma original
+- nao conclua uma alteracao sem validar e verificar o modulo
+- comece pelo menor artefato semantico que resolva a tarefa
+
+Antes de editar \`.sema\`, entenda:
+- o module alvo
+- os contratos de task, route, error, effects, guarantees, state e flow
+- os exemplos oficiais relacionados
+
+Depois de editar \`.sema\`, execute este fluxo:
+1. formatar
+2. validar
+3. diagnosticar, se houver falha
+4. verificar
+
+Se houver conflito entre texto livre e IR/diagnosticos, priorize a IR e os diagnosticos da CLI.
+
+Se algo nao estiver claro, siga a forma ja usada nos exemplos oficiais. Nao improvise sem base.
+`;
+export const PROMPT_IA_UI = `Atue como Engenheiro de Software Senior e UX/UI Designer de elite.
+
+Quero que voce trabalhe com Sema como fonte de verdade semantica do sistema e com React + TypeScript como camada de interface.
+
+Entregue obrigatoriamente duas partes integradas:
+1. os arquivos \`.sema\` do dominio
+2. a proposta ou implementacao da interface em React + TypeScript
+
+Regras:
+- nao entregue apenas HTML solto em arquivo unico
+- nao trate a Sema como enfeite conceitual
+- a interface deve nascer do contrato semantico definido em Sema
+- use os exemplos oficiais da Sema como referencia de estilo e semantica
+- nao invente sintaxe fora da gramatica suportada
+
+A Sema deve modelar, quando fizer sentido:
+- \`module\`
+- \`use\`
+- \`entity\`
+- \`enum\`
+- \`state\`
+- \`task\`
+- \`flow\`
+- \`route\`
+- \`effects\`
+- \`error\`
+- \`guarantees\`
+- \`tests\`
+- \`docs\`
+
+A interface deve refletir visualmente:
+- \`state\` como status e progresso observavel
+- \`flow\` como etapas ou orquestracao visivel
+- \`error\` como falhas tratadas com clareza
+- \`effects\` como operacoes relevantes para usuario ou operacao
+- \`guarantees\` como confianca, confirmacao ou consistencia final
+
+Estruture a entrega assim:
+1. visao do produto
+2. dominio modelado em Sema
+3. arquitetura de pastas em React + TypeScript
+4. componentes principais
+5. estrategia visual
+6. codigo principal da interface
+7. explicacao curta de como a UI conversa com a semantica da Sema
+
+Se a tarefa envolver app visual, a Sema governa o significado e o React renderiza a experiencia. Nao atropele essa separacao.
+`;
+export const PROMPT_IA_REACT = `Crie uma solucao com Sema + React + TypeScript.
+
+Regras principais:
+- a Sema deve ser a fonte de verdade semantica do dominio
+- React + TypeScript deve ser a camada de interface e experiencia
+- nao entregue HTML unico solto
+- nao trate a Sema como enfeite
+
+Entregue obrigatoriamente:
+1. arquivos \`.sema\` do dominio
+2. arquitetura de pastas do frontend
+3. componentes React principais
+4. contratos e tipos derivados da semantica
+5. interface elegante e implementavel
+
+A modelagem Sema deve cobrir, quando fizer sentido:
+- \`entity\`
+- \`enum\`
+- \`state\`
+- \`task\`
+- \`flow\`
+- \`route\`
+- \`effects\`
+- \`error\`
+- \`guarantees\`
+- \`tests\`
+
+A interface React deve tornar visiveis:
+- estado atual e transicoes relevantes
+- fluxo operacional
+- erros publicos
+- efeitos operacionais importantes
+- garantias ou confirmacoes finais
+
+Estruture a entrega assim:
+1. visao do produto
+2. arquivos \`.sema\`
+3. arquitetura React + TypeScript
+4. componentes e telas
+5. codigo principal
+6. explicacao de como a UI deriva da semantica da Sema
+
+Se houver duvida, siga os exemplos oficiais e mantenha a separacao:
+- Sema governa o significado
+- React governa a apresentacao
+`;
+export const PROMPT_IA_SEMA_PRIMEIRO = `Quero que voce trabalhe no modo "Sema primeiro".
+
+Regra principal:
+- modele primeiro o dominio em arquivos \`.sema\`
+- se a intencao mudar, crie, edite ou remova o contrato antes de qualquer acao operacional
+- so depois proponha ou gere codigo de aplicacao derivado disso
+
+Fluxo obrigatorio:
+1. entender o dominio pedido
+2. modelar o contrato em Sema
+3. validar coerencia entre \`task\`, \`route\`, \`state\`, \`flow\`, \`error\`, \`effects\` e \`guarantees\`
+4. so depois gerar TypeScript, Python, React ou outra camada de implementacao
+
+Nao entregue apenas codigo de interface ou codigo imperativo direto sem antes entregar a camada semantica.
+
+A modelagem em Sema deve:
+- preservar a intencao do dominio
+- explicitar entradas, saidas, erros, efeitos e garantias
+- usar apenas blocos e sintaxe oficiais
+- incluir testes embutidos quando fizer sentido
+
+Se houver interface grafica:
+- entregue a modelagem Sema primeiro
+- depois explique como a interface deve refletir a semantica
+- se gerar UI, use React + TypeScript em vez de HTML unico solto
+
+Se houver backend:
+- entregue a modelagem Sema primeiro
+- depois gere a borda publica e a implementacao derivada
+
+Nao pule a etapa semantica. A camada \`.sema\` e a ancora principal da solucao.
+`;
+export const EXEMPLOS_PROMPT_IA = `Exemplos de prompt oficial para trabalhar com Sema
+
+1. Sema primeiro
+
+Crie uma solucao seguindo a estrategia "Sema primeiro".
+Entregue primeiro os arquivos \`.sema\` do dominio e so depois a implementacao derivada.
+Nao entregue apenas codigo imperativo.
+Use Sema como fonte de verdade para contratos, estados, erros, efeitos e garantias.
+
+2. Sema + React + TypeScript
+
+Crie um projeto com Sema + React + TypeScript.
+Entregue:
+- os arquivos \`.sema\` do dominio
+- a arquitetura de pastas do frontend
+- componentes React que reflitam \`state\`, \`flow\`, \`error\`, \`effects\` e \`guarantees\`
+- uma interface elegante e implementavel
+- nao entregue HTML solto em arquivo unico
+
+3. Revisar ou corrigir um modulo Sema
+
+Revise e corrija um modulo \`.sema\`.
+Antes de editar:
+- leia os exemplos oficiais parecidos
+- consulte AST e IR
+Depois de editar:
+- rode \`sema formatar\`
+- rode \`sema validar --json\`
+- use \`diagnosticos --json\` se houver falha
+- feche com \`sema verificar\`
+
+4. Caso de UI sem perder a semantica
+
+Quero uma interface premium para este dominio, mas a solucao deve continuar ancorada em Sema.
+Modele primeiro o dominio em \`.sema\`.
+Depois proponha uma interface em React + TypeScript que torne visiveis:
+- estado
+- fluxo
+- erros
+- efeitos
+- garantias
+Nao transforme isso em um \`index.html\` solto.
+
+Comandos uteis da CLI para esse fluxo:
+- \`sema starter-ia\`
+- \`sema ajuda-ia\`
+- \`sema resumo <arquivo-ou-pasta>\`
+- \`sema prompt-curto <arquivo-ou-pasta>\`
+- \`sema prompt-ia\`
+- \`sema prompt-ia-ui\`
+- \`sema prompt-ia-react\`
+- \`sema prompt-ia-sema-primeiro\`
+- \`sema contexto-ia <arquivo.sema>\`
+`;
+//# sourceMappingURL=iaPrompts.js.map

package/dist/iaPrompts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iaPrompts.js","sourceRoot":"","sources":["../src/iaPrompts.ts"],"names":[],"mappings":"AAAA,gBAAgB;AAChB,2CAA2C;AAC3C,oDAAoD;AACpD,8EAA8E;AAE9E,MAAM,CAAC,MAAM,UAAU,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2FzB,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwC7B,CAAC;AAEF,MAAM,CAAC,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+C3B,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6C9B,CAAC;AAEF,MAAM,CAAC,MAAM,uBAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BtC,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDjC,CAAC"}

package/dist/importador.d.ts

@@ -1,31 +1,9 @@
-import { type Diagnostico } from "@sema/nucleo";
-export type FonteImportacao = "nestjs" | "fastapi" | "flask" | "nextjs" | "nextjs-consumer" | "react-vite-consumer" | "angular-consumer" | "flutter-consumer" | "firebase" | "typescript" | "python" | "dart" | "dotnet" | "java" | "go" | "rust" | "cpp";
-export interface ArquivoImportado {
-    caminhoRelativo: string;
-    conteudo: string;
-    modulo: string;
-    tarefas: number;
-    rotas: number;
-    entidades: number;
-    enums: number;
-    databases: number;
-}
-export interface ResultadoImportacao {
-    fonte: FonteImportacao;
-    diretorio: string;
-    namespaceBase: string;
-    arquivos: ArquivoImportado[];
-    diagnosticos: Diagnostico[];
-}
-export declare function inferirNamespaceBase(diretorio: string, namespaceExplicito?: string): string;
-export declare function importarProjetoLegado(fonte: FonteImportacao, diretorio: string, namespaceBase?: string): Promise<ResultadoImportacao>;
-export declare function resumoImportacao(resultado: ResultadoImportacao): {
-    modulos: number;
-    tarefas: number;
-    rotas: number;
-    entidades: number;
-    enums: number;
-    databases: number;
-    diagnosticos: number;
-    sucesso: boolean;
-};
+export * from "./importador.part01.js";
+export * from "./importador.part02.js";
+export * from "./importador.part03.js";
+export * from "./importador.part04.js";
+export * from "./importador.part05.js";
+export * from "./importador.part06.js";
+export * from "./importador.part07.js";
+export * from "./importador.part08.js";
+export * from "./importador.part09.js";