@semacode/cli 1.3.1 → 1.3.2

package/src/python-http.ts

@@ -1,258 +0,0 @@
-export interface FuncaoPythonDecorada {
-  nome: string;
-  parametros: string;
-  retorno?: string;
-  indentacao: number;
-  decorators: string[];
-}
-
-export interface ParametroRotaFlask {
-  nome: string;
-  conversor?: string;
-}
-
-export interface RotaFlaskDecorada {
-  nomeFuncao: string;
-  parametros: string;
-  retorno?: string;
-  metodo: string;
-  caminho: string;
-}
-
-function contarParenteses(texto: string): number {
-  let saldo = 0;
-  let quote: "'" | '"' | undefined;
-  let escapando = false;
-
-  for (const caractere of texto) {
-    if (escapando) {
-      escapando = false;
-      continue;
-    }
-
-    if (caractere === "\\") {
-      escapando = true;
-      continue;
-    }
-
-    if (quote) {
-      if (caractere === quote) {
-        quote = undefined;
-      }
-      continue;
-    }
-
-    if (caractere === "'" || caractere === '"') {
-      quote = caractere;
-      continue;
-    }
-
-    if (caractere === "(") {
-      saldo += 1;
-      continue;
-    }
-
-    if (caractere === ")") {
-      saldo -= 1;
-    }
-  }
-
-  return saldo;
-}
-
-export function contarIndentacaoPython(linha: string): number {
-  let total = 0;
-  for (const caractere of linha) {
-    if (caractere === " ") {
-      total += 1;
-      continue;
-    }
-    if (caractere === "\t") {
-      total += 4;
-      continue;
-    }
-    break;
-  }
-  return total;
-}
-
-function juntarCaminhoHttp(base: string | undefined, sufixo: string | undefined): string {
-  const partes = [base ?? "", sufixo ?? ""]
-    .map((item) => item.trim())
-    .filter(Boolean)
-    .map((item) => item.replace(/^\/+|\/+$/g, ""));
-
-  const caminho = `/${partes.join("/")}`.replace(/\/+/g, "/");
-  return caminho === "//" ? "/" : caminho;
-}
-
-function detectarBlueprintsFlask(texto: string): Map<string, string | undefined> {
-  const blueprints = new Map<string, string | undefined>();
-  const linhas = texto.split(/\r?\n/);
-  let atual: { nome: string; linhas: string[]; saldo: number } | undefined;
-
-  const finalizar = () => {
-    if (!atual) {
-      return;
-    }
-    const conteudo = atual.linhas.join(" ");
-    const prefixo = conteudo.match(/\burl_prefix\s*=\s*["']([^"']+)["']/)?.[1];
-    blueprints.set(atual.nome, prefixo);
-    atual = undefined;
-  };
-
-  for (const linha of linhas) {
-    const trim = linha.trim();
-    if (!trim || trim.startsWith("#")) {
-      continue;
-    }
-
-    if (atual) {
-      atual.linhas.push(trim);
-      atual.saldo += contarParenteses(trim);
-      if (atual.saldo <= 0) {
-        finalizar();
-      }
-      continue;
-    }
-
-    const inicio = trim.match(/^([A-Za-z_]\w*)\s*=\s*Blueprint\s*\(/);
-    if (!inicio) {
-      continue;
-    }
-
-    atual = {
-      nome: inicio[1]!,
-      linhas: [trim],
-      saldo: contarParenteses(trim),
-    };
-
-    if (atual.saldo <= 0) {
-      finalizar();
-    }
-  }
-
-  finalizar();
-  return blueprints;
-}
-
-export function extrairFuncoesPythonDecoradas(texto: string): FuncaoPythonDecorada[] {
-  const funcoes: FuncaoPythonDecorada[] = [];
-  const linhas = texto.split(/\r?\n/);
-  let decoratorsPendentes: string[] = [];
-  let decoratorAtual: { linhas: string[]; saldo: number } | undefined;
-
-  const finalizarDecorator = () => {
-    if (!decoratorAtual) {
-      return;
-    }
-    decoratorsPendentes.push(decoratorAtual.linhas.join(" ").replace(/\s+/g, " ").trim());
-    decoratorAtual = undefined;
-  };
-
-  for (const linha of linhas) {
-    const trim = linha.trim();
-    const indentacao = contarIndentacaoPython(linha);
-
-    if (decoratorAtual) {
-      decoratorAtual.linhas.push(trim);
-      decoratorAtual.saldo += contarParenteses(trim);
-      if (decoratorAtual.saldo <= 0) {
-        finalizarDecorator();
-      }
-      continue;
-    }
-
-    if (!trim || trim.startsWith("#")) {
-      continue;
-    }
-
-    if (trim.startsWith("@")) {
-      decoratorAtual = {
-        linhas: [trim],
-        saldo: contarParenteses(trim),
-      };
-      if (decoratorAtual.saldo <= 0) {
-        finalizarDecorator();
-      }
-      continue;
-    }
-
-    const definicao = trim.match(/^(?:async\s+def|def)\s+([A-Za-z_]\w*)\s*\((.*)\)(?:\s*->\s*([^:]+))?:\s*(?:#.*)?$/);
-    if (definicao) {
-      funcoes.push({
-        nome: definicao[1]!,
-        parametros: definicao[2] ?? "",
-        retorno: definicao[3]?.trim(),
-        indentacao,
-        decorators: decoratorsPendentes,
-      });
-      decoratorsPendentes = [];
-      continue;
-    }
-
-    decoratorsPendentes = [];
-  }
-
-  return funcoes;
-}
-
-function extrairMetodosFlask(decorator: string): string[] {
-  const blocoMethods = decorator.match(/\bmethods\s*=\s*\[([^\]]*)\]/i)?.[1];
-  if (!blocoMethods) {
-    return ["GET"];
-  }
-
-  const encontrados = [...blocoMethods.matchAll(/["']([A-Za-z]+)["']/g)]
-    .map((match) => match[1]!.toUpperCase())
-    .filter((metodo) => ["GET", "POST", "PUT", "PATCH", "DELETE"].includes(metodo));
-
-  return [...new Set(encontrados)];
-}
-
-export function normalizarCaminhoFlask(caminho: string): string {
-  return caminho.replace(/<(?:(\w+):)?([A-Za-z_]\w*)>/g, "{$2}");
-}
-
-export function extrairParametrosCaminhoFlask(caminho: string): ParametroRotaFlask[] {
-  return [...caminho.matchAll(/<(?:(\w+):)?([A-Za-z_]\w*)>/g)].map((match) => ({
-    conversor: match[1] ?? undefined,
-    nome: match[2]!,
-  }));
-}
-
-export function extrairRotasFlaskDecoradas(texto: string): RotaFlaskDecorada[] {
-  const blueprints = detectarBlueprintsFlask(texto);
-  const rotas: RotaFlaskDecorada[] = [];
-
-  for (const funcao of extrairFuncoesPythonDecoradas(texto)) {
-    if (funcao.indentacao > 0) {
-      continue;
-    }
-
-    for (const decorator of funcao.decorators) {
-      const match = decorator.match(/^@([A-Za-z_]\w*)\.route\(([\s\S]*)\)$/);
-      if (!match) {
-        continue;
-      }
-
-      const alvo = match[1]!;
-      const argumentos = match[2] ?? "";
-      const sufixo = argumentos.match(/["']([^"']+)["']/)?.[1];
-      const prefixo = alvo === "app" ? undefined : blueprints.get(alvo);
-      const metodos = extrairMetodosFlask(decorator);
-
-      for (const metodo of metodos) {
-        rotas.push({
-          nomeFuncao: funcao.nome,
-          parametros: funcao.parametros,
-          retorno: funcao.retorno,
-          metodo,
-          caminho: normalizarCaminhoFlask(juntarCaminhoHttp(prefixo, sufixo)),
-        });
-      }
-    }
-  }
-
-  return rotas;
-}

package/src/rust-http.ts

@@ -1,125 +0,0 @@
-export interface ParametroRotaRust {
-  nome: string;
-  tipoSema: "Texto" | "Inteiro" | "Decimal" | "Id";
-}
-
-export interface SimboloRustExtraido {
-  simbolo: string;
-  retorno?: string;
-  parametros: Array<{ nome: string; tipoTexto?: string; obrigatorio: boolean }>;
-}
-
-export interface RotaRustExtraida {
-  origem: "rust";
-  metodo: string;
-  caminho: string;
-  simbolo: string;
-  parametros: ParametroRotaRust[];
-  retorno?: string;
-}
-
-const METODOS_HTTP = new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
-
-function normalizarCaminhoRust(caminho: string): string {
-  return caminho
-    .replace(/:([A-Za-z_]\w*)/g, "{$1}")
-    .replace(/\/+/g, "/");
-}
-
-function mapearTipoRust(tipo?: string): ParametroRotaRust["tipoSema"] {
-  const normalizado = (tipo ?? "").toLowerCase();
-  if (/^(i8|i16|i32|i64|u8|u16|u32|u64|usize|isize)$/.test(normalizado)) {
-    return "Inteiro";
-  }
-  if (/^(f32|f64|decimal)$/.test(normalizado)) {
-    return "Decimal";
-  }
-  if (/uuid|id$/.test(normalizado)) {
-    return "Id";
-  }
-  return "Texto";
-}
-
-function extrairParametrosAssinaturaRust(assinatura: string): Array<{ nome: string; tipoTexto?: string; obrigatorio: boolean }> {
-  return assinatura.split(",").map((parametroBruto) => {
-    const parametro = parametroBruto.trim();
-    if (!parametro || parametro === "&self" || parametro === "self") {
-      return undefined;
-    }
-    const [nome, tipo] = parametro.split(":").map((parte) => parte.trim());
-    if (!nome) {
-      return undefined;
-    }
-    return {
-      nome: nome.replace(/^mut\s+/, ""),
-      tipoTexto: tipo,
-      obrigatorio: true,
-    };
-  }).filter((item): item is NonNullable<typeof item> => Boolean(item));
-}
-
-function extrairParametrosRotaRust(caminho: string, assinatura: string): ParametroRotaRust[] {
-  const assinaturaMap = new Map<string, string>();
-  for (const parametro of extrairParametrosAssinaturaRust(assinatura)) {
-    assinaturaMap.set(parametro.nome, parametro.tipoTexto ?? "");
-  }
-  return [...normalizarCaminhoRust(caminho).matchAll(/\{([^}]+)\}/g)].map((match) => ({
-    nome: match[1]!,
-    tipoSema: mapearTipoRust(assinaturaMap.get(match[1]!)),
-  }));
-}
-
-export function extrairSimbolosRust(codigo: string): SimboloRustExtraido[] {
-  const simbolos = new Map<string, SimboloRustExtraido>();
-  let implAtual: string | undefined;
-
-  for (const linha of codigo.split(/\r?\n/)) {
-    const trim = linha.trim();
-    const impl = trim.match(/^impl(?:<[^>]+>)?\s+([A-Za-z_]\w*)/);
-    if (impl) {
-      implAtual = impl[1]!;
-      continue;
-    }
-    if (trim.startsWith("}")) {
-      implAtual = undefined;
-    }
-
-    const funcao = trim.match(/^(?:pub\s+)?(?:async\s+)?fn\s+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*(?:->\s*([^ {]+))?/);
-    if (!funcao) {
-      continue;
-    }
-    const simbolo = implAtual ? `${implAtual}.${funcao[1]!}` : funcao[1]!;
-    simbolos.set(simbolo, {
-      simbolo,
-      retorno: funcao[3]?.trim(),
-      parametros: extrairParametrosAssinaturaRust(funcao[2] ?? ""),
-    });
-  }
-
-  return [...simbolos.values()];
-}
-
-export function extrairRotasRust(codigo: string): RotaRustExtraida[] {
-  const rotas = new Map<string, RotaRustExtraida>();
-
-  for (const match of codigo.matchAll(/\.route\(\s*"([^"]+)"\s*,\s*((?:get|post|put|patch|delete)\([A-Za-z_:][A-Za-z0-9_:]*\)(?:\.(?:get|post|put|patch|delete)\([A-Za-z_:][A-Za-z0-9_:]*\))*)\s*\)/g)) {
-    const caminho = normalizarCaminhoRust(match[1]!);
-    const bloco = match[2]!;
-    for (const rota of bloco.matchAll(/\b(get|post|put|patch|delete)\(([A-Za-z_:][A-Za-z0-9_:]*)\)/g)) {
-      const metodo = rota[1]!.toUpperCase();
-      const simbolo = rota[2]!.replace(/::/g, ".");
-      if (!METODOS_HTTP.has(metodo)) {
-        continue;
-      }
-      rotas.set(`${metodo}:${caminho}:${simbolo}`, {
-        origem: "rust",
-        metodo,
-        caminho,
-        simbolo,
-        parametros: extrairParametrosRotaRust(caminho, ""),
-      });
-    }
-  }
-
-  return [...rotas.values()];
-}

package/src/tipos.ts

@@ -1,22 +0,0 @@
-export type EstruturaSaida = "flat" | "modulos" | "backend";
-
-export type FonteLegado =
-  | "nestjs"
-  | "fastapi"
-  | "flask"
-  | "nextjs"
-  | "nextjs-consumer"
-  | "react-vite-consumer"
-  | "angular-consumer"
-  | "flutter-consumer"
-  | "firebase"
-  | "typescript"
-  | "python"
-  | "dart"
-  | "dotnet"
-  | "java"
-  | "go"
-  | "rust"
-  | "cpp";
-
-export type ModoAdocao = "incremental";