@semacode/cli 1.5.16 → 1.5.18

package/src/java-http.ts

@@ -1,247 +0,0 @@
-export interface ParametroRotaJava {
-  nome: string;
-  tipoSema: "Texto" | "Inteiro" | "Decimal" | "Id";
-}
-
-export interface SimboloJavaExtraido {
-  simbolo: string;
-  retorno?: string;
-  parametros: Array<{ nome: string; tipoTexto?: string; obrigatorio: boolean }>;
-}
-
-export interface RotaJavaExtraida {
-  origem: "java";
-  metodo: string;
-  caminho: string;
-  simbolo: string;
-  parametros: ParametroRotaJava[];
-  retorno?: string;
-}
-
-const METODOS_HTTP = new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
-
-function contarChar(texto: string, alvo: string): number {
-  return [...texto].filter((char) => char === alvo).length;
-}
-
-function juntarCaminho(base: string | undefined, sufixo: string | undefined): string {
-  const partes = [base, sufixo]
-    .map((parte) => (parte ?? "").trim())
-    .filter(Boolean)
-    .map((parte) => parte.replace(/^\/+|\/+$/g, ""));
-  return `/${partes.join("/")}`.replace(/\/+/g, "/");
-}
-
-function extrairParametrosAssinaturaJava(assinatura: string): Array<{ nome: string; tipoTexto?: string; obrigatorio: boolean }> {
-  return assinatura.split(",").map((parametroBruto) => {
-    const parametro = parametroBruto.trim();
-    if (!parametro) {
-      return undefined;
-    }
-    const limpo = parametro.replace(/^@\w+(?:\([^)]*\))?\s*/g, "").trim();
-    const partes = limpo.split(/\s+/).filter(Boolean);
-    if (partes.length < 2) {
-      return undefined;
-    }
-    return {
-      nome: partes.at(-1)!,
-      tipoTexto: partes.slice(0, -1).join(" "),
-      obrigatorio: true,
-    };
-  }).filter((item): item is NonNullable<typeof item> => Boolean(item));
-}
-
-function mapearTipoJava(tipo?: string): ParametroRotaJava["tipoSema"] {
-  const normalizado = (tipo ?? "").toLowerCase();
-  if (/(^|\.)(int|integer|long|short)$/.test(normalizado)) {
-    return "Inteiro";
-  }
-  if (/(^|\.)(float|double|bigdecimal|decimal)$/.test(normalizado)) {
-    return "Decimal";
-  }
-  if (/uuid|id$/i.test(normalizado)) {
-    return "Id";
-  }
-  return "Texto";
-}
-
-function extrairAtributosJava(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 };
-}
-
-function extrairCaminhoJava(atributo: string): string | undefined {
-  return atributo.match(/"([^"]+)"/)?.[1];
-}
-
-function extrairMetodosJava(atributo: string): string[] {
-  const direto = atributo.match(/@(Get|Post|Put|Patch|Delete)Mapping/i)?.[1]?.toUpperCase();
-  if (direto && METODOS_HTTP.has(direto)) {
-    return [direto];
-  }
-
-  const requestMethod = [...atributo.matchAll(/RequestMethod\.(GET|POST|PUT|PATCH|DELETE)/gi)]
-    .map((match) => match[1]!.toUpperCase())
-    .filter((metodo) => METODOS_HTTP.has(metodo));
-  if (requestMethod.length > 0) {
-    return [...new Set(requestMethod)];
-  }
-  return [];
-}
-
-function normalizarCaminhoJava(caminho: string): string {
-  return caminho.replace(/\{([^}:]+):[^}]+\}/g, "{$1}").replace(/\/+/g, "/");
-}
-
-function extrairParametrosRotaJava(caminho: string, assinatura: string): ParametroRotaJava[] {
-  const assinaturaMap = new Map<string, string>();
-  for (const parametro of extrairParametrosAssinaturaJava(assinatura)) {
-    assinaturaMap.set(parametro.nome, parametro.tipoTexto ?? "");
-  }
-  return [...caminho.matchAll(/\{([^}:]+)(?::[^}]+)?\}/g)].map((match) => {
-    const nome = match[1]!;
-    return {
-      nome,
-      tipoSema: mapearTipoJava(assinaturaMap.get(nome)),
-    };
-  });
-}
-
-export function extrairSimbolosJava(codigo: string): SimboloJavaExtraido[] {
-  const simbolos = new Map<string, SimboloJavaExtraido>();
-  const linhas = codigo.split(/\r?\n/);
-  const pilhaClasses: Array<{ nome: string; profundidade: number }> = [];
-  let profundidade = 0;
-
-  for (let indice = 0; indice < linhas.length; indice += 1) {
-    const linhaOriginal = linhas[indice]!;
-    const { atributos, proximoIndice } = extrairAtributosJava(linhas, indice);
-    if (atributos.length > 0) {
-      indice = proximoIndice;
-    }
-    const linha = (linhas[indice] ?? linhaOriginal).trim();
-    if (!linha || linha.startsWith("//")) {
-      profundidade += contarChar(linhaOriginal, "{") - contarChar(linhaOriginal, "}");
-      while (pilhaClasses.length > 0 && profundidade < pilhaClasses[pilhaClasses.length - 1]!.profundidade) {
-        pilhaClasses.pop();
-      }
-      continue;
-    }
-
-    const classe = linha.match(/\bclass\s+([A-Za-z_]\w*)/);
-    if (classe) {
-      pilhaClasses.push({ nome: classe[1]!, profundidade: profundidade + 1 });
-      profundidade += contarChar(linha, "{") - contarChar(linha, "}");
-      while (pilhaClasses.length > 0 && profundidade < pilhaClasses[pilhaClasses.length - 1]!.profundidade) {
-        pilhaClasses.pop();
-      }
-      continue;
-    }
-
-    const metodo = linha.match(/\b(?:public|protected|private)\s+(?:static\s+|final\s+|synchronized\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: extrairParametrosAssinaturaJava(metodo[3]!),
-      });
-    }
-
-    profundidade += contarChar(linha, "{") - contarChar(linha, "}");
-    while (pilhaClasses.length > 0 && profundidade < pilhaClasses[pilhaClasses.length - 1]!.profundidade) {
-      pilhaClasses.pop();
-    }
-  }
-
-  return [...simbolos.values()];
-}
-
-export function extrairRotasJava(codigo: string): RotaJavaExtraida[] {
-  const rotas = new Map<string, RotaJavaExtraida>();
-  const linhas = codigo.split(/\r?\n/);
-  const pilhaClasses: Array<{ nome: string; profundidade: number; rotaBase?: string; rest: boolean }> = [];
-  let profundidade = 0;
-
-  for (let indice = 0; indice < linhas.length; indice += 1) {
-    const linhaOriginal = linhas[indice]!;
-    const { atributos, proximoIndice } = extrairAtributosJava(linhas, indice);
-    if (atributos.length > 0) {
-      indice = proximoIndice;
-    }
-    const linha = (linhas[indice] ?? linhaOriginal).trim();
-    if (!linha || linha.startsWith("//")) {
-      profundidade += contarChar(linhaOriginal, "{") - contarChar(linhaOriginal, "}");
-      while (pilhaClasses.length > 0 && profundidade < pilhaClasses[pilhaClasses.length - 1]!.profundidade) {
-        pilhaClasses.pop();
-      }
-      continue;
-    }
-
-    const classe = linha.match(/\bclass\s+([A-Za-z_]\w*)/);
-    if (classe) {
-      const rotaBase = atributos
-        .filter((atributo) => /@RequestMapping/i.test(atributo))
-        .map((atributo) => extrairCaminhoJava(atributo))
-        .find(Boolean);
-      pilhaClasses.push({
-        nome: classe[1]!,
-        profundidade: profundidade + 1,
-        rotaBase,
-        rest: atributos.some((atributo) => /@RestController/i.test(atributo)),
-      });
-      profundidade += contarChar(linha, "{") - contarChar(linha, "}");
-      while (pilhaClasses.length > 0 && profundidade < pilhaClasses[pilhaClasses.length - 1]!.profundidade) {
-        pilhaClasses.pop();
-      }
-      continue;
-    }
-
-    const classeAtual = pilhaClasses[pilhaClasses.length - 1];
-    const metodo = linha.match(/\b(?:public|protected)\s+(?:static\s+|final\s+)*([A-Za-z0-9_<>,.?[\]\s]+)\s+([A-Za-z_]\w*)\s*\(([^)]*)\)/);
-    if (classeAtual && metodo) {
-      for (const atributo of atributos.filter((item) => /@(Get|Post|Put|Patch|Delete)Mapping|@RequestMapping/i.test(item))) {
-        const metodos = extrairMetodosJava(atributo);
-        const caminho = normalizarCaminhoJava(juntarCaminho(classeAtual.rotaBase, extrairCaminhoJava(atributo)));
-        for (const httpMetodo of metodos) {
-          const registro: RotaJavaExtraida = {
-            origem: "java",
-            metodo: httpMetodo,
-            caminho,
-            simbolo: `${classeAtual.nome}.${metodo[2]!}`,
-            parametros: extrairParametrosRotaJava(caminho, metodo[3] ?? ""),
-            retorno: metodo[1]!.trim(),
-          };
-          rotas.set(`${registro.metodo}:${registro.caminho}:${registro.simbolo}`, registro);
-        }
-      }
-    }
-
-    profundidade += contarChar(linha, "{") - contarChar(linha, "}");
-    while (pilhaClasses.length > 0 && profundidade < pilhaClasses[pilhaClasses.length - 1]!.profundidade) {
-      pilhaClasses.pop();
-    }
-  }
-
-  return [...rotas.values()];
-}

package/src/lua-symbols.ts

@@ -1,114 +0,0 @@
-export interface ParametroLuaExtraido {
-  nome: string;
-  obrigatorio: boolean;
-  tipoTexto?: string;
-}
-
-export interface SimboloLuaExtraido {
-  simbolo: string;
-  parametros: ParametroLuaExtraido[];
-}
-
-const PALAVRAS_RESERVADAS_LUA = new Set([
-  "and",
-  "break",
-  "do",
-  "else",
-  "elseif",
-  "end",
-  "false",
-  "for",
-  "function",
-  "goto",
-  "if",
-  "in",
-  "local",
-  "nil",
-  "not",
-  "or",
-  "repeat",
-  "return",
-  "then",
-  "true",
-  "until",
-  "while",
-]);
-
-function removerComentariosLua(codigo: string): string {
-  return codigo
-    .replace(/--\[\[[\s\S]*?\]\]/g, "")
-    .replace(/--[^\r\n]*/g, "");
-}
-
-function normalizarSimboloLua(simbolo: string): string {
-  return simbolo
-    .replace(/:/g, ".")
-    .replace(/\.+/g, ".")
-    .replace(/^\.+|\.+$/g, "");
-}
-
-function simboloLuaValido(simbolo: string): boolean {
-  const partes = simbolo.split(".").filter(Boolean);
-  return partes.length > 0
-    && partes.every((parte) => /^[A-Za-z_]\w*$/.test(parte) && !PALAVRAS_RESERVADAS_LUA.has(parte));
-}
-
-function dividirParametrosLua(parametros: string): ParametroLuaExtraido[] {
-  return parametros
-    .split(",")
-    .map((item) => item.trim())
-    .filter(Boolean)
-    .filter((item) => item !== "..." && item !== "self")
-    .map((item) => item.replace(/\s*=.*$/, "").trim())
-    .filter((item) => /^[A-Za-z_]\w*$/.test(item))
-    .map((nome) => ({
-      nome,
-      obrigatorio: true,
-    }));
-}
-
-function registrarSimboloLua(
-  simbolos: Map<string, SimboloLuaExtraido>,
-  simboloBruto: string,
-  parametros: string,
-): void {
-  const simbolo = normalizarSimboloLua(simboloBruto);
-  if (!simboloLuaValido(simbolo)) {
-    return;
-  }
-  simbolos.set(simbolo, {
-    simbolo,
-    parametros: dividirParametrosLua(parametros),
-  });
-}
-
-export function extrairSimbolosLua(codigo: string): SimboloLuaExtraido[] {
-  const texto = removerComentariosLua(codigo);
-  const simbolos = new Map<string, SimboloLuaExtraido>();
-
-  for (const match of texto.matchAll(/(?:^|\n)\s*(?:local\s+)?function\s+([A-Za-z_]\w*(?:(?:\.|:)[A-Za-z_]\w*)*)\s*\(([^)]*)\)/g)) {
-    registrarSimboloLua(simbolos, match[1]!, match[2] ?? "");
-  }
-
-  for (const match of texto.matchAll(/(?:^|\n)\s*(?:local\s+)?([A-Za-z_]\w*)\s*=\s*\{([\s\S]*?)^\s*\}/gm)) {
-    const tabela = match[1]!;
-    const corpo = match[2] ?? "";
-    for (const membro of corpo.matchAll(/(?:^|[\s,{])([A-Za-z_]\w*)\s*=\s*function\s*\(([^)]*)\)/g)) {
-      registrarSimboloLua(simbolos, `${tabela}.${membro[1]!}`, membro[2] ?? "");
-    }
-  }
-
-  for (const match of texto.matchAll(/(?:^|\n)\s*([A-Za-z_]\w*(?:(?:\.|:)[A-Za-z_]\w*)*)\s*=\s*function\s*\(([^)]*)\)/g)) {
-    registrarSimboloLua(simbolos, match[1]!, match[2] ?? "");
-  }
-
-  for (const match of texto.matchAll(/(?:^|\n)\s*([A-Za-z_]\w*)\s*\[\s*["']([A-Za-z_]\w*)["']\s*\]\s*=\s*function\s*\(([^)]*)\)/g)) {
-    registrarSimboloLua(simbolos, `${match[1]!}.${match[2]!}`, match[3] ?? "");
-  }
-
-  for (const match of texto.matchAll(/(?:^|[\s,{])([A-Za-z_]\w*)\s*=\s*function\s*\(([^)]*)\)/g)) {
-    registrarSimboloLua(simbolos, match[1]!, match[2] ?? "");
-  }
-
-  return [...simbolos.values()].sort((a, b) => a.simbolo.localeCompare(b.simbolo, "pt-BR"));
-}