@semacode/cli 1.5.29 → 1.5.31

package/node_modules/@sema/nucleo/src/ir/modelos.ts

@@ -0,0 +1,403 @@
+import type { Diagnostico } from "../diagnosticos/index.js";
+import type {
+  ContratoErroRouteSemantico,
+  EfeitoSemantico,
+  EtapaFlowSemantica,
+  ExpressaoSemantica,
+  TransicaoEstadoSemantica,
+} from "../semantico/estruturas.js";
+import type {
+  CompatibilidadePersistencia,
+  ConsistenciaPersistencia,
+  DurabilidadePersistencia,
+  EngineBanco,
+  ModeloConsultaPersistencia,
+  ModeloTransacaoPersistencia,
+  StatusCompatibilidadePersistencia,
+  TipoRecursoPersistencia,
+} from "../persistencia/contratos.js";
+import type {
+  ClassificacaoDadoSemantico,
+  ModoAuthSemantico,
+  MotivoAuditSemantico,
+  OrigemAuthSemantica,
+  PrincipalAuthSemantico,
+  RedacaoLogSemantica,
+  TenantAuthzSemantico,
+} from "../semantico/seguranca.js";
+
+export type PerfilCompatibilidade = "publico" | "interno" | "experimental" | "legado" | "deprecado";
+export type StatusResolucaoSemantica = "nao_verificado" | "resolvido" | "parcial" | "inferido" | "quebrado" | "nao_encontrado";
+export type NivelConfiancaSemantica = "alta" | "media" | "baixa";
+export type NivelRiscoSemantico = "baixo" | "medio" | "alto";
+export type TipoSuperficieIr = "worker" | "evento" | "fila" | "cron" | "webhook" | "cache" | "storage" | "policy";
+
+export interface IrCampo {
+  nome: string;
+  tipo: string;
+  modificadores: string[];
+  tipoOriginal: string;
+  tipoBase: string;
+  cardinalidade: "unitario" | "lista" | "mapa" | "uniao";
+  opcional: boolean;
+  tiposAlternativos: string[];
+  tipoItem?: string;
+  chaveMapa?: string;
+  valorMapa?: string;
+  refinamentos: string[];
+}
+
+export interface IrImplementacaoTask {
+  origem: "ts" | "py" | "dart" | "lua" | "cs" | "java" | "go" | "rust" | "cpp";
+  caminho: string;
+  origemArquivo?: string;
+  origemSimbolo?: string;
+  resolucaoImpl?: string;
+  statusImpl?: StatusResolucaoSemantica;
+}
+
+export interface IrVinculo {
+  tipo: string;
+  valor: string;
+  arquivo?: string;
+  simbolo?: string;
+  recurso?: string;
+  superficie?: string;
+  statusResolucao?: StatusResolucaoSemantica;
+  confianca?: NivelConfiancaSemantica;
+}
+
+export interface IrExecucao {
+  idempotencia: boolean;
+  timeout: string;
+  retry: string;
+  compensacao: string;
+  criticidadeOperacional: "baixa" | "media" | "alta" | "critica";
+  explicita: boolean;
+}
+
+export interface IrAuth {
+  explicita: boolean;
+  modo?: ModoAuthSemantico | string;
+  estrategia?: string;
+  principal?: PrincipalAuthSemantico | string;
+  origem?: OrigemAuthSemantica | string;
+}
+
+export interface IrAuthz {
+  explicita: boolean;
+  papeis: string[];
+  escopos: string[];
+  politica?: string;
+  tenant?: TenantAuthzSemantico | string;
+}
+
+export interface IrCampoDadoClassificado {
+  origem: string;
+  campo: string;
+  classificacao: ClassificacaoDadoSemantico | string;
+}
+
+export interface IrDados {
+  explicita: boolean;
+  classificacaoPadrao?: ClassificacaoDadoSemantico | string;
+  redacaoLog?: RedacaoLogSemantica | string;
+  retencao?: string;
+  campos: IrCampoDadoClassificado[];
+}
+
+export interface IrAudit {
+  explicita: boolean;
+  evento?: string;
+  ator?: string;
+  correlacao?: string;
+  retencao?: string;
+  motivo?: MotivoAuditSemantico | string;
+}
+
+export interface IrSegredo {
+  nome: string;
+  origem?: string;
+  escopo?: string;
+  acesso?: string;
+  rotacao?: string;
+  naoLogar?: boolean;
+  naoRetornar?: boolean;
+  mascarar?: boolean;
+}
+
+export interface IrSegredos {
+  explicita: boolean;
+  itens: IrSegredo[];
+}
+
+export interface IrForbidden {
+  explicita: boolean;
+  regras: string[];
+}
+
+export interface IrBlocoDeclarativo {
+  campos: IrCampo[];
+  linhas: string[];
+  blocos: IrBlocoDeclarativoAninhado[];
+}
+
+export interface IrBlocoDeclarativoAninhado {
+  nome: string;
+  conteudo: IrBlocoDeclarativo;
+}
+
+export interface IrCasoTeste {
+  nome: string;
+  given: IrBlocoDeclarativo;
+  when?: IrBlocoDeclarativo;
+  expect: IrBlocoDeclarativo;
+  error?: IrBlocoDeclarativo;
+}
+
+export interface IrResumoAgente {
+  riscos: string[];
+  checks: string[];
+  entidadesAfetadas: string[];
+  superficiesPublicas: string[];
+  mutacoesPrevistas: string[];
+}
+
+export interface IrType {
+  nome: string;
+  definicao: IrBlocoDeclarativo;
+  invariantes: ExpressaoSemantica[];
+}
+
+export interface IrEntity {
+  nome: string;
+  campos: IrCampo[];
+  invariantes: ExpressaoSemantica[];
+}
+
+export interface IrEnum {
+  nome: string;
+  valores: string[];
+}
+
+export interface IrUse {
+  origem: "sema" | "ts" | "py" | "dart" | "lua" | "cs" | "java" | "go" | "rust" | "cpp";
+  caminho: string;
+  externo: boolean;
+}
+
+export interface IrInteropExterno {
+  origem: "ts" | "py" | "dart" | "lua" | "cs" | "java" | "go" | "rust" | "cpp";
+  caminho: string;
+}
+
+export interface IrErroOperacional {
+  codigo: string;
+  mensagem: string;
+  categoria?: string;
+  recuperabilidade?: string;
+  acaoChamador?: string;
+  impactaEstado?: boolean;
+  requerCompensacao?: boolean;
+  origemTask?: string;
+}
+
+export interface IrTask {
+  nome: string;
+  input: IrCampo[];
+  output: IrCampo[];
+  rules: string[];
+  regrasEstruturadas: ExpressaoSemantica[];
+  effects: string[];
+  efeitosEstruturados: EfeitoSemantico[];
+  implementacoesExternas: IrImplementacaoTask[];
+  vinculos: IrVinculo[];
+  execucao: IrExecucao;
+  auth: IrAuth;
+  authz: IrAuthz;
+  dados: IrDados;
+  audit: IrAudit;
+  segredos: IrSegredos;
+  forbidden: IrForbidden;
+  guarantees: string[];
+  garantiasEstruturadas: ExpressaoSemantica[];
+  errors: Record<string, string>;
+  errosDetalhados: IrErroOperacional[];
+  perfilCompatibilidade: PerfilCompatibilidade;
+  stateContract?: IrTaskStateContract;
+  resumoAgente: IrResumoAgente;
+  tests: IrCasoTeste[];
+}
+
+export interface IrErroPublico extends IrErroOperacional {
+  nome: string;
+}
+
+export interface IrRoutePublica {
+  metodo?: string;
+  caminho?: string;
+  task?: string;
+  input: IrCampo[];
+  output: IrCampo[];
+  errors: IrErroPublico[];
+  effects: EfeitoSemantico[];
+  garantiasMinimas: string[];
+  confiancaContrato?: NivelConfiancaSemantica;
+  riscoRegressao?: NivelRiscoSemantico;
+  divergenciasPublicas?: string[];
+}
+
+export interface IrTaskStateContract {
+  nomeEstado?: string;
+  campos: IrCampo[];
+  linhas: string[];
+  transicoes: TransicaoEstadoSemantica[];
+}
+
+export interface IrFlow {
+  nome: string;
+  campos: IrCampo[];
+  linhas: string[];
+  tasksReferenciadas: string[];
+  etapasEstruturadas: EtapaFlowSemantica[];
+  effects: string[];
+  efeitosEstruturados: EfeitoSemantico[];
+  vinculos: IrVinculo[];
+  perfilCompatibilidade: PerfilCompatibilidade;
+  resumoAgente: IrResumoAgente;
+}
+
+export interface IrRoute {
+  nome: string;
+  campos: IrCampo[];
+  linhas: string[];
+  metodo?: string;
+  caminho?: string;
+  task?: string;
+  inputPublico: IrCampo[];
+  outputPublico: IrCampo[];
+  errosPublicos: ContratoErroRouteSemantico[];
+  efeitosPublicos: EfeitoSemantico[];
+  vinculos: IrVinculo[];
+  auth: IrAuth;
+  authz: IrAuthz;
+  dados: IrDados;
+  audit: IrAudit;
+  segredos: IrSegredos;
+  forbidden: IrForbidden;
+  perfilCompatibilidade: PerfilCompatibilidade;
+  garantiasPublicasMinimas: string[];
+  resumoAgente: IrResumoAgente;
+  publico: IrRoutePublica;
+}
+
+export interface IrSuperficie {
+  tipo: TipoSuperficieIr;
+  nome: string;
+  campos: IrCampo[];
+  linhas: string[];
+  task?: string;
+  input: IrCampo[];
+  output: IrCampo[];
+  effects: EfeitoSemantico[];
+  implementacoesExternas: IrImplementacaoTask[];
+  vinculos: IrVinculo[];
+  execucao: IrExecucao;
+  auth: IrAuth;
+  authz: IrAuthz;
+  dados: IrDados;
+  audit: IrAudit;
+  segredos: IrSegredos;
+  forbidden: IrForbidden;
+  perfilCompatibilidade: PerfilCompatibilidade;
+  resumoAgente: IrResumoAgente;
+}
+
+export interface IrState {
+  nome?: string;
+  campos: IrCampo[];
+  linhas: string[];
+  invariantes: ExpressaoSemantica[];
+  transicoes: TransicaoEstadoSemantica[];
+}
+
+export interface IrCompatibilidadePersistencia extends CompatibilidadePersistencia {
+  engine: EngineBanco;
+  status: StatusCompatibilidadePersistencia;
+}
+
+export interface IrRecursoPersistencia {
+  nome: string;
+  resourceKind: TipoRecursoPersistencia;
+  entity?: string;
+  collection?: string;
+  table?: string;
+  consistency?: ConsistenciaPersistencia | string;
+  durability?: DurabilidadePersistencia | string;
+  transactionModel?: ModeloTransacaoPersistencia | string;
+  queryModel?: ModeloConsultaPersistencia | string;
+  mode?: string;
+  isolation?: string;
+  strategy?: string;
+  ttl?: string;
+  retention?: string;
+  path?: string;
+  from?: string;
+  to?: string;
+  surface?: string;
+  adapter?: string;
+  portavel?: boolean;
+  capabilities: string[];
+  operations: string[];
+  indexing: string[];
+  guarantees: string[];
+  diagnostics: string[];
+  risks: string[];
+  fields: IrCampo[];
+  lines: string[];
+  block: IrBlocoDeclarativo;
+  compatibilidade: IrCompatibilidadePersistencia[];
+}
+
+export interface IrBancoDados {
+  nome: string;
+  engine?: EngineBanco;
+  schema?: string;
+  database?: string;
+  consistency?: ConsistenciaPersistencia | string;
+  durability?: DurabilidadePersistencia | string;
+  transactionModel?: ModeloTransacaoPersistencia | string;
+  queryModel?: ModeloConsultaPersistencia | string;
+  portavel?: boolean;
+  adapter?: string;
+  capabilities: string[];
+  operations: string[];
+  indexing: string[];
+  guarantees: string[];
+  diagnostics: string[];
+  risks: string[];
+  fields: IrCampo[];
+  lines: string[];
+  block: IrBlocoDeclarativo;
+  resources: IrRecursoPersistencia[];
+}
+
+export interface IrModulo {
+  nome: string;
+  uses: string[];
+  imports: IrUse[];
+  interoperabilidades: IrInteropExterno[];
+  vinculos: IrVinculo[];
+  perfilCompatibilidade: PerfilCompatibilidade;
+  types: IrType[];
+  entities: IrEntity[];
+  enums: IrEnum[];
+  tasks: IrTask[];
+  flows: IrFlow[];
+  routes: IrRoute[];
+  superficies: IrSuperficie[];
+  states: IrState[];
+  databases: IrBancoDados[];
+  resumoAgente: IrResumoAgente;
+  diagnosticos: Diagnostico[];
+}

package/node_modules/@sema/nucleo/src/lexer/lexer.ts

@@ -0,0 +1,166 @@
+import { criarDiagnostico, type Diagnostico, type PosicaoFonte } from "../diagnosticos/index.js";
+import { PALAVRAS_CHAVE, type Token, type TipoToken } from "./tokens.js";
+
+export interface ResultadoLexer {
+  tokens: Token[];
+  diagnosticos: Diagnostico[];
+}
+
+function avancar(posicao: PosicaoFonte, caractere: string): PosicaoFonte {
+  if (caractere === "\n") {
+    return { indice: posicao.indice + 1, linha: posicao.linha + 1, coluna: 1 };
+  }
+  return { indice: posicao.indice + 1, linha: posicao.linha, coluna: posicao.coluna + 1 };
+}
+
+function criarToken(tipo: TipoToken, valor: string, inicio: PosicaoFonte, fim: PosicaoFonte, arquivo?: string): Token {
+  return {
+    tipo,
+    valor,
+    intervalo: { inicio, fim, arquivo },
+  };
+}
+
+export function tokenizar(codigo: string, arquivo?: string): ResultadoLexer {
+  const tokens: Token[] = [];
+  const diagnosticos: Diagnostico[] = [];
+  let posicao: PosicaoFonte = { indice: 0, linha: 1, coluna: 1 };
+
+  while (posicao.indice < codigo.length) {
+    const inicio = { ...posicao };
+    const atual = codigo[posicao.indice]!;
+
+    if (atual === " " || atual === "\t" || atual === "\r") {
+      posicao = avancar(posicao, atual);
+      continue;
+    }
+
+    if (atual === "\n") {
+      posicao = avancar(posicao, atual);
+      tokens.push(criarToken("nova_linha", "\n", inicio, { ...posicao }, arquivo));
+      continue;
+    }
+
+    if (atual === "/" && codigo[posicao.indice + 1] === "/") {
+      let texto = "";
+      let cursor = { ...posicao };
+      while (cursor.indice < codigo.length && codigo[cursor.indice] !== "\n") {
+        texto += codigo[cursor.indice];
+        cursor = avancar(cursor, codigo[cursor.indice]!);
+      }
+      tokens.push(criarToken("comentario", texto, inicio, cursor, arquivo));
+      posicao = cursor;
+      continue;
+    }
+
+    if (atual === "\"") {
+      let texto = "";
+      let cursor = avancar(posicao, atual);
+      let fechado = false;
+      while (cursor.indice < codigo.length) {
+        const caractere = codigo[cursor.indice]!;
+        if (caractere === "\\") {
+          const proximo = codigo[cursor.indice + 1];
+          if (proximo) {
+            texto += caractere + proximo;
+            cursor = avancar(avancar(cursor, caractere), proximo);
+            continue;
+          }
+        }
+        if (caractere === "\"") {
+          fechado = true;
+          cursor = avancar(cursor, caractere);
+          break;
+        }
+        texto += caractere;
+        cursor = avancar(cursor, caractere);
+      }
+      if (!fechado) {
+        diagnosticos.push(
+          criarDiagnostico(
+            "LEX001",
+            "Texto nao foi fechado com aspas.",
+            "erro",
+            { inicio, fim: cursor, arquivo },
+            "Feche a string com aspas duplas.",
+          ),
+        );
+        posicao = cursor;
+        continue;
+      }
+      tokens.push(criarToken("texto", texto, inicio, cursor, arquivo));
+      posicao = cursor;
+      continue;
+    }
+
+    if (/[0-9]/.test(atual)) {
+      let texto = "";
+      let cursor = { ...posicao };
+      while (cursor.indice < codigo.length && /[0-9.]/.test(codigo[cursor.indice]!)) {
+        texto += codigo[cursor.indice];
+        cursor = avancar(cursor, codigo[cursor.indice]!);
+      }
+      tokens.push(criarToken("numero", texto, inicio, cursor, arquivo));
+      posicao = cursor;
+      continue;
+    }
+
+    if (/[A-Za-z_]/.test(atual)) {
+      let texto = "";
+      let cursor = { ...posicao };
+      while (cursor.indice < codigo.length && /[A-Za-z0-9_.-]/.test(codigo[cursor.indice]!)) {
+        texto += codigo[cursor.indice];
+        cursor = avancar(cursor, codigo[cursor.indice]!);
+      }
+      const tipo: TipoToken = PALAVRAS_CHAVE.has(texto) ? "palavra_chave" : "identificador";
+      tokens.push(criarToken(tipo, texto, inicio, cursor, arquivo));
+      posicao = cursor;
+      continue;
+    }
+
+    const doisCaracteres = codigo.slice(posicao.indice, posicao.indice + 2);
+    if (["==", "!=", ">=", "<=", "->"].includes(doisCaracteres)) {
+      const cursor = avancar(avancar(posicao, doisCaracteres[0]!), doisCaracteres[1]!);
+      tokens.push(criarToken("operador", doisCaracteres, inicio, cursor, arquivo));
+      posicao = cursor;
+      continue;
+    }
+
+    if ("{}[]():,.".includes(atual)) {
+      const cursor = avancar(posicao, atual);
+      tokens.push(criarToken("pontuacao", atual, inicio, cursor, arquivo));
+      posicao = cursor;
+      continue;
+    }
+
+    if ("=><+-*/|?".includes(atual)) {
+      const cursor = avancar(posicao, atual);
+      tokens.push(criarToken("operador", atual, inicio, cursor, arquivo));
+      posicao = cursor;
+      continue;
+    }
+
+    diagnosticos.push(
+      criarDiagnostico(
+        "LEX002",
+        `Caractere inesperado encontrado: "${atual}".`,
+        "erro",
+        { inicio, fim: avancar(posicao, atual), arquivo },
+        "Remova o caractere ou adicione suporte no lexer.",
+      ),
+    );
+    posicao = avancar(posicao, atual);
+  }
+
+  tokens.push(
+    criarToken(
+      "fim_arquivo",
+      "",
+      { ...posicao },
+      { ...posicao },
+      arquivo,
+    ),
+  );
+
+  return { tokens, diagnosticos };
+}

package/node_modules/@sema/nucleo/src/lexer/tokens.ts

@@ -0,0 +1,79 @@
+import type { IntervaloFonte } from "../diagnosticos/index.js";
+
+export type TipoToken =
+  | "palavra_chave"
+  | "identificador"
+  | "texto"
+  | "numero"
+  | "pontuacao"
+  | "operador"
+  | "nova_linha"
+  | "comentario"
+  | "fim_arquivo";
+
+export interface Token {
+  tipo: TipoToken;
+  valor: string;
+  intervalo: IntervaloFonte;
+}
+
+export const PALAVRAS_CHAVE = new Set([
+  "module",
+  "use",
+  "database",
+  "type",
+  "entity",
+  "enum",
+  "task",
+  "worker",
+  "evento",
+  "fila",
+  "cron",
+  "webhook",
+  "cache",
+  "storage",
+  "policy",
+  "input",
+  "output",
+  "rules",
+  "effects",
+  "impl",
+  "vinculos",
+  "execucao",
+  "auth",
+  "authz",
+  "dados",
+  "audit",
+  "segredos",
+  "forbidden",
+  "guarantees",
+  "state",
+  "flow",
+  "route",
+  "tests",
+  "error",
+  "docs",
+  "comments",
+  "table",
+  "view",
+  "query",
+  "transaction",
+  "index",
+  "constraint",
+  "relationship",
+  "collection",
+  "document",
+  "keyspace",
+  "stream",
+  "lock",
+  "retention",
+  "replication",
+  "fields",
+  "invariants",
+  "transitions",
+  "given",
+  "when",
+  "expect",
+  "caso",
+  "required",
+]);

package/node_modules/@sema/nucleo/src/parser/gramatica.ebnf

@@ -0,0 +1,41 @@
+arquivo             = modulo ;
+modulo              = "module" identificador "{" declaracao_modulo* "}" ;
+declaracao_modulo   = use | docs | comments | vinculos | database | type | entity | enum | task | flow | route | worker | evento | fila | cron | webhook | cache | storage | policy | state | tests ;
+use                 = "use" identificador ;
+database            = "database" identificador bloco_generico ;
+type                = "type" identificador bloco_generico ;
+entity              = "entity" identificador bloco_generico ;
+enum                = "enum" identificador "{" identificador ("," identificador)* "}" ;
+task                = "task" identificador bloco_generico ;
+flow                = "flow" identificador bloco_generico ;
+route               = "route" identificador bloco_generico ;
+worker              = "worker" identificador bloco_generico ;
+evento              = "evento" identificador bloco_generico ;
+fila                = "fila" identificador bloco_generico ;
+cron                = "cron" identificador bloco_generico ;
+webhook             = "webhook" identificador bloco_generico ;
+cache               = "cache" identificador bloco_generico ;
+storage             = "storage" identificador bloco_generico ;
+policy              = "policy" identificador bloco_generico ;
+state               = "state" bloco_generico ;
+tests               = "tests" "{" caso* "}" ;
+caso                = "caso" texto "{" given? when? expect? error? docs? comments? "}" ;
+given               = "given" bloco_generico ;
+when                = "when" bloco_generico ;
+expect              = "expect" bloco_generico ;
+error               = "error" bloco_generico ;
+vinculos            = "vinculos" bloco_generico ;
+docs                = "docs" bloco_generico ;
+comments            = "comments" bloco_generico ;
+bloco_generico      = "{" item_bloco* "}" ;
+item_bloco          = campo | linha | bloco_generico_nomeado | bloco_generico_nomeado_livre ;
+bloco_generico_nomeado = palavra_chave "{" item_bloco* "}" ;
+bloco_generico_nomeado_livre = identificador identificador "{" item_bloco* "}" ;
+campo               = identificador ":" valor valor_modificador* ;
+linha               = valor+ ;
+valor               = identificador | numero | texto ;
+valor_modificador   = identificador ;
+identificador       = ? token de identificador ? ;
+numero              = ? token numerico ? ;
+texto               = ? token textual ? ;
+palavra_chave       = "input" | "output" | "rules" | "effects" | "impl" | "vinculos" | "execucao" | "auth" | "authz" | "dados" | "audit" | "segredos" | "forbidden" | "guarantees" | "state" | "fields" | "tests" | "error" | "docs" | "comments" | "given" | "when" | "expect" ;