@semacode/cli 1.5.29 → 1.5.31

package/node_modules/@sema/nucleo/src/diagnosticos/melhorador.ts

@@ -0,0 +1,130 @@
+// Melhoria de mensagens de erro SEM0xx
+// Contrato: cli_melhoria_erros.sema
+
+export interface ErroSemantico {
+  codigo: string;
+  mensagem: string;
+  dica?: string;
+  arquivo?: string;
+  linha?: number;
+  coluna?: number;
+  localizacao?: {
+    arquivo?: string;
+    linha?: number;
+    coluna?: number;
+  };
+}
+
+export interface MensagemMelhorada {
+  mensagemMelhorada: string;
+  snippetCorrecao: string;
+  explicacao: string;
+  documentacaoLink: string;
+  gravidade: "alta" | "media" | "baixa";
+}
+
+const SNIPPETS_CORRECAO: Record<string, (nomeElemento: string) => string> = {
+  SEM094: (nome) => `  auth {
+    modo: obrigatorio  // ou: anonimo, opcional
+  }`,
+  
+  SEM095: (nome) => `  authz {
+    escopo: ${nome.toLowerCase().replace(/_/g, '.')}.executar
+    papeis: [admin, editor]  // ajuste conforme necessario
+  }`,
+  
+  SEM096: (nome) => `  dados {
+    classificacao_padrao: interno  // ou: publico, pii, financeiro, segredo
+    input {
+      campo1: interno
+      campo2: publico
+    }
+    output {
+      resultado: publico
+    }
+  }`,
+  
+  SEM097: (nome) => `  audit {
+    evento: ${nome.toLowerCase().replace(/_/g, '.')}.executado
+    ator: auth.usuario
+    correlacao: request_id
+    retencao: "90d"
+    motivo: obrigatorio
+  }`,
+  
+  SEM071: (nome) => `  execucao {
+    idempotencia: verdadeiro  // ou: falso
+    timeout: "30s"           // ajuste conforme necessidade
+    retry: "ate 3 tentativas com backoff"
+    compensacao: "descricao do rollback"
+    criticidade_operacional: alta  // ou: media, baixa
+  }`,
+  
+  SEM072: (nome) => `  impl {
+    ts: pacote.src.modulo.${nome}  // ajuste o caminho
+  }
+  vinculos {
+    arquivo: "src/modulo/arquivo.ts"
+    simbolo: pacote.src.modulo.${nome}
+  }`
+};
+
+const EXPLICACOES: Record<string, string> = {
+  SEM094: "O bloco auth define se a task/route requer autenticacao. Isso e obrigatorio para endpoints publicos.",
+  SEM095: "O bloco authz define quem pode acessar (escopos, papeis). Sem isso, a autorizacao fica ambigua.",
+  SEM096: "O bloco dados classifica a sensibilidade dos dados (PII, financeiro, etc) para compliance.",
+  SEM097: "O bloco audit cria trilha de auditoria para rastrear quem fez o que e quando.",
+  SEM071: "O bloco execucao define timeout, retry, idempotencia - essencial para producao.",
+  SEM072: "Os vinculos ligam o contrato ao codigo real (arquivo, simbolo), permitindo drift detection."
+};
+
+export function melhorarMensagemErro(
+  erroOriginal: ErroSemantico,
+  nomeElemento: string,
+  tipoElemento: string
+): MensagemMelhorada {
+  const codigo = erroOriginal.codigo;
+  
+  // Gerar snippet de correcao
+  const geradorSnippet = SNIPPETS_CORRECAO[codigo];
+  const snippet = geradorSnippet ? geradorSnippet(nomeElemento) : "// Consulte a documentacao para corrigir";
+  
+  // Construir mensagem melhorada
+  let mensagemMelhorada = erroOriginal.mensagem;
+  
+  if (codigo === "SEM094") {
+    mensagemMelhorada = `Task/Route "${nomeElemento}" exposta publicamente nao declara auth { ... }.\n\nAdicione o bloco auth para definir se requer autenticacao:`;
+  } else if (codigo === "SEM095") {
+    mensagemMelhorada = `Task/Route "${nomeElemento}" exposta publicamente nao declara authz { ... }.\n\nAdicione o bloco authz para definir permissoes:`;
+  } else if (codigo === "SEM096") {
+    mensagemMelhorada = `Task/Route "${nomeElemento}" nao classifica dados em dados { ... }.\n\nAdicione classificacao para compliance:`;
+  } else if (codigo === "SEM097") {
+    mensagemMelhorada = `Task/Route "${nomeElemento}" nao declara audit { ... }.\n\nAdicione trilha de auditoria:`;
+  } else if (codigo === "SEM071") {
+    mensagemMelhorada = `Task "${nomeElemento}" exposta publicamente requer execucao { ... } explicita.\n\nAdicione configuracao de execucao:`;
+  } else if (codigo === "SEM072") {
+    mensagemMelhorada = `Task "${nomeElemento}" exposta publicamente requer impl/vinculos { ... }.\n\nAdicione rastreabilidade ao codigo:`;
+  }
+  
+  return {
+    mensagemMelhorada,
+    snippetCorrecao: snippet,
+    explicacao: EXPLICACOES[codigo] || erroOriginal.dica || "Consulte a documentacao.",
+    documentacaoLink: `https://sema.otimitare.online/docs/erros/${codigo}`,
+    gravidade: codigo.startsWith("SEM09") ? "alta" : "media"
+  };
+}
+
+export function formatarErroMelhorado(erro: ErroSemantico, mensagemMelhorada: MensagemMelhorada): string {
+  return `
+❌ ${erro.codigo}: ${mensagemMelhorada.mensagemMelhorada}
+
+📝 Snippet de correcao:
+${mensagemMelhorada.snippetCorrecao}
+
+💡 ${mensagemMelhorada.explicacao}
+
+📖 Documentacao: ${mensagemMelhorada.documentacaoLink}
+📍 ${erro.localizacao?.arquivo ?? erro.arquivo}:${erro.localizacao?.linha ?? erro.linha}:${erro.localizacao?.coluna ?? erro.coluna}
+`;
+}

package/node_modules/@sema/nucleo/src/formatador/index.ts

@@ -0,0 +1,530 @@
+import type {
+  BlocoAst,
+  BlocoCasoTesteAst,
+  BlocoGenericoAst,
+  CampoAst,
+  EntityAst,
+  EnumAst,
+  FlowAst,
+  ModuloAst,
+  RouteAst,
+  StateAst,
+  TaskAst,
+  TypeAst,
+  UseAst,
+} from "../ast/tipos.js";
+import type { Diagnostico } from "../diagnosticos/index.js";
+import { parsear } from "../parser/parser.js";
+import { tokenizar } from "../lexer/lexer.js";
+
+const ORDEM_BLOCOS_MODULO = new Map<string, number>([
+  ["docs", 0],
+  ["comments", 1],
+  ["use", 2],
+  ["vinculos", 3],
+  ["database", 4],
+  ["type", 5],
+  ["entity", 6],
+  ["enum", 7],
+  ["state", 8],
+  ["task", 9],
+  ["flow", 10],
+  ["route", 11],
+  ["worker", 12],
+  ["evento", 13],
+  ["fila", 14],
+  ["cron", 15],
+  ["webhook", 16],
+  ["cache", 17],
+  ["storage", 18],
+  ["policy", 19],
+  ["tests", 20],
+  ["desconhecido", 21],
+]);
+
+const ORDEM_SUBBLOCOS_TASK = new Map<string, number>([
+  ["docs", 0],
+  ["comments", 1],
+  ["input", 2],
+  ["output", 3],
+  ["rules", 4],
+  ["effects", 5],
+  ["auth", 6],
+  ["authz", 7],
+  ["dados", 8],
+  ["audit", 9],
+  ["segredos", 10],
+  ["forbidden", 11],
+  ["impl", 12],
+  ["vinculos", 13],
+  ["execucao", 14],
+  ["state", 15],
+  ["guarantees", 16],
+  ["error", 17],
+  ["tests", 18],
+  ["desconhecido", 19],
+]);
+
+const ORDEM_SUBBLOCOS_ROUTE = new Map<string, number>([
+  ["input", 0],
+  ["output", 1],
+  ["effects", 2],
+  ["auth", 3],
+  ["authz", 4],
+  ["dados", 5],
+  ["audit", 6],
+  ["segredos", 7],
+  ["forbidden", 8],
+  ["vinculos", 9],
+  ["error", 10],
+  ["docs", 11],
+  ["comments", 12],
+  ["desconhecido", 13],
+]);
+
+const ORDEM_SUBBLOCOS_FLOW = new Map<string, number>([
+  ["effects", 0],
+  ["vinculos", 1],
+  ["docs", 2],
+  ["comments", 3],
+  ["desconhecido", 4],
+]);
+
+const ORDEM_SUBBLOCOS_SUPERFICIE = new Map<string, number>([
+  ["input", 0],
+  ["output", 1],
+  ["effects", 2],
+  ["auth", 3],
+  ["authz", 4],
+  ["dados", 5],
+  ["audit", 6],
+  ["segredos", 7],
+  ["forbidden", 8],
+  ["impl", 9],
+  ["vinculos", 10],
+  ["execucao", 11],
+  ["error", 12],
+  ["docs", 13],
+  ["comments", 14],
+  ["desconhecido", 15],
+]);
+
+const ORDEM_SUBBLOCOS_STATE = new Map<string, number>([
+  ["fields", 0],
+  ["invariants", 1],
+  ["transitions", 2],
+  ["docs", 3],
+  ["comments", 4],
+  ["desconhecido", 5],
+]);
+
+const ORDEM_SUBBLOCOS_TESTE = new Map<string, number>([
+  ["given", 0],
+  ["when", 1],
+  ["expect", 2],
+  ["error", 3],
+  ["docs", 4],
+  ["comments", 5],
+  ["desconhecido", 6],
+]);
+
+const ORDEM_CAMPOS_POR_BLOCO = new Map<string, Map<string, number>>([
+  ["vinculos", new Map<string, number>([
+    ["arquivo", 0],
+    ["simbolo", 1],
+    ["rota", 2],
+    ["superficie", 3],
+    ["recurso", 4],
+    ["tabela", 5],
+    ["fila", 6],
+    ["worker", 7],
+    ["evento", 8],
+    ["cron", 9],
+    ["webhook", 10],
+    ["cache", 11],
+    ["storage", 12],
+    ["policy", 13],
+    ["teste", 14],
+  ])],
+  ["execucao", new Map<string, number>([
+    ["idempotencia", 0],
+    ["timeout", 1],
+    ["retry", 2],
+    ["compensacao", 3],
+    ["criticidade_operacional", 4],
+  ])],
+  ["auth", new Map<string, number>([
+    ["modo", 0],
+    ["estrategia", 1],
+    ["principal", 2],
+    ["origem", 3],
+  ])],
+  ["authz", new Map<string, number>([
+    ["papeis", 0],
+    ["papel", 1],
+    ["escopos", 2],
+    ["escopo", 3],
+    ["politica", 4],
+    ["tenant", 5],
+  ])],
+  ["dados", new Map<string, number>([
+    ["classificacao_padrao", 0],
+    ["redacao_log", 1],
+    ["retencao", 2],
+  ])],
+  ["audit", new Map<string, number>([
+    ["evento", 0],
+    ["ator", 1],
+    ["correlacao", 2],
+    ["retencao", 3],
+    ["motivo", 4],
+  ])],
+  ["database", new Map<string, number>([
+    ["engine", 0],
+    ["schema", 1],
+    ["database", 2],
+    ["consistency", 3],
+    ["durability", 4],
+    ["transaction_model", 5],
+    ["query_model", 6],
+    ["portavel", 7],
+    ["adapter", 8],
+  ])],
+]);
+
+export interface ResultadoFormatacao {
+  modulo?: ModuloAst;
+  codigoFormatado?: string;
+  diagnosticos: Diagnostico[];
+  alterado: boolean;
+}
+
+function indentacao(nivel: number): string {
+  return "  ".repeat(nivel);
+}
+
+function ordenarPorMapa<T>(itens: T[], extrairChave: (item: T) => string, ordem: Map<string, number>): T[] {
+  return [...itens].sort((a, b) => {
+    const ordemA = ordem.get(extrairChave(a)) ?? Number.MAX_SAFE_INTEGER;
+    const ordemB = ordem.get(extrairChave(b)) ?? Number.MAX_SAFE_INTEGER;
+    if (ordemA !== ordemB) {
+      return ordemA - ordemB;
+    }
+    return extrairChave(a).localeCompare(extrairChave(b), "pt-BR");
+  });
+}
+
+function normalizarEspacos(texto: string): string {
+  const marcadorSeta = "__SEMA_SETA__";
+  const marcadorMaiorIgual = "__SEMA_MAIOR_IGUAL__";
+  const marcadorMenorIgual = "__SEMA_MENOR_IGUAL__";
+  const marcadorIgual = "__SEMA_IGUAL__";
+  const marcadorDiferente = "__SEMA_DIFERENTE__";
+  return texto
+    .trim()
+    .replace(/\s*->\s*/g, ` ${marcadorSeta} `)
+    .replace(/\s*-\s*>\s*/g, ` ${marcadorSeta} `)
+    .replace(/\s+/g, " ")
+    .replace(/\s*,\s*/g, ", ")
+    .replace(/\(\s+/g, "(")
+    .replace(/\s+\)/g, ")")
+    .replace(/\[\s+/g, "[")
+    .replace(/\s+\]/g, "]")
+    .replace(/\s*>=\s*/g, ` ${marcadorMaiorIgual} `)
+    .replace(/\s*<=\s*/g, ` ${marcadorMenorIgual} `)
+    .replace(/\s*==\s*/g, ` ${marcadorIgual} `)
+    .replace(/\s*!=\s*/g, ` ${marcadorDiferente} `)
+    .replace(/\s*>\s*/g, " > ")
+    .replace(/\s*<\s*/g, " < ")
+    .replace(new RegExp(`\\s*${marcadorMaiorIgual}\\s*`, "g"), " >= ")
+    .replace(new RegExp(`\\s*${marcadorMenorIgual}\\s*`, "g"), " <= ")
+    .replace(new RegExp(`\\s*${marcadorIgual}\\s*`, "g"), " == ")
+    .replace(new RegExp(`\\s*${marcadorDiferente}\\s*`, "g"), " != ")
+    .replace(new RegExp(`\\s*${marcadorSeta}\\s*`, "g"), " -> ");
+}
+
+function normalizarCaminho(texto: string): string {
+  return texto
+    .trim()
+    .replace(/\s*\/\s*/g, "/")
+    .replace(/\s+/g, "");
+}
+
+function eLiteralEscalar(texto: string): boolean {
+  const normalizado = texto.trim();
+  return /^-?\d+(?:\.\d+)?$/.test(normalizado) || ["verdadeiro", "falso", "nulo"].includes(normalizado);
+}
+
+function deveColocarAspas(contexto: string, campo: CampoAst, combinado: string): boolean {
+  if (campo.nome === "metodo") {
+    return false;
+  }
+  if (campo.nome === "caminho") {
+    return /[{}]/.test(combinado);
+  }
+  if (contexto === "vinculos" && ["arquivo", "webhook"].includes(campo.nome)) {
+    return true;
+  }
+  if (["timeout", "retry", "compensacao", "retencao", "rotacao"].includes(campo.nome)) {
+    return true;
+  }
+  if (contexto === "docs" || contexto === "comments") {
+    return true;
+  }
+  if (contexto === "error") {
+    return !eLiteralEscalar(combinado);
+  }
+  if (contexto === "given" || contexto === "when" || contexto === "expect") {
+    return !eLiteralEscalar(combinado);
+  }
+  return false;
+}
+
+function normalizarValorCampo(campo: CampoAst): string {
+  return [campo.valor, ...campo.modificadores]
+    .filter(Boolean)
+    .join(" ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function ordenarCampos(bloco: BlocoGenericoAst): CampoAst[] {
+  const ordem = ORDEM_CAMPOS_POR_BLOCO.get(bloco.palavraChave);
+  if (!ordem) {
+    return bloco.campos;
+  }
+  return ordenarPorMapa(bloco.campos, (campo) => campo.nome, ordem);
+}
+
+function renderizarCampo(campo: CampoAst, nivel: number, contexto: string): string {
+  let combinado = normalizarValorCampo(campo);
+
+  if (campo.nome === "caminho") {
+    combinado = normalizarCaminho(combinado);
+  }
+
+  if (deveColocarAspas(contexto, campo, combinado)) {
+    combinado = JSON.stringify(combinado);
+  }
+
+  return `${indentacao(nivel)}${campo.nome}: ${combinado}`;
+}
+
+function renderizarLinha(linha: string, nivel: number): string {
+  return `${indentacao(nivel)}${normalizarEspacos(linha)}`;
+}
+
+function renderizarCasoTeste(caso: BlocoCasoTesteAst, nivel: number): string {
+  const partes: string[] = [];
+  if (caso.given) {
+    partes.push(renderizarBlocoGenerico(caso.given, nivel + 1));
+  }
+  if (caso.when) {
+    partes.push(renderizarBlocoGenerico(caso.when, nivel + 1));
+  }
+  if (caso.expect) {
+    partes.push(renderizarBlocoGenerico(caso.expect, nivel + 1));
+  }
+  if (caso.error) {
+    partes.push(renderizarBlocoGenerico(caso.error, nivel + 1));
+  }
+  if (caso.docs) {
+    partes.push(renderizarBlocoGenerico(caso.docs, nivel + 1));
+  }
+  if (caso.comments) {
+    partes.push(renderizarBlocoGenerico(caso.comments, nivel + 1));
+  }
+
+  return `${indentacao(nivel)}caso ${JSON.stringify(caso.nome)} {\n${partes.join("\n\n")}\n${indentacao(nivel)}}`;
+}
+
+function renderizarBlocoAst(bloco: BlocoAst, nivel: number): string {
+  switch (bloco.tipo) {
+    case "caso_teste":
+      return renderizarCasoTeste(bloco, nivel);
+    case "bloco_generico":
+      return renderizarBlocoGenerico(bloco, nivel);
+    case "use":
+      return `${indentacao(nivel)}use ${bloco.origem === "sema" ? "" : `${bloco.origem} `}${bloco.caminho}`.trimEnd();
+    case "enum":
+      return renderizarEnum(bloco, nivel);
+    case "type":
+      return renderizarTipo(bloco, nivel);
+    case "entity":
+      return renderizarEntity(bloco, nivel);
+    case "task":
+      return renderizarTask(bloco, nivel);
+    case "flow":
+      return renderizarFlow(bloco, nivel);
+    case "route":
+      return renderizarRoute(bloco, nivel);
+    case "state":
+      return renderizarState(bloco, nivel);
+  }
+}
+
+function ordenarSubblocos(bloco: BlocoGenericoAst): BlocoAst[] {
+  if (bloco.palavraChave === "task") {
+    return ordenarPorMapa(bloco.blocos, (item) => item.tipo === "bloco_generico" ? item.palavraChave : item.tipo, ORDEM_SUBBLOCOS_TASK);
+  }
+  if (bloco.palavraChave === "route") {
+    return ordenarPorMapa(bloco.blocos, (item) => item.tipo === "bloco_generico" ? item.palavraChave : item.tipo, ORDEM_SUBBLOCOS_ROUTE);
+  }
+  if (bloco.palavraChave === "flow") {
+    return ordenarPorMapa(bloco.blocos, (item) => item.tipo === "bloco_generico" ? item.palavraChave : item.tipo, ORDEM_SUBBLOCOS_FLOW);
+  }
+  if (["worker", "evento", "fila", "cron", "webhook", "cache", "storage", "policy"].includes(bloco.palavraChave)) {
+    return ordenarPorMapa(bloco.blocos, (item) => item.tipo === "bloco_generico" ? item.palavraChave : item.tipo, ORDEM_SUBBLOCOS_SUPERFICIE);
+  }
+  if (bloco.palavraChave === "state") {
+    return ordenarPorMapa(bloco.blocos, (item) => item.tipo === "bloco_generico" ? item.palavraChave : item.tipo, ORDEM_SUBBLOCOS_STATE);
+  }
+  if (bloco.palavraChave === "tests") {
+    return ordenarPorMapa(bloco.blocos, (item) => item.tipo === "caso_teste" ? "case" : item.tipo === "bloco_generico" ? item.palavraChave : item.tipo, ORDEM_SUBBLOCOS_TESTE);
+  }
+  return bloco.blocos;
+}
+
+function renderizarBlocoGenerico(bloco: BlocoGenericoAst, nivel: number): string {
+  const identificadorBloco = bloco.palavraChave === "desconhecido" && bloco.nome
+    ? bloco.nome
+    : `${bloco.palavraChave}${bloco.nome ? ` ${bloco.nome}` : ""}`;
+  const cabecalho = `${indentacao(nivel)}${identificadorBloco} {`;
+  const linhasCampos = ordenarCampos(bloco).map((campo) => renderizarCampo(campo, nivel + 1, bloco.palavraChave));
+  const linhasDeclarativas = bloco.linhas.map((linha) => renderizarLinha(linha.conteudo, nivel + 1));
+  const blocosInternos = ordenarSubblocos(bloco).map((subbloco) => renderizarBlocoAst(subbloco, nivel + 1));
+  const corpo = [...linhasCampos, ...linhasDeclarativas, ...blocosInternos];
+  if (corpo.length === 0) {
+    return `${cabecalho}\n${indentacao(nivel)}}`;
+  }
+  return `${cabecalho}\n${corpo.join("\n")}\n${indentacao(nivel)}}`;
+}
+
+function renderizarEnum(enumeracao: EnumAst, nivel: number): string {
+  const corpo = enumeracao.valores.map((valor, indice) => `${indentacao(nivel + 1)}${valor}${indice < enumeracao.valores.length - 1 ? "," : ""}`);
+  return `${indentacao(nivel)}enum ${enumeracao.nome} {\n${corpo.join("\n")}\n${indentacao(nivel)}}`;
+}
+
+function renderizarTipo(type: TypeAst, nivel: number): string {
+  return `${indentacao(nivel)}type ${type.nome} {\n${renderizarCorpoSimples(type.corpo, nivel + 1)}\n${indentacao(nivel)}}`;
+}
+
+function renderizarEntity(entity: EntityAst, nivel: number): string {
+  return `${indentacao(nivel)}entity ${entity.nome} {\n${renderizarCorpoSimples(entity.corpo, nivel + 1)}\n${indentacao(nivel)}}`;
+}
+
+function renderizarTask(task: TaskAst, nivel: number): string {
+  return `${indentacao(nivel)}task ${task.nome} {\n${renderizarCorpoSimples(task.corpo, nivel + 1)}\n${indentacao(nivel)}}`;
+}
+
+function renderizarFlow(flow: FlowAst, nivel: number): string {
+  return `${indentacao(nivel)}flow ${flow.nome} {\n${renderizarCorpoSimples(flow.corpo, nivel + 1)}\n${indentacao(nivel)}}`;
+}
+
+function renderizarRoute(route: RouteAst, nivel: number): string {
+  return `${indentacao(nivel)}route ${route.nome} {\n${renderizarCorpoSimples(route.corpo, nivel + 1)}\n${indentacao(nivel)}}`;
+}
+
+function renderizarState(state: StateAst, nivel: number): string {
+  return `${indentacao(nivel)}state${state.nome ? ` ${state.nome}` : ""} {\n${renderizarCorpoSimples(state.corpo, nivel + 1)}\n${indentacao(nivel)}}`;
+}
+
+function renderizarCorpoSimples(bloco: BlocoGenericoAst, nivel: number): string {
+  const conteudo = ordenarSubblocos(bloco).map((subbloco) => renderizarBlocoAst(subbloco, nivel));
+  const campos = ordenarCampos(bloco).map((campo) => renderizarCampo(campo, nivel, bloco.palavraChave));
+  const linhas = bloco.linhas.map((linha) => renderizarLinha(linha.conteudo, nivel));
+  const corpo = [...campos, ...linhas, ...conteudo];
+  return corpo.join("\n");
+}
+
+function renderizarModulo(modulo: ModuloAst): string {
+  const blocos: Array<{ chave: string; conteudo: string }> = [];
+
+  if (modulo.docs) {
+    blocos.push({ chave: "docs", conteudo: renderizarBlocoGenerico(modulo.docs, 1) });
+  }
+  if (modulo.comments) {
+    blocos.push({ chave: "comments", conteudo: renderizarBlocoGenerico(modulo.comments, 1) });
+  }
+  for (const use of modulo.uses) {
+    blocos.push({ chave: "use", conteudo: renderizarBlocoAst(use, 1) });
+  }
+  if (modulo.vinculos) {
+    blocos.push({ chave: "vinculos", conteudo: renderizarBlocoGenerico(modulo.vinculos, 1) });
+  }
+  for (const database of modulo.databases) {
+    blocos.push({ chave: "database", conteudo: renderizarBlocoGenerico(database, 1) });
+  }
+  for (const type of modulo.types) {
+    blocos.push({ chave: "type", conteudo: renderizarBlocoAst(type, 1) });
+  }
+  for (const entity of modulo.entities) {
+    blocos.push({ chave: "entity", conteudo: renderizarBlocoAst(entity, 1) });
+  }
+  for (const enumeracao of modulo.enums) {
+    blocos.push({ chave: "enum", conteudo: renderizarBlocoAst(enumeracao, 1) });
+  }
+  for (const state of modulo.states) {
+    blocos.push({ chave: "state", conteudo: renderizarBlocoAst(state, 1) });
+  }
+  for (const task of modulo.tasks) {
+    blocos.push({ chave: "task", conteudo: renderizarBlocoAst(task, 1) });
+  }
+  for (const flow of modulo.flows) {
+    blocos.push({ chave: "flow", conteudo: renderizarBlocoAst(flow, 1) });
+  }
+  for (const route of modulo.routes) {
+    blocos.push({ chave: "route", conteudo: renderizarBlocoAst(route, 1) });
+  }
+  for (const worker of modulo.workers) {
+    blocos.push({ chave: "worker", conteudo: renderizarBlocoGenerico(worker, 1) });
+  }
+  for (const evento of modulo.eventos) {
+    blocos.push({ chave: "evento", conteudo: renderizarBlocoGenerico(evento, 1) });
+  }
+  for (const fila of modulo.filas) {
+    blocos.push({ chave: "fila", conteudo: renderizarBlocoGenerico(fila, 1) });
+  }
+  for (const cron of modulo.crons) {
+    blocos.push({ chave: "cron", conteudo: renderizarBlocoGenerico(cron, 1) });
+  }
+  for (const webhook of modulo.webhooks) {
+    blocos.push({ chave: "webhook", conteudo: renderizarBlocoGenerico(webhook, 1) });
+  }
+  for (const cache of modulo.caches) {
+    blocos.push({ chave: "cache", conteudo: renderizarBlocoGenerico(cache, 1) });
+  }
+  for (const storage of modulo.storages) {
+    blocos.push({ chave: "storage", conteudo: renderizarBlocoGenerico(storage, 1) });
+  }
+  for (const policy of modulo.policies) {
+    blocos.push({ chave: "policy", conteudo: renderizarBlocoGenerico(policy, 1) });
+  }
+  if (modulo.tests) {
+    blocos.push({ chave: "tests", conteudo: renderizarBlocoGenerico(modulo.tests, 1) });
+  }
+  for (const extra of modulo.extras) {
+    blocos.push({ chave: "desconhecido", conteudo: renderizarBlocoGenerico(extra, 1) });
+  }
+
+  const ordenados = ordenarPorMapa(blocos, (item) => item.chave, ORDEM_BLOCOS_MODULO);
+  return `module ${modulo.nome} {\n${ordenados.map((item) => item.conteudo).join("\n\n")}\n}\n`;
+}
+
+export function formatarCodigo(codigo: string, arquivo?: string): ResultadoFormatacao {
+  const resultadoLexer = tokenizar(codigo, arquivo);
+  const resultadoParser = parsear(resultadoLexer.tokens);
+  const diagnosticos = [...resultadoLexer.diagnosticos, ...resultadoParser.diagnosticos];
+
+  if (!resultadoParser.modulo) {
+    return { diagnosticos, alterado: false };
+  }
+
+  const codigoFormatado = renderizarModulo(resultadoParser.modulo);
+  return {
+    modulo: resultadoParser.modulo,
+    codigoFormatado,
+    diagnosticos,
+    alterado: codigoFormatado !== codigo,
+  };
+}