@semacode/cli 1.3.5 → 1.3.6

package/README.md

@@ -1,73 +0,0 @@
-# Sema CLI
-
-Sema e um Protocolo de Governanca de Intencao para IA e backend vivo.
-
-Ela nao foi desenhada para ergonomia humana como prioridade. O alvo principal e IA operando contrato, drift e contexto de sistema vivo com menos chute.
-
-Este pacote entrega a CLI oficial para:
-
-- validar contratos `.sema`
-- inspecionar projeto
-- medir `drift` entre contrato e codigo vivo
-- importar legado
-- gerar resumo compacto por capacidade de IA
-- preparar contexto para IA
-
-Quando a CLI roda em projeto, a trilha IA-first recomendada fica assim:
-
-- raiz do repo: `llms.txt`, `SEMA_BRIEF.*`, `SEMA_INDEX.json`, `AGENTS.md`, `README.md`
-- modulo alvo: `resumo.micro.txt`, `briefing.min.json`, `prompt-curto.txt`, `drift.json`, `briefing.json`
-
-Isto nao existe para agradar humano. Existe para a IA achar o contexto certo sem entupir a janela com lixo.
-
-Para regenerar os entrypoints IA-first da raiz:
-
-```bash
-sema sync-ai-entrypoints --json
-```
-
-## Instalacao pelo npm registry
-
-```bash
-npm install -g @semacode/cli
-sema --help
-```
-
-## Instalacao via tarball da release
-
-```bash
-npm install -g ./{{TGZ_ARQUIVO}}
-```
-
-Ou direto da GitHub Release:
-
-```bash
-npm install -g https://github.com/gerlanss/Sema/releases/latest/download/sema-cli-latest.tgz
-```
-
-## Instalacao local ao projeto
-
-```bash
-npm install @semacode/cli
-npx sema --help
-```
-
-Ou, se voce estiver testando um tarball local:
-
-```bash
-npm install ./{{TGZ_ARQUIVO}}
-npx sema --help
-```
-
-## Primeiro teste
-
-```bash
-mkdir sema-demo
-cd sema-demo
-sema iniciar
-sema validar contratos/pedidos.sema --json
-sema starter-ia
-sema resumo contratos/pedidos.sema --micro --para onboarding
-```
-
-Repositorio: https://github.com/gerlanss/Sema

package/src/cpp-symbols.ts

@@ -1,82 +0,0 @@
-export interface SimboloCppExtraido {
-  simbolo: string;
-  retorno?: string;
-  parametros: Array<{ nome: string; tipoTexto?: string; obrigatorio: boolean }>;
-}
-
-function extrairParametrosCpp(assinatura: string): Array<{ nome: string; tipoTexto?: string; obrigatorio: boolean }> {
-  return assinatura.split(",").map((parametroBruto) => {
-    const parametro = parametroBruto.trim();
-    if (!parametro || parametro === "void") {
-      return undefined;
-    }
-    const semPadrao = parametro.split("=")[0]?.trim() ?? parametro;
-    const partes = semPadrao.split(/\s+/).filter(Boolean);
-    if (partes.length < 2) {
-      return undefined;
-    }
-    const nome = partes.at(-1)!.replace(/[&*]+$/, "");
-    const tipoTexto = partes.slice(0, -1).join(" ");
-    return {
-      nome,
-      tipoTexto,
-      obrigatorio: !parametro.includes("="),
-    };
-  }).filter((item): item is NonNullable<typeof item> => Boolean(item));
-}
-
-export function extrairSimbolosCpp(codigo: string): SimboloCppExtraido[] {
-  const simbolos = new Map<string, SimboloCppExtraido>();
-
-  for (const match of codigo.matchAll(/(?:^|\n)\s*(?:inline\s+|static\s+|virtual\s+|constexpr\s+|friend\s+|extern\s+|template\s*<[^>]+>\s*)*(?:[\w:<>~*&]+\s+)+([A-Za-z_]\w*)::([A-Za-z_]\w*)\s*\(([^)]*)\)\s*(?:const)?\s*(?:\{|;)/g)) {
-    const simbolo = `${match[1]!}.${match[2]!}`;
-    simbolos.set(simbolo, {
-      simbolo,
-      parametros: extrairParametrosCpp(match[3] ?? ""),
-    });
-  }
-
-  for (const match of codigo.matchAll(/(?:^|\n)\s*(?:inline\s+|static\s+|virtual\s+|constexpr\s+|friend\s+|extern\s+)*(?:[\w:<>~*&]+\s+)+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*(?:const)?\s*(?:\{|;)/g)) {
-    const nome = match[1]!;
-    if (["if", "for", "while", "switch", "return"].includes(nome)) {
-      continue;
-    }
-    if (!simbolos.has(nome)) {
-      simbolos.set(nome, {
-        simbolo: nome,
-        parametros: extrairParametrosCpp(match[2] ?? ""),
-      });
-    }
-  }
-
-  const pilhaClasses: string[] = [];
-  for (const linha of codigo.split(/\r?\n/)) {
-    const trim = linha.trim();
-    const classe = trim.match(/^(?:class|struct)\s+([A-Za-z_]\w*)/);
-    if (classe) {
-      pilhaClasses.push(classe[1]!);
-      continue;
-    }
-    if (trim.startsWith("};") || trim === "}" || trim === "};") {
-      pilhaClasses.pop();
-      continue;
-    }
-
-    const metodoClasse = trim.match(/^(?:inline\s+|static\s+|virtual\s+|constexpr\s+)*(?:[\w:<>~*&]+\s+)+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*(?:const)?\s*\{/);
-    if (metodoClasse && pilhaClasses.length > 0) {
-      const nomeClasse = pilhaClasses[pilhaClasses.length - 1]!;
-      const nomeMetodo = metodoClasse[1]!;
-      if (!["if", "for", "while", "switch"].includes(nomeMetodo)) {
-        const simbolo = `${nomeClasse}.${nomeMetodo}`;
-        if (!simbolos.has(simbolo)) {
-          simbolos.set(simbolo, {
-            simbolo,
-            parametros: extrairParametrosCpp(metodoClasse[2] ?? ""),
-          });
-        }
-      }
-    }
-  }
-
-  return [...simbolos.values()];
-}

package/src/dotnet-http.ts

@@ -1,355 +0,0 @@
-export interface ParametroRotaBackend {
-  nome: string;
-  tipoSema: "Texto" | "Inteiro" | "Decimal" | "Id";
-}
-
-export interface SimboloDotnetExtraido {
-  simbolo: string;
-  retorno?: string;
-  parametros: Array<{ nome: string; tipoTexto?: string; obrigatorio: boolean }>;
-}
-
-export interface RotaDotnetExtraida {
-  origem: "dotnet";
-  metodo: string;
-  caminho: string;
-  simbolo: string;
-  parametros: ParametroRotaBackend[];
-  retorno?: string;
-}
-
-const METODOS_HTTP = new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
-
-function normalizarCaminhoBase(caminho?: string): string | undefined {
-  if (!caminho) {
-    return undefined;
-  }
-  return caminho.replace(/^\/+|\/+$/g, "");
-}
-
-function juntarCaminho(base: string | undefined, sufixo: string | undefined): string {
-  const partes = [base, sufixo]
-    .map((parte) => normalizarCaminhoBase(parte))
-    .filter((parte): parte is string => Boolean(parte));
-  return `/${partes.join("/")}`.replace(/\/+/g, "/");
-}
-
-function normalizarCaminhoAspNet(caminho: string, classe?: string, metodo?: string): string {
-  const controller = (classe ?? "").replace(/Controller$/i, "");
-  const action = metodo ?? "";
-  return caminho
-    .replace(/\[controller\]/gi, controller ? controller.toLowerCase() : "controller")
-    .replace(/\[action\]/gi, action ? action.toLowerCase() : "action")
-    .replace(/\{([^}:]+):[^}]+\}/g, "{$1}")
-    .replace(/\/+/g, "/");
-}
-
-function mapearTipoRotaDotnet(tipo?: string): ParametroRotaBackend["tipoSema"] {
-  const normalizado = (tipo ?? "").toLowerCase();
-  if (/(^|\.)(int|int32|int64|long|short)$/.test(normalizado)) {
-    return "Inteiro";
-  }
-  if (/(^|\.)(float|double|decimal)$/.test(normalizado)) {
-    return "Decimal";
-  }
-  if (/guid|uuid|id$/i.test(normalizado)) {
-    return "Id";
-  }
-  return "Texto";
-}
-
-function extrairParametrosRota(caminho: string, assinatura: string): ParametroRotaBackend[] {
-  const tiposAssinatura = new Map<string, string>();
-  for (const parametroBruto of assinatura.split(",")) {
-    const parametro = parametroBruto.trim();
-    if (!parametro) {
-      continue;
-    }
-    const semPadrao = parametro.split("=")[0]?.trim() ?? parametro;
-    const partes = semPadrao.split(/\s+/).filter(Boolean);
-    if (partes.length < 2) {
-      continue;
-    }
-    const nome = partes.at(-1)!;
-    const tipo = partes.slice(0, -1).join(" ");
-    tiposAssinatura.set(nome, tipo);
-  }
-
-  return [...caminho.matchAll(/\{([^}:]+)(?::[^}]+)?\}/g)].map((match) => {
-    const nome = match[1]!;
-    return {
-      nome,
-      tipoSema: mapearTipoRotaDotnet(tiposAssinatura.get(nome)),
-    };
-  });
-}
-
-function extrairTextoAtributo(atributo: string): string | undefined {
-  return atributo.match(/"([^"]+)"/)?.[1];
-}
-
-function extrairMetodosAtributo(atributo: string): string[] {
-  const direto = atributo.match(/\[\s*Http(Get|Post|Put|Patch|Delete)\b/i)?.[1]?.toUpperCase();
-  if (direto && METODOS_HTTP.has(direto)) {
-    return [direto];
-  }
-
-  const bloco = atributo.match(/\bHttpMethods\.(Get|Post|Put|Patch|Delete)\b/gi)
-    ?.map((item) => item.split(".").pop()?.toUpperCase() ?? "")
-    .filter((item) => METODOS_HTTP.has(item));
-  if (bloco && bloco.length > 0) {
-    return [...new Set(bloco)];
-  }
-
-  const requestMapping = atributo.match(/\[\s*AcceptVerbs\(([^)]*)\)\s*\]/i)?.[1];
-  if (requestMapping) {
-    const encontrados = [...requestMapping.matchAll(/"([A-Za-z]+)"/g)]
-      .map((match) => match[1]!.toUpperCase())
-      .filter((item) => METODOS_HTTP.has(item));
-    if (encontrados.length > 0) {
-      return [...new Set(encontrados)];
-    }
-  }
-
-  return [];
-}
-
-function contarChar(texto: string, alvo: string): number {
-  return [...texto].filter((char) => char === alvo).length;
-}
-
-function atualizarPilhaClasses<T extends { profundidade: number }>(pilha: T[], profundidade: number): void {
-  while (pilha.length > 0 && profundidade < pilha[pilha.length - 1]!.profundidade) {
-    pilha.pop();
-  }
-}
-
-function extrairAtributos(linhas: string[], inicio: number): { atributos: string[]; proximoIndice: number } {
-  const atributos: string[] = [];
-  let indice = inicio;
-
-  while (indice < linhas.length) {
-    const linha = linhas[indice]!.trim();
-    if (!linha.startsWith("[")) {
-      break;
-    }
-    let atual = linha;
-    let saldo = contarChar(linha, "[") - contarChar(linha, "]");
-    while (saldo > 0 && indice + 1 < linhas.length) {
-      indice += 1;
-      const complemento = linhas[indice]!.trim();
-      atual += ` ${complemento}`;
-      saldo += contarChar(complemento, "[") - contarChar(complemento, "]");
-    }
-    atributos.push(atual);
-    indice += 1;
-  }
-
-  return { atributos, proximoIndice: indice };
-}
-
-export function extrairSimbolosDotnet(codigo: string): SimboloDotnetExtraido[] {
-  const simbolos = new Map<string, SimboloDotnetExtraido>();
-  const linhas = codigo.split(/\r?\n/);
-  const pilhaClasses: Array<{ nome: string; profundidade: number }> = [];
-  let classePendente: { nome: string; profundidade: number } | undefined;
-  let profundidade = 0;
-
-  for (let indice = 0; indice < linhas.length; indice += 1) {
-    const linhaOriginal = linhas[indice]!;
-    const linha = linhaOriginal.trim();
-    if (classePendente && linha.startsWith("{")) {
-      pilhaClasses.push(classePendente);
-      classePendente = undefined;
-    }
-    if (!linha || linha.startsWith("//")) {
-      profundidade += contarChar(linhaOriginal, "{") - contarChar(linhaOriginal, "}");
-      atualizarPilhaClasses(pilhaClasses, profundidade);
-      continue;
-    }
-
-    const { atributos, proximoIndice } = extrairAtributos(linhas, indice);
-    if (atributos.length > 0) {
-      indice = proximoIndice;
-    }
-
-    const linhaEfetiva = (linhas[indice] ?? "").trim();
-    const classe = linhaEfetiva.match(/\bclass\s+([A-Za-z_]\w*)/);
-    if (classe) {
-      const entrada = { nome: classe[1]!, profundidade: profundidade + 1 };
-      if (linhaEfetiva.includes("{")) {
-        pilhaClasses.push(entrada);
-      } else {
-        classePendente = entrada;
-      }
-      profundidade += contarChar(linhaEfetiva, "{") - contarChar(linhaEfetiva, "}");
-      atualizarPilhaClasses(pilhaClasses, profundidade);
-      continue;
-    }
-
-    const metodo = linhaEfetiva.match(/\b(?:public|internal|protected|private)\s+(?:static\s+|async\s+|virtual\s+|override\s+|sealed\s+|partial\s+)*([A-Za-z0-9_<>,.?[\]\s]+)\s+([A-Za-z_]\w*)\s*\(([^)]*)\)/);
-    if (metodo) {
-      const classeAtual = pilhaClasses[pilhaClasses.length - 1];
-      const simbolo = classeAtual ? `${classeAtual.nome}.${metodo[2]!}` : metodo[2]!;
-      simbolos.set(simbolo, {
-        simbolo,
-        retorno: metodo[1]!.trim(),
-        parametros: metodo[3]!.split(",").flatMap((parametroBruto) => {
-          const parametro = parametroBruto.trim();
-          if (!parametro) {
-            return [];
-          }
-          const semPadrao = parametro.split("=")[0]?.trim() ?? parametro;
-          const partes = semPadrao.split(/\s+/).filter(Boolean);
-          if (partes.length < 2) {
-            return [];
-          }
-          return [{
-            nome: partes.at(-1)!,
-            tipoTexto: partes.slice(0, -1).join(" "),
-            obrigatorio: !parametro.includes("="),
-          }];
-        }),
-      });
-      profundidade += contarChar(linhaEfetiva, "{") - contarChar(linhaEfetiva, "}");
-      atualizarPilhaClasses(pilhaClasses, profundidade);
-      continue;
-    }
-
-    const funcaoLocal = linhaEfetiva.match(/\b([A-Za-z0-9_<>,.?[\]\s]+)\s+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*=>/);
-    if (funcaoLocal && atributos.length === 0 && pilhaClasses.length === 0) {
-      const simbolo = funcaoLocal[2]!;
-      simbolos.set(simbolo, {
-        simbolo,
-        retorno: funcaoLocal[1]!.trim(),
-        parametros: [],
-      });
-    }
-
-    const funcaoTopo = linhaEfetiva.match(/\b(?:static\s+)?([A-Za-z0-9_<>,.?[\]\s]+)\s+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*(?:\{|$)/);
-    if (funcaoTopo && atributos.length === 0 && pilhaClasses.length === 0 && !["if", "for", "while", "switch"].includes(funcaoTopo[2]!)) {
-      const simbolo = funcaoTopo[2]!;
-      if (!simbolos.has(simbolo)) {
-        simbolos.set(simbolo, {
-          simbolo,
-          retorno: funcaoTopo[1]!.trim(),
-          parametros: funcaoTopo[3]!.split(",").flatMap((parametroBruto) => {
-            const parametro = parametroBruto.trim();
-            if (!parametro) {
-              return [];
-            }
-            const semPadrao = parametro.split("=")[0]?.trim() ?? parametro;
-            const partes = semPadrao.split(/\s+/).filter(Boolean);
-            if (partes.length < 2) {
-              return [];
-            }
-            return [{
-              nome: partes.at(-1)!,
-              tipoTexto: partes.slice(0, -1).join(" "),
-              obrigatorio: !parametro.includes("="),
-            }];
-          }),
-        });
-      }
-    }
-
-    profundidade += contarChar(linhaEfetiva, "{") - contarChar(linhaEfetiva, "}");
-    atualizarPilhaClasses(pilhaClasses, profundidade);
-  }
-
-  return [...simbolos.values()];
-}
-
-export function extrairRotasDotnet(codigo: string): RotaDotnetExtraida[] {
-  const rotas = new Map<string, RotaDotnetExtraida>();
-  const linhas = codigo.split(/\r?\n/);
-  const pilhaClasses: Array<{ nome: string; profundidade: number; rotaBase?: string; apiController: boolean }> = [];
-  let classePendente: { nome: string; profundidade: number; rotaBase?: string; apiController: boolean } | undefined;
-  let profundidade = 0;
-
-  for (let indice = 0; indice < linhas.length; indice += 1) {
-    const linhaOriginal = linhas[indice]!;
-    const linha = linhaOriginal.trim();
-    if (classePendente && linha.startsWith("{")) {
-      pilhaClasses.push(classePendente);
-      classePendente = undefined;
-    }
-    if (!linha || linha.startsWith("//")) {
-      profundidade += contarChar(linhaOriginal, "{") - contarChar(linhaOriginal, "}");
-      atualizarPilhaClasses(pilhaClasses, profundidade);
-      continue;
-    }
-
-    const { atributos, proximoIndice } = extrairAtributos(linhas, indice);
-    if (atributos.length > 0) {
-      indice = proximoIndice;
-    }
-
-    const linhaEfetiva = (linhas[indice] ?? "").trim();
-    const classe = linhaEfetiva.match(/\bclass\s+([A-Za-z_]\w*)/);
-    if (classe) {
-      const rotaBase = atributos
-        .map((atributo) => extrairTextoAtributo(atributo))
-        .find(Boolean);
-      const entrada = {
-        nome: classe[1]!,
-        profundidade: profundidade + 1,
-        rotaBase,
-        apiController: atributos.some((atributo) => /\[\s*ApiController\s*\]/i.test(atributo)),
-      };
-      if (linhaEfetiva.includes("{")) {
-        pilhaClasses.push(entrada);
-      } else {
-        classePendente = entrada;
-      }
-      profundidade += contarChar(linhaEfetiva, "{") - contarChar(linhaEfetiva, "}");
-      atualizarPilhaClasses(pilhaClasses, profundidade);
-      continue;
-    }
-
-    const classeAtual = pilhaClasses[pilhaClasses.length - 1];
-    const metodo = linhaEfetiva.match(/\b(?:public|internal|protected)\s+(?:async\s+|virtual\s+|override\s+|static\s+)*([A-Za-z0-9_<>,.?[\]\s]+)\s+([A-Za-z_]\w*)\s*\(([^)]*)\)/);
-    if (metodo && classeAtual) {
-      const atributosMetodo = atributos.filter((atributo) => /\[\s*(?:Http|AcceptVerbs)/i.test(atributo));
-      for (const atributo of atributosMetodo) {
-        const metodos = extrairMetodosAtributo(atributo);
-        const rotaMetodo = extrairTextoAtributo(atributo);
-        for (const httpMetodo of metodos) {
-          const caminho = normalizarCaminhoAspNet(
-            juntarCaminho(classeAtual.rotaBase, rotaMetodo),
-            classeAtual.nome,
-            metodo[2]!,
-          );
-          const registro: RotaDotnetExtraida = {
-            origem: "dotnet",
-            metodo: httpMetodo,
-            caminho,
-            simbolo: `${classeAtual.nome}.${metodo[2]!}`,
-            parametros: extrairParametrosRota(caminho, metodo[3] ?? ""),
-            retorno: metodo[1]!.trim(),
-          };
-          rotas.set(`${registro.metodo}:${registro.caminho}:${registro.simbolo}`, registro);
-        }
-      }
-    }
-
-    for (const match of linhaEfetiva.matchAll(/\b\w+\.Map(Get|Post|Put|Patch|Delete)\(\s*"([^"]+)"\s*,\s*([A-Za-z_][\w.]*)/g)) {
-      const httpMetodo = match[1]!.toUpperCase();
-      const caminho = normalizarCaminhoAspNet(match[2]!);
-      const simbolo = match[3]!;
-      const registro: RotaDotnetExtraida = {
-        origem: "dotnet",
-        metodo: httpMetodo,
-        caminho,
-        simbolo,
-        parametros: extrairParametrosRota(caminho, ""),
-      };
-      rotas.set(`${registro.metodo}:${registro.caminho}:${registro.simbolo}`, registro);
-    }
-
-    profundidade += contarChar(linhaEfetiva, "{") - contarChar(linhaEfetiva, "}");
-    atualizarPilhaClasses(pilhaClasses, profundidade);
-  }
-
-  return [...rotas.values()];
-}