@semacode/cli 1.5.14 → 1.5.16

package/src/java-http.ts

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

@@ -0,0 +1,114 @@
+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"));
+}