@semacode/cli 1.5.9 → 1.5.11

package/dist/importador.d.ts

@@ -1,5 +1,5 @@
 import { type Diagnostico } from "@sema/nucleo";
-export type FonteImportacao = "nestjs" | "fastapi" | "flask" | "nextjs" | "nextjs-consumer" | "react-vite-consumer" | "angular-consumer" | "flutter-consumer" | "firebase" | "typescript" | "python" | "dart" | "dotnet" | "java" | "go" | "rust" | "cpp";
+export type FonteImportacao = "nestjs" | "fastapi" | "flask" | "nextjs" | "nextjs-consumer" | "react-vite-consumer" | "angular-consumer" | "flutter-consumer" | "firebase" | "typescript" | "python" | "dart" | "lua" | "php" | "dotnet" | "java" | "go" | "rust" | "cpp";
 export interface ArquivoImportado {
     caminhoRelativo: string;
     conteudo: string;

package/dist/importador.js

@@ -7,6 +7,8 @@ import { extrairSimbolosCpp } from "./cpp-symbols.js";
 import { extrairRotasDotnet, extrairSimbolosDotnet } from "./dotnet-http.js";
 import { extrairRotasGo, extrairSimbolosGo } from "./go-http.js";
 import { extrairRotasJava, extrairSimbolosJava } from "./java-http.js";
+import { extrairSimbolosLua } from "./lua-symbols.js";
+import { extrairRotasPhp, extrairSimbolosPhp } from "./php-symbols.js";
 import { extrairParametrosCaminhoFlask, extrairRotasFlaskDecoradas } from "./python-http.js";
 import { extrairRotasRust, extrairSimbolosRust } from "./rust-http.js";
 import { extrairRotasTypeScriptHttp, inferirSemanticaHandlerTypeScriptHttp, localizarExportacaoTypeScriptHttp, } from "./typescript-http.js";
@@ -245,6 +247,7 @@ function limparTipoBackend(tipo) {
     }
     return tipo
         .trim()
+        .replace(/^\?/, "")
         .replace(/^Task<(.+)>$/i, "$1")
         .replace(/^ActionResult<(.+)>$/i, "$1")
         .replace(/^IActionResult$/i, "Json")
@@ -258,7 +261,10 @@ function limparTipoBackend(tipo) {
         .replace(/^Vec<(.+)>$/i, "Json")
         .replace(/^List<(.+)>$/i, "Json")
         .replace(/^Map<(.+)>$/i, "Json")
-        .replace(/^Dictionary<(.+)>$/i, "Json");
+        .replace(/^Dictionary<(.+)>$/i, "Json")
+        .replace(/\|null$/i, "")
+        .replace(/^null\|/i, "")
+        .replace(/^(array|mixed|object)$/i, "Json");
 }
 function mapearTipoBackendParaSema(tipo) {
     const limpo = limparTipoBackend(tipo);
@@ -1464,6 +1470,8 @@ function renderizarImpl(impl, indentacao = "  ") {
         ...(impl.ts ? [`${indentacao}  ts: ${impl.ts}`] : []),
         ...(impl.py ? [`${indentacao}  py: ${impl.py}`] : []),
         ...(impl.dart ? [`${indentacao}  dart: ${impl.dart}`] : []),
+        ...(impl.lua ? [`${indentacao}  lua: ${impl.lua}`] : []),
+        ...(impl.php ? [`${indentacao}  php: ${impl.php}`] : []),
         ...(impl.cs ? [`${indentacao}  cs: ${impl.cs}`] : []),
         ...(impl.java ? [`${indentacao}  java: ${impl.java}`] : []),
         ...(impl.go ? [`${indentacao}  go: ${impl.go}`] : []),
@@ -2183,6 +2191,27 @@ function extrairErrosPython(texto) {
     }
     return [...erros.entries()].map(([nome, mensagem]) => ({ nome, mensagem }));
 }
+function extrairErrosLua(texto) {
+    const erros = new Map();
+    for (const match of texto.matchAll(/\berror\s*\(\s*(?:(["'])(.*?)\1|([A-Za-z_]\w*))/g)) {
+        const mensagem = match[2] ?? `Erro importado automaticamente de ${match[3] ?? "error"}.`;
+        erros.set(normalizarNomeErroBruto(mensagem), mensagem);
+    }
+    return [...erros.entries()].map(([nome, mensagem]) => ({ nome, mensagem }));
+}
+function extrairErrosPhp(texto) {
+    const erros = new Map();
+    for (const match of texto.matchAll(/\bthrow\s+new\s+([A-Za-z_\\][A-Za-z0-9_\\]*)\s*\(([^)]*)\)/g)) {
+        const nomeBruto = match[1].split("\\").at(-1) ?? match[1];
+        const mensagem = (match[2] ?? "").match(/["']([^"']+)["']/)?.[1] ?? `Erro importado automaticamente de ${nomeBruto}.`;
+        erros.set(normalizarNomeErroBruto(nomeBruto), mensagem);
+    }
+    for (const match of texto.matchAll(/\babort\s*\(\s*(\d{3})(?:\s*,\s*["']([^"']+)["'])?/g)) {
+        const mensagem = match[2] ?? `Abort HTTP ${match[1]}.`;
+        erros.set(`http_${match[1]}`, mensagem);
+    }
+    return [...erros.entries()].map(([nome, mensagem]) => ({ nome, mensagem }));
+}
 function caminhoImplGenerico(diretorioBase, arquivo, simbolo, opcoes) {
     const relativo = path.relative(diretorioBase, arquivo).replace(/\.[^.]+$/, "");
     const segmentos = relativo.split(path.sep).map((segmento, indice, lista) => opcoes?.snakeCaseUltimoArquivo && indice === lista.length - 1
@@ -2197,6 +2226,62 @@ function caminhoImplPython(diretorioBase, arquivo, simbolo) {
 function caminhoImplDart(diretorioBase, arquivo, simbolo) {
     return caminhoImplGenerico(diretorioBase, arquivo, simbolo);
 }
+function caminhoImplPhp(diretorioBase, arquivo, simbolo) {
+    return simbolo.includes(".")
+        ? simbolo
+        : caminhoImplGenerico(diretorioBase, arquivo, simbolo);
+}
+const NOMES_RESERVADOS_TASK_IMPORTADA = new Set([
+    "database",
+    "table",
+    "view",
+    "query",
+    "transaction",
+    "index",
+    "constraint",
+    "relationship",
+    "collection",
+    "document",
+    "keyspace",
+    "stream",
+    "lock",
+    "retention",
+    "replication",
+    "input",
+    "output",
+    "rules",
+    "effects",
+    "impl",
+    "vinculos",
+    "execucao",
+    "auth",
+    "authz",
+    "dados",
+    "audit",
+    "segredos",
+    "forbidden",
+    "guarantees",
+    "state",
+    "tests",
+    "error",
+    "flow",
+    "route",
+    "worker",
+    "evento",
+    "fila",
+    "cron",
+    "webhook",
+    "cache",
+    "storage",
+    "policy",
+    "when",
+    "given",
+    "expect",
+]);
+function normalizarNomeTaskImportada(valor) {
+    const nome = paraSnakeCase(valor) || "task_importada";
+    return NOMES_RESERVADOS_TASK_IMPORTADA.has(nome) ? `${nome}_task` : nome;
+}
 function dividirParametrosPython(parametros) {
     const partes = [];
     let atual = "";
@@ -2500,6 +2585,114 @@ async function importarDartBase(diretorio, namespaceBase) {
     }
     return modulos;
 }
+async function importarLuaBase(diretorio, namespaceBase) {
+    const arquivos = (await listarArquivosRecursivos(diretorio, [".lua"]))
+        .filter((arquivo) => !/(^|[\\/])tests?([\\/]|$)|(?:^|[\\/])spec([\\/]|$)|(?:_spec|_test)\.lua$/i.test(arquivo));
+    const modulos = [];
+    for (const arquivo of arquivos) {
+        const texto = await readFile(arquivo, "utf8");
+        const relacao = path.relative(diretorio, arquivo);
+        const contextoSegmentos = inferirContextoPorArquivo(relacao);
+        const nomeModulo = [namespaceBase, ...contextoSegmentos].join(".");
+        const tasks = [];
+        for (const simbolo of selecionarSimbolosPreferidos(extrairSimbolosLua(texto))) {
+            const nomeBase = simbolo.simbolo.split(".").at(-1) ?? simbolo.simbolo;
+            tasks.push({
+                nome: paraSnakeCase(nomeBase),
+                resumo: `Task importada automaticamente de ${relacao}#${simbolo.simbolo}.`,
+                input: simbolo.parametros.map((parametro) => ({
+                    nome: normalizarNomeCampoImportado(parametro.nome),
+                    tipo: mapearTipoPrimitivo(parametro.tipoTexto ?? "Json"),
+                    obrigatorio: parametro.obrigatorio,
+                })),
+                output: [{ nome: "resultado", tipo: "Json", obrigatorio: false }],
+                errors: extrairErrosLua(texto),
+                effects: descreverEfeitosPorHeuristica(texto),
+                impl: { lua: caminhoImplGenerico(diretorio, arquivo, simbolo.simbolo) },
+                origemArquivo: relacao,
+                origemSimbolo: simbolo.simbolo,
+            });
+        }
+        if (tasks.length === 0) {
+            continue;
+        }
+        modulos.push({
+            nome: nomeModulo,
+            resumo: `Rascunho Sema importado automaticamente de ${relacao}.`,
+            tasks: deduplicarTarefas(tasks),
+            routes: [],
+            entities: [],
+            enums: [],
+            databases: inferirDatabasesPorHeuristica(texto, relacao),
+        });
+    }
+    return modulos;
+}
+async function importarPhpBase(diretorio, namespaceBase) {
+    const arquivos = (await listarArquivosRecursivos(diretorio, [".php"]))
+        .filter((arquivo) => !/(^|[\\/])tests?([\\/]|$)|(?:^|[\\/])spec([\\/]|$)|(?:Test|Spec)\.php$/i.test(arquivo));
+    const modulos = new Map();
+    for (const arquivo of arquivos) {
+        const texto = await readFile(arquivo, "utf8");
+        const relacao = path.relative(diretorio, arquivo);
+        const contextoSegmentos = inferirContextoPorArquivo(relacao);
+        const nomeModulo = [namespaceBase, ...contextoSegmentos].join(".");
+        const tasks = [];
+        const routes = [];
+        for (const simbolo of selecionarSimbolosPreferidos(extrairSimbolosPhp(texto))) {
+            const nomeBase = simbolo.simbolo.split(".").at(-1) ?? simbolo.simbolo;
+            tasks.push({
+                nome: normalizarNomeTaskImportada(nomeBase),
+                resumo: `Task importada automaticamente de ${relacao}#${simbolo.simbolo}.`,
+                input: simbolo.parametros.map((parametro) => ({
+                    nome: normalizarNomeCampoImportado(parametro.nome),
+                    tipo: mapearTipoBackendParaSema(parametro.tipoTexto),
+                    obrigatorio: parametro.obrigatorio,
+                })),
+                output: criarCampoResultadoBackend(simbolo.retorno),
+                errors: extrairErrosPhp(texto),
+                effects: descreverEfeitosPorHeuristica(texto),
+                impl: { php: caminhoImplPhp(diretorio, arquivo, simbolo.simbolo) },
+                origemArquivo: relacao,
+                origemSimbolo: simbolo.simbolo,
+            });
+        }
+        for (const rota of extrairRotasPhp(texto)) {
+            const taskNome = normalizarNomeTaskImportada(rota.simbolo.split(".").at(-1) ?? rota.simbolo);
+            const output = rota.retorno ? criarCampoResultadoBackend(rota.retorno) : [{ nome: "resultado", tipo: "Json", obrigatorio: false }];
+            const nomeBase = `${taskNome}_publico`;
+            const nome = routes.some((route) => route.nome === nomeBase)
+                ? `${taskNome}_${rota.metodo.toLowerCase()}_publico`
+                : nomeBase;
+            tasks.push({
+                nome: taskNome,
+                resumo: `Task HTTP PHP importada automaticamente de ${relacao}#${rota.simbolo}.`,
+                input: camposDeParametrosRotaBackend(rota.parametros),
+                output,
+                errors: extrairErrosPhp(texto),
+                effects: [{ categoria: "consulta", alvo: "http", criticidade: "media" }],
+                impl: { php: caminhoImplPhp(diretorio, arquivo, rota.simbolo) },
+                origemArquivo: relacao,
+                origemSimbolo: rota.simbolo,
+            });
+            routes.push({
+                nome,
+                resumo: `Rota PHP importada automaticamente de ${relacao}#${rota.simbolo}.`,
+                metodo: rota.metodo,
+                caminho: rota.caminho,
+                task: taskNome,
+                input: camposDeParametrosRotaBackend(rota.parametros),
+                output,
+                errors: [],
+            });
+        }
+        if (tasks.length === 0 && routes.length === 0) {
+            continue;
+        }
+        acumularModuloImportado(modulos, criarModuloImportadoSimples(nomeModulo, `Rascunho Sema importado automaticamente de ${relacao}.`, tasks, routes, [], inferirDatabasesPorHeuristica(texto, relacao)));
+    }
+    return [...modulos.values()];
+}
 function criarModuloImportadoSimples(nome, resumo, tasks, routes = [], vinculos = [], databases = []) {
     sincronizarRotasComTasks(routes, tasks);
     return {
@@ -2891,6 +3084,12 @@ export async function importarProjetoLegado(fonte, diretorio, namespaceBase) {
     else if (fonte === "dart") {
         modulos = await importarDartBase(base, namespace);
     }
+    else if (fonte === "lua") {
+        modulos = await importarLuaBase(base, namespace);
+    }
+    else if (fonte === "php") {
+        modulos = await importarPhpBase(base, namespace);
+    }
     else if (fonte === "dotnet") {
         modulos = await importarDotnetBase(base, namespace);
     }