@semacode/cli 1.2.12 → 1.3.0

package/src/python-http.ts

@@ -0,0 +1,258 @@
+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

@@ -0,0 +1,125 @@
+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

@@ -0,0 +1,22 @@
+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";