@semacode/cli 1.0.0 → 1.2.0

package/dist/importador.js

@@ -9,6 +9,7 @@ import { extrairRotasGo, extrairSimbolosGo } from "./go-http.js";
 import { extrairRotasJava, extrairSimbolosJava } from "./java-http.js";
 import { extrairParametrosCaminhoFlask, extrairRotasFlaskDecoradas } from "./python-http.js";
 import { extrairRotasRust, extrairSimbolosRust } from "./rust-http.js";
+import { extrairSimbolosLua } from "./lua-symbols.js";
 import { extrairRotasTypeScriptHttp, inferirSemanticaHandlerTypeScriptHttp, localizarExportacaoTypeScriptHttp, } from "./typescript-http.js";
 const DIRETORIOS_IGNORADOS = new Set([
     ".git",
@@ -190,6 +191,7 @@ function mapearTipoPrimitivo(tipo) {
     const limpo = tipo.trim().replace(/\s+/g, "");
     const base = limpo
         .replace(/^Promise<(.*)>$/, "$1")
+        .replace(/^Future<(.*)>$/, "$1")
         .replace(/\|undefined/g, "")
         .replace(/\|null/g, "")
         .replace(/\bundefined\|/g, "")
@@ -217,10 +219,22 @@ function mapearTipoPrimitivo(tipo) {
     if (minusculo === "id" || minusculo.endsWith("id")) {
         return "Id";
     }
-    if (minusculo.includes("[]") || minusculo.startsWith("array<") || minusculo.startsWith("record<") || minusculo.startsWith("list[") || minusculo.startsWith("dict[")) {
+    if (minusculo.includes("[]")
+        || minusculo.startsWith("array<")
+        || minusculo.startsWith("record<")
+        || minusculo.startsWith("map<")
+        || minusculo.startsWith("list<")
+        || minusculo.startsWith("list[")
+        || minusculo.startsWith("dict[")) {
         return "Json";
     }
-    if (minusculo === "json" || minusculo === "object" || minusculo === "unknown" || minusculo === "any" || minusculo === "void" || minusculo === "none") {
+    if (minusculo === "json"
+        || minusculo === "object"
+        || minusculo === "unknown"
+        || minusculo === "any"
+        || minusculo === "dynamic"
+        || minusculo === "void"
+        || minusculo === "none") {
         return minusculo === "void" || minusculo === "none" ? "Vazio" : "Json";
     }
     return tipo.trim();
@@ -568,6 +582,624 @@ function resolverEscopoImportacaoNextJs(diretorioEntrada) {
         diretorioEscopo: resolvido,
     };
 }
+function normalizarCaminhoImportado(caminhoArquivo) {
+    return caminhoArquivo.replace(/\\/g, "/");
+}
+function normalizarSegmentoRotaConsumer(segmento) {
+    const opcionalCatchAll = segmento.match(/^\[\[\.\.\.([A-Za-z_]\w*)\]\]$/);
+    if (opcionalCatchAll) {
+        return `{${opcionalCatchAll[1]}}`;
+    }
+    const catchAll = segmento.match(/^\[\.\.\.([A-Za-z_]\w*)\]$/);
+    if (catchAll) {
+        return `{${catchAll[1]}}`;
+    }
+    const dinamico = segmento.match(/^\[([A-Za-z_]\w*)\]$/);
+    if (dinamico) {
+        return `{${dinamico[1]}}`;
+    }
+    return segmento;
+}
+function montarCaminhoRotaConsumer(partes) {
+    const filtradas = partes
+        .filter((segmento) => segmento && segmento !== "index" && !/^\(.*\)$/.test(segmento) && !segmento.startsWith("@"))
+        .map(normalizarSegmentoRotaConsumer);
+    return filtradas.length > 0 ? `/${filtradas.join("/")}`.replace(/\/+/g, "/") : "/";
+}
+function resolverEscopoImportacaoFrontendConsumer(diretorioEntrada) {
+    const resolvido = path.resolve(diretorioEntrada);
+    const partes = path.parse(resolvido);
+    const segmentos = resolvido.slice(partes.root.length).split(path.sep).filter(Boolean);
+    const procurarSequencia = (sequencia) => segmentos.findIndex((segmento, indice) => sequencia.every((item, deslocamento) => segmentos[indice + deslocamento]?.toLowerCase() === item));
+    const montarBase = (indice) => indice <= 0
+        ? partes.root
+        : path.join(partes.root, ...segmentos.slice(0, indice));
+    for (const sequencia of [
+        ["src", "pages"],
+        ["pages"],
+        ["src", "app", "api"],
+        ["app", "api"],
+        ["src", "app"],
+        ["app"],
+        ["src", "lib"],
+        ["lib"],
+    ]) {
+        const indice = procurarSequencia(sequencia);
+        if (indice >= 0) {
+            return {
+                baseProjeto: montarBase(indice),
+                diretorioEscopo: resolvido,
+            };
+        }
+    }
+    return {
+        baseProjeto: resolvido,
+        diretorioEscopo: resolvido,
+    };
+}
+function arquivoEhBridgeNextJsConsumer(relacaoArquivo) {
+    const relacao = normalizarCaminhoImportado(relacaoArquivo);
+    return /(?:^|\/)(?:src\/)?lib\/(?:sema_consumer_bridge|sema\/.+)\.(?:ts|tsx|js|jsx)$/i.test(relacao);
+}
+function arquivoEhBridgeReactViteConsumer(relacaoArquivo) {
+    const relacao = normalizarCaminhoImportado(relacaoArquivo);
+    return /(?:^|\/)(?:src\/)?lib\/(?:sema_consumer_bridge|sema\/.+)\.(?:ts|tsx|js|jsx)$/i.test(relacao);
+}
+function arquivoEhBridgeAngularConsumer(relacaoArquivo) {
+    const relacao = normalizarCaminhoImportado(relacaoArquivo);
+    return /(?:^|\/)(?:src\/)?app\/(?:sema_consumer_bridge|sema\/.+)\.(?:ts|js)$/i.test(relacao);
+}
+function arquivoEhSuperficieNextJsConsumer(relacaoArquivo) {
+    const relacao = normalizarCaminhoImportado(relacaoArquivo);
+    return /(?:^|\/)(?:src\/)?app\/(?:(?!api\/).)*?(?:page|layout|loading|error)\.(?:ts|tsx|js|jsx)$/i.test(relacao);
+}
+function arquivoEhSuperficieReactViteConsumer(relacaoArquivo) {
+    const relacao = normalizarCaminhoImportado(relacaoArquivo);
+    return /^(?:src\/)?pages\/.+\.(?:ts|tsx|js|jsx)$/i.test(relacao)
+        || /^(?:src\/)?App\.(?:ts|tsx|js|jsx)$/i.test(relacao);
+}
+function arquivoEhRotasReactViteConsumer(relacaoArquivo, codigo) {
+    const relacao = normalizarCaminhoImportado(relacaoArquivo);
+    return /(?:^|\/)(?:src\/)?(?:app\/)?(?:router|routes)\.(?:ts|tsx|js|jsx)$/i.test(relacao)
+        || /from\s+["']react-router-dom["']|createBrowserRouter|RouterProvider|useRoutes\s*\(|<Routes\b|<Route\b/.test(codigo ?? "");
+}
+function arquivoEhRotasAngularConsumer(relacaoArquivo) {
+    const relacao = normalizarCaminhoImportado(relacaoArquivo);
+    return /(?:^|\/)(?:src\/)?app(?:\/.+)?\/[^/]+\.routes\.(?:ts|js)$/i.test(relacao);
+}
+function arquivoEhRotasAngularConsumerRaiz(relacaoArquivo) {
+    const relacao = normalizarCaminhoImportado(relacaoArquivo);
+    return /(?:^|\/)(?:src\/)?app\/[^/]+\.routes\.(?:ts|js)$/i.test(relacao);
+}
+function arquivoEhBridgeFlutterConsumer(relacaoArquivo) {
+    const relacao = normalizarCaminhoImportado(relacaoArquivo);
+    return /(?:^|\/)(?:lib\/)?(?:sema_consumer_bridge|api\/sema_contract_bridge|sema\/.+)\.dart$/i.test(relacao);
+}
+function arquivoEhSuperficieFlutterConsumer(relacaoArquivo) {
+    const relacao = normalizarCaminhoImportado(relacaoArquivo);
+    return /(?:^|\/)(?:lib\/)?(?:screens|pages)\/.+\.dart$/i.test(relacao)
+        || /(?:^|\/)(?:lib\/)?main\.dart$/i.test(relacao);
+}
+function arquivoEhRotasFlutterConsumer(relacaoArquivo, codigo) {
+    const relacao = normalizarCaminhoImportado(relacaoArquivo);
+    return /(?:^|\/)(?:lib\/)?(?:router|app_router|routes)\.dart$/i.test(relacao)
+        || /MaterialApp(?:\.router)?\s*\(|CupertinoApp(?:\.router)?\s*\(|GoRouter\s*\(/.test(codigo ?? "");
+}
+function inferirCaminhoNextJsConsumer(relacaoArquivo) {
+    const relacao = normalizarCaminhoImportado(relacaoArquivo);
+    const segmentos = relacao.split("/");
+    const indiceSrcApp = segmentos.findIndex((segmento, indice) => segmento === "src" && segmentos[indice + 1] === "app");
+    const indiceApp = segmentos.findIndex((segmento) => segmento === "app");
+    const inicioApp = indiceSrcApp >= 0 ? indiceSrcApp + 2 : indiceApp >= 0 ? indiceApp + 1 : -1;
+    if (inicioApp < 0) {
+        return undefined;
+    }
+    const arquivoFinal = segmentos.at(-1) ?? "";
+    const tipoArquivo = arquivoFinal.match(/^(page|layout|loading|error)\.(?:ts|tsx|js|jsx)$/)?.[1];
+    if (!tipoArquivo) {
+        return undefined;
+    }
+    const caminhoAteArquivo = segmentos.slice(inicioApp, -1);
+    if (caminhoAteArquivo[0] === "api") {
+        return undefined;
+    }
+    const partes = caminhoAteArquivo
+        .filter((segmento) => segmento);
+    const caminho = montarCaminhoRotaConsumer(partes);
+    return {
+        caminho,
+        arquivo: relacao,
+        tipoArquivo,
+    };
+}
+function inferirCaminhoReactViteConsumer(relacaoArquivo) {
+    const relacao = normalizarCaminhoImportado(relacaoArquivo);
+    if (!arquivoEhSuperficieReactViteConsumer(relacao)) {
+        return undefined;
+    }
+    if (/(?:^|\/)(?:src\/)?App\.(?:ts|tsx|js|jsx)$/i.test(relacao)) {
+        return {
+            caminho: "/",
+            arquivo: relacao,
+            tipoArquivo: "app",
+        };
+    }
+    const segmentos = relacao.split("/");
+    const indiceSrcPages = segmentos.findIndex((segmento, indice) => segmento === "src" && segmentos[indice + 1] === "pages");
+    const indicePages = segmentos.findIndex((segmento) => segmento === "pages");
+    const inicioPages = indiceSrcPages >= 0 ? indiceSrcPages + 2 : indicePages >= 0 ? indicePages + 1 : -1;
+    if (inicioPages < 0) {
+        return undefined;
+    }
+    const arquivoFinal = segmentos.at(-1) ?? "";
+    const nomeBase = arquivoFinal.replace(/\.(?:ts|tsx|js|jsx)$/i, "");
+    const caminho = montarCaminhoRotaConsumer([...segmentos.slice(inicioPages, -1), nomeBase]);
+    return {
+        caminho,
+        arquivo: relacao,
+        tipoArquivo: "page",
+    };
+}
+function inferirCaminhoFlutterConsumer(relacaoArquivo) {
+    const relacao = normalizarCaminhoImportado(relacaoArquivo);
+    if (!arquivoEhSuperficieFlutterConsumer(relacao)) {
+        return undefined;
+    }
+    if (/(?:^|\/)(?:lib\/)?main\.dart$/i.test(relacao)) {
+        return {
+            caminho: "/",
+            arquivo: relacao,
+            tipoArquivo: "app",
+        };
+    }
+    const segmentos = relacao.split("/");
+    const indiceLibScreens = segmentos.findIndex((segmento, indice) => segmento === "lib" && ["screens", "pages"].includes(segmentos[indice + 1] ?? ""));
+    const indiceScreens = segmentos.findIndex((segmento) => segmento === "screens" || segmento === "pages");
+    const inicio = indiceLibScreens >= 0 ? indiceLibScreens + 2 : indiceScreens >= 0 ? indiceScreens + 1 : -1;
+    if (inicio < 0) {
+        return undefined;
+    }
+    const arquivoFinal = segmentos.at(-1) ?? "";
+    const nomeBase = arquivoFinal
+        .replace(/\.(?:dart)$/i, "")
+        .replace(/_(screen|page)$/i, "");
+    return {
+        caminho: montarCaminhoRotaConsumer([...segmentos.slice(inicio, -1), nomeBase]),
+        arquivo: relacao,
+        tipoArquivo: "screen",
+    };
+}
+function normalizarRotaDeclaradaConsumer(caminhoCru, prefixo = "/") {
+    const partesPrefixo = prefixo.replace(/^\/+|\/+$/g, "").split("/").filter(Boolean);
+    const partesCaminho = (caminhoCru ?? "").trim().replace(/^\/+|\/+$/g, "").split("/").filter(Boolean);
+    return montarCaminhoRotaConsumer([...partesPrefixo, ...partesCaminho]);
+}
+function resolverImportRelativoTypeScript(relacaoArquivoBase, especificador) {
+    if (!especificador.startsWith(".")) {
+        return undefined;
+    }
+    const baseDir = path.posix.dirname(normalizarCaminhoImportado(relacaoArquivoBase));
+    for (const sufixo of ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js", "/index.jsx"]) {
+        const candidato = path.posix.normalize(path.posix.join(baseDir, `${especificador}${sufixo}`));
+        if (!/\.(?:ts|tsx|js|jsx)$/i.test(candidato)) {
+            continue;
+        }
+        return candidato;
+    }
+    return undefined;
+}
+function extrairImportsTypeScriptConsumer(relacaoArquivo, codigo) {
+    const imports = new Map();
+    for (const match of codigo.matchAll(/import\s*\{\s*([^}]+)\s*\}\s*from\s*["']([^"']+)["']/g)) {
+        const moduloImportado = match[2];
+        const relacaoImportada = resolverImportRelativoTypeScript(relacaoArquivo, moduloImportado);
+        if (!relacaoImportada) {
+            continue;
+        }
+        for (const bruto of match[1].split(",")) {
+            const normalizado = bruto.trim();
+            if (!normalizado) {
+                continue;
+            }
+            const local = normalizado.split(/\s+as\s+/i).at(-1)?.trim();
+            if (local) {
+                imports.set(local, relacaoImportada);
+            }
+        }
+    }
+    for (const match of codigo.matchAll(/import\s+([A-Za-z_]\w*)\s+from\s*["']([^"']+)["']/g)) {
+        const relacaoImportada = resolverImportRelativoTypeScript(relacaoArquivo, match[2]);
+        const local = match[1]?.trim();
+        if (relacaoImportada && local) {
+            imports.set(local, relacaoImportada);
+        }
+    }
+    return imports;
+}
+function extrairRotasReactViteConsumer(relacaoArquivo, codigo) {
+    const imports = extrairImportsTypeScriptConsumer(relacaoArquivo, codigo);
+    const rotas = new Map();
+    const registrar = (caminhoCru, componente) => {
+        const caminho = normalizarRotaDeclaradaConsumer(caminhoCru);
+        const chave = `${caminho}:${normalizarCaminhoImportado(relacaoArquivo)}:${componente ?? "router"}`;
+        rotas.set(chave, {
+            caminho,
+            arquivoRotas: normalizarCaminhoImportado(relacaoArquivo),
+            arquivoComponente: componente ? imports.get(componente) : undefined,
+        });
+    };
+    for (const match of codigo.matchAll(/(?:path\s*:\s*["'`]([^"'`]*)["'`]|index\s*:\s*true)[\s\S]{0,260}?(?:element\s*:\s*<\s*([A-Za-z_]\w*)|Component\s*:\s*([A-Za-z_]\w*))/g)) {
+        const caminhoCru = match[1] ?? "";
+        const componente = match[2] ?? match[3];
+        registrar(caminhoCru, componente);
+    }
+    for (const match of codigo.matchAll(/<Route\b[^>]*?(?:path=["'`]([^"'`]*)["'`][^>]*?)?(index\b)?[^>]*?(?:element=\{\s*<\s*([A-Za-z_]\w*)|Component=\{\s*([A-Za-z_]\w*))/g)) {
+        const caminhoCru = match[2] ? "" : (match[1] ?? "");
+        const componente = match[3] ?? match[4];
+        registrar(caminhoCru, componente);
+    }
+    return [...rotas.values()];
+}
+function extrairRotasAngularConsumerDiretas(relacaoArquivo, codigo, prefixo = "/") {
+    const imports = extrairImportsTypeScriptConsumer(relacaoArquivo, codigo);
+    const rotas = [];
+    for (const match of codigo.matchAll(/path\s*:\s*["'`]([^"'`]*)["'`][\s\S]{0,320}?component\s*:\s*([A-Za-z_]\w*)/g)) {
+        const caminhoCru = (match[1] ?? "").trim();
+        const componente = match[2];
+        rotas.push({
+            caminho: normalizarRotaDeclaradaConsumer(caminhoCru, prefixo),
+            arquivoRotas: normalizarCaminhoImportado(relacaoArquivo),
+            arquivoComponente: imports.get(componente),
+        });
+    }
+    for (const match of codigo.matchAll(/path\s*:\s*["'`]([^"'`]*)["'`][\s\S]{0,320}?loadComponent\s*:\s*\(\s*\)\s*=>\s*import\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g)) {
+        const caminhoCru = (match[1] ?? "").trim();
+        const relacaoImportada = resolverImportRelativoTypeScript(relacaoArquivo, match[2] ?? "");
+        rotas.push({
+            caminho: normalizarRotaDeclaradaConsumer(caminhoCru, prefixo),
+            arquivoRotas: normalizarCaminhoImportado(relacaoArquivo),
+            arquivoComponente: relacaoImportada,
+        });
+    }
+    for (const match of codigo.matchAll(/path\s*:\s*["'`]([^"'`]*)["'`][\s\S]{0,360}?loadChildren\s*:\s*\(\s*\)\s*=>\s*import\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g)) {
+        const caminhoCru = (match[1] ?? "").trim();
+        const relacaoImportada = resolverImportRelativoTypeScript(relacaoArquivo, match[2] ?? "");
+        rotas.push({
+            caminho: normalizarRotaDeclaradaConsumer(caminhoCru, prefixo),
+            arquivoRotas: normalizarCaminhoImportado(relacaoArquivo),
+            arquivoRotasFilhas: relacaoImportada,
+        });
+    }
+    return rotas;
+}
+async function extrairRotasAngularConsumer(baseProjeto, relacaoArquivo, prefixo = "/", visitados = new Set()) {
+    const relacaoNormalizada = normalizarCaminhoImportado(relacaoArquivo);
+    if (visitados.has(relacaoNormalizada)) {
+        return [];
+    }
+    visitados.add(relacaoNormalizada);
+    const caminhoAbsoluto = path.join(baseProjeto, relacaoNormalizada);
+    let codigo = "";
+    try {
+        codigo = await readFile(caminhoAbsoluto, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const diretas = extrairRotasAngularConsumerDiretas(relacaoNormalizada, codigo, prefixo);
+    const agregadas = [...diretas];
+    for (const rota of diretas) {
+        if (!rota.arquivoRotasFilhas) {
+            continue;
+        }
+        agregadas.push(...await extrairRotasAngularConsumer(baseProjeto, rota.arquivoRotasFilhas, rota.caminho, visitados));
+    }
+    return agregadas;
+}
+function normalizarRotaDeclaradaFlutter(caminhoCru) {
+    return montarCaminhoRotaConsumer((caminhoCru ?? "").trim().replace(/^\/+|\/+$/g, "").split("/").filter(Boolean));
+}
+function extrairRotasFlutterConsumer(relacaoArquivo, codigo) {
+    const rotas = new Map();
+    const registrar = (caminhoCru) => {
+        const caminho = normalizarRotaDeclaradaFlutter(caminhoCru);
+        rotas.set(`${caminho}:${normalizarCaminhoImportado(relacaoArquivo)}`, {
+            caminho,
+            arquivoRotas: normalizarCaminhoImportado(relacaoArquivo),
+        });
+    };
+    for (const match of codigo.matchAll(/GoRoute\s*\([\s\S]{0,220}?path\s*:\s*["'`]([^"'`]+)["'`]/g)) {
+        registrar(match[1] ?? "");
+    }
+    for (const match of codigo.matchAll(/["'`]([^"'`]+)["'`]\s*:\s*\([^)]*\)\s*=>/g)) {
+        registrar(match[1] ?? "");
+    }
+    if (/home\s*:\s*(?:const\s+)?[A-Za-z_]\w*\(/.test(codigo)) {
+        registrar("/");
+    }
+    return [...rotas.values()];
+}
+async function carregarContextosBridgeConsumer(baseProjeto, arquivosBridge) {
+    return Promise.all(arquivosBridge.map(async (arquivo) => {
+        const texto = await readFile(arquivo, "utf8");
+        const scriptKind = arquivo.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+        return {
+            sourceFile: ts.createSourceFile(arquivo, texto, ts.ScriptTarget.Latest, true, scriptKind),
+            texto,
+            relacao: path.relative(baseProjeto, arquivo),
+        };
+    }));
+}
+function extrairTasksBridgeConsumer(baseProjeto, contextosBridge) {
+    const tiposGlobais = consolidarTiposTs(contextosBridge);
+    const entitiesRef = new Set();
+    const enumsRef = new Set();
+    const tasks = [];
+    for (const contexto of contextosBridge) {
+        contexto.sourceFile.forEachChild((node) => {
+            if (ts.isFunctionDeclaration(node) && node.name && node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
+                const nome = node.name.text;
+                const input = node.parameters.flatMap((parametro) => expandirCamposTs(parametro.name.getText(contexto.sourceFile), parametro.type?.getText(contexto.sourceFile), tiposGlobais, entitiesRef, enumsRef, !parametro.questionToken));
+                const output = node.type?.getText(contexto.sourceFile) && mapearTipoPrimitivo(node.type.getText(contexto.sourceFile)) === "Vazio"
+                    ? []
+                    : deduplicarCampos(expandirCamposTs("resultado", node.type?.getText(contexto.sourceFile), tiposGlobais, entitiesRef, enumsRef, false));
+                tasks.push({
+                    nome: nomeTaskBridgeConsumer(nome),
+                    resumo: `Task consumer importada automaticamente de ${contexto.relacao}#${nome}.`,
+                    input: deduplicarCampos(input),
+                    output,
+                    errors: node.body ? extrairErrosTs(node.body, contexto.sourceFile) : [],
+                    effects: node.body ? descreverEfeitosPorHeuristica(node.body.getText(contexto.sourceFile)) : [],
+                    impl: { ts: caminhoImplTs(baseProjeto, path.join(baseProjeto, contexto.relacao), nome) },
+                    vinculos: deduplicarVinculos([
+                        { tipo: "arquivo", valor: normalizarCaminhoImportado(contexto.relacao) },
+                        { tipo: "simbolo", valor: caminhoImplTs(baseProjeto, path.join(baseProjeto, contexto.relacao), nome) },
+                    ]),
+                    origemArquivo: contexto.relacao,
+                    origemSimbolo: nome,
+                });
+            }
+            if (ts.isClassDeclaration(node) && node.name && node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
+                const nomeClasse = node.name.text;
+                for (const member of node.members) {
+                    if (!ts.isMethodDeclaration(member) || !member.name || !member.body) {
+                        continue;
+                    }
+                    if (member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.PrivateKeyword || modifier.kind === ts.SyntaxKind.ProtectedKeyword)) {
+                        continue;
+                    }
+                    const nomeMetodo = member.name.getText(contexto.sourceFile);
+                    if (nomeMetodo === "constructor") {
+                        continue;
+                    }
+                    const input = member.parameters.flatMap((parametro) => expandirCamposTs(parametro.name.getText(contexto.sourceFile), parametro.type?.getText(contexto.sourceFile), tiposGlobais, entitiesRef, enumsRef, !parametro.questionToken));
+                    const output = member.type?.getText(contexto.sourceFile) && mapearTipoPrimitivo(member.type.getText(contexto.sourceFile)) === "Vazio"
+                        ? []
+                        : deduplicarCampos(expandirCamposTs("resultado", member.type?.getText(contexto.sourceFile), tiposGlobais, entitiesRef, enumsRef, false));
+                    const caminhoSimbolo = caminhoImplTs(baseProjeto, path.join(baseProjeto, contexto.relacao), `${nomeClasse}.${nomeMetodo}`);
+                    tasks.push({
+                        nome: nomeTaskBridgeConsumer(nomeMetodo),
+                        resumo: `Task consumer importada automaticamente de ${contexto.relacao}#${nomeClasse}.${nomeMetodo}.`,
+                        input: deduplicarCampos(input),
+                        output,
+                        errors: extrairErrosTs(member.body, contexto.sourceFile),
+                        effects: descreverEfeitosPorHeuristica(member.body.getText(contexto.sourceFile)),
+                        impl: { ts: caminhoSimbolo },
+                        vinculos: deduplicarVinculos([
+                            { tipo: "arquivo", valor: normalizarCaminhoImportado(contexto.relacao) },
+                            { tipo: "simbolo", valor: caminhoSimbolo },
+                        ]),
+                        origemArquivo: contexto.relacao,
+                        origemSimbolo: `${nomeClasse}.${nomeMetodo}`,
+                    });
+                }
+            }
+        });
+    }
+    const { entities, enums } = criarEntidadesReferenciadas(tiposGlobais, entitiesRef, enumsRef);
+    return {
+        tasks,
+        entities,
+        enums,
+    };
+}
+function montarVinculosSuperficiesConsumer(superficies) {
+    return deduplicarVinculos(superficies.flatMap((superficie) => [
+        { tipo: "superficie", valor: superficie.caminho },
+        { tipo: "arquivo", valor: normalizarCaminhoImportado(superficie.arquivo) },
+    ]));
+}
+async function importarConsumerBase(diretorio, namespaceBase, descricaoFramework, ehBridge, coletarSuperficies) {
+    const escopo = resolverEscopoImportacaoFrontendConsumer(diretorio);
+    const arquivos = await listarArquivosRecursivos(escopo.baseProjeto, [".ts", ".tsx", ".js", ".jsx"]);
+    const arquivosBridge = arquivos.filter((arquivo) => ehBridge(path.relative(escopo.baseProjeto, arquivo)));
+    const contextosBridge = await carregarContextosBridgeConsumer(escopo.baseProjeto, arquivosBridge);
+    const { tasks, entities, enums } = extrairTasksBridgeConsumer(escopo.baseProjeto, contextosBridge);
+    const superficiesImportadas = await coletarSuperficies(escopo.baseProjeto, arquivos);
+    const superficies = montarVinculosSuperficiesConsumer(superficiesImportadas);
+    if (tasks.length === 0 && superficies.length === 0) {
+        return [];
+    }
+    const nomeModulo = namespaceBase.endsWith(".consumer")
+        ? namespaceBase
+        : `${namespaceBase}.consumer`;
+    return [{
+            nome: nomeModulo,
+            resumo: `Rascunho Sema importado automaticamente do consumer ${descricaoFramework} em ${escopo.baseProjeto}.`,
+            tasks: deduplicarTarefas(tasks),
+            routes: [],
+            entities,
+            enums,
+            vinculos: superficies,
+        }];
+}
+async function coletarSuperficiesNextJsConsumer(baseProjeto, arquivos) {
+    return arquivos
+        .map((arquivo) => inferirCaminhoNextJsConsumer(path.relative(baseProjeto, arquivo)))
+        .filter((item) => Boolean(item));
+}
+async function coletarSuperficiesReactViteConsumer(baseProjeto, arquivos) {
+    const superficies = [];
+    for (const arquivo of arquivos) {
+        const relacao = path.relative(baseProjeto, arquivo);
+        const codigo = await readFile(arquivo, "utf8");
+        if (arquivoEhRotasReactViteConsumer(relacao, codigo)) {
+            for (const rota of extrairRotasReactViteConsumer(relacao, codigo)) {
+                superficies.push({
+                    caminho: rota.caminho,
+                    arquivo: rota.arquivoRotas,
+                    tipoArquivo: "router",
+                });
+                if (rota.arquivoComponente) {
+                    superficies.push({
+                        caminho: rota.caminho,
+                        arquivo: rota.arquivoComponente,
+                        tipoArquivo: "page",
+                    });
+                }
+            }
+        }
+    }
+    for (const arquivo of arquivos) {
+        const superficie = inferirCaminhoReactViteConsumer(path.relative(baseProjeto, arquivo));
+        if (superficie) {
+            superficies.push(superficie);
+        }
+    }
+    return superficies;
+}
+async function coletarSuperficiesAngularConsumer(baseProjeto, arquivos) {
+    const superficies = [];
+    const arquivosRotas = arquivos.filter((arquivo) => arquivoEhRotasAngularConsumer(path.relative(baseProjeto, arquivo)));
+    const arquivosRaiz = arquivosRotas.filter((arquivo) => arquivoEhRotasAngularConsumerRaiz(path.relative(baseProjeto, arquivo)));
+    const pontosEntrada = arquivosRaiz.length > 0 ? arquivosRaiz : arquivosRotas;
+    for (const arquivoRotas of pontosEntrada) {
+        const relacao = path.relative(baseProjeto, arquivoRotas);
+        for (const rota of await extrairRotasAngularConsumer(baseProjeto, relacao)) {
+            superficies.push({
+                caminho: rota.caminho,
+                arquivo: rota.arquivoRotas,
+                tipoArquivo: "routes",
+            });
+            if (rota.arquivoComponente) {
+                superficies.push({
+                    caminho: rota.caminho,
+                    arquivo: rota.arquivoComponente,
+                    tipoArquivo: "component",
+                });
+            }
+        }
+    }
+    return superficies;
+}
+async function importarNextJsConsumerBase(diretorio, namespaceBase) {
+    return importarConsumerBase(diretorio, namespaceBase, "Next.js", arquivoEhBridgeNextJsConsumer, coletarSuperficiesNextJsConsumer);
+}
+async function importarReactViteConsumerBase(diretorio, namespaceBase) {
+    return importarConsumerBase(diretorio, namespaceBase, "React/Vite", arquivoEhBridgeReactViteConsumer, coletarSuperficiesReactViteConsumer);
+}
+async function importarAngularConsumerBase(diretorio, namespaceBase) {
+    return importarConsumerBase(diretorio, namespaceBase, "Angular", arquivoEhBridgeAngularConsumer, coletarSuperficiesAngularConsumer);
+}
+async function extrairTasksBridgeFlutterConsumer(baseProjeto, arquivosBridge) {
+    const tasks = [];
+    for (const arquivo of arquivosBridge) {
+        const texto = await readFile(arquivo, "utf8");
+        const relacao = path.relative(baseProjeto, arquivo);
+        for (const match of texto.matchAll(/(?:Future<([^\n]+)>|([\w?<>.,\s]+))\s+(\w+)\(([^)]*)\)\s*(?:async\s*)?\{/g)) {
+            const retorno = (match[1] ?? match[2] ?? "").trim();
+            const nome = match[3];
+            if (["build", "toString", "hashCode"].includes(nome)) {
+                continue;
+            }
+            const parametros = match[4];
+            const input = parametros
+                .split(",")
+                .map((item) => item.trim())
+                .filter(Boolean)
+                .map((item) => item.replace(/^(required|final)\s+/g, ""))
+                .map((item) => {
+                const partes = item.split(/\s+/).filter(Boolean);
+                const nomeParametro = partes.at(-1) ?? "arg";
+                const tipoParametro = partes.slice(0, -1).join(" ");
+                return {
+                    nome: paraSnakeCase(nomeParametro),
+                    tipo: mapearTipoPrimitivo(tipoParametro || "Json"),
+                    obrigatorio: !/\?/.test(tipoParametro),
+                };
+            });
+            const caminhoSimbolo = caminhoImplDart(baseProjeto, arquivo, nome);
+            tasks.push({
+                nome: nomeTaskBridgeConsumer(nome),
+                resumo: `Task consumer importada automaticamente de ${relacao}#${nome}.`,
+                input,
+                output: retorno && mapearTipoPrimitivo(retorno) === "Vazio"
+                    ? []
+                    : [{ nome: "resultado", tipo: mapearTipoPrimitivo(retorno || "Json"), obrigatorio: false }],
+                errors: [],
+                effects: descreverEfeitosPorHeuristica(texto),
+                impl: { dart: caminhoSimbolo },
+                vinculos: deduplicarVinculos([
+                    { tipo: "arquivo", valor: normalizarCaminhoImportado(relacao) },
+                    { tipo: "simbolo", valor: caminhoSimbolo },
+                ]),
+                origemArquivo: relacao,
+                origemSimbolo: nome,
+            });
+        }
+    }
+    return tasks;
+}
+async function coletarSuperficiesFlutterConsumer(baseProjeto, arquivos) {
+    const superficies = [];
+    for (const arquivo of arquivos) {
+        const relacao = path.relative(baseProjeto, arquivo);
+        const codigo = await readFile(arquivo, "utf8");
+        if (arquivoEhRotasFlutterConsumer(relacao, codigo)) {
+            for (const rota of extrairRotasFlutterConsumer(relacao, codigo)) {
+                superficies.push({
+                    caminho: rota.caminho,
+                    arquivo: rota.arquivoRotas,
+                    tipoArquivo: "router",
+                });
+            }
+        }
+    }
+    for (const arquivo of arquivos) {
+        const superficie = inferirCaminhoFlutterConsumer(path.relative(baseProjeto, arquivo));
+        if (superficie) {
+            superficies.push(superficie);
+        }
+    }
+    return superficies;
+}
+async function importarFlutterConsumerBase(diretorio, namespaceBase) {
+    const escopo = resolverEscopoImportacaoFrontendConsumer(diretorio);
+    const arquivos = (await listarArquivosRecursivos(escopo.baseProjeto, [".dart"]))
+        .filter((arquivo) => !arquivo.endsWith(".g.dart") && !arquivo.endsWith(".freezed.dart"));
+    const arquivosBridge = arquivos.filter((arquivo) => arquivoEhBridgeFlutterConsumer(path.relative(escopo.baseProjeto, arquivo)));
+    const tasks = await extrairTasksBridgeFlutterConsumer(escopo.baseProjeto, arquivosBridge);
+    const superficiesImportadas = await coletarSuperficiesFlutterConsumer(escopo.baseProjeto, arquivos);
+    const superficies = montarVinculosSuperficiesConsumer(superficiesImportadas);
+    if (tasks.length === 0 && superficies.length === 0) {
+        return [];
+    }
+    const nomeModulo = namespaceBase.endsWith(".consumer")
+        ? namespaceBase
+        : `${namespaceBase}.consumer`;
+    return [{
+            nome: nomeModulo,
+            resumo: `Rascunho Sema importado automaticamente do consumer Flutter em ${escopo.baseProjeto}.`,
+            tasks: deduplicarTarefas(tasks),
+            routes: [],
+            entities: [],
+            enums: [],
+            vinculos: superficies,
+        }];
+}
+function nomeTaskBridgeConsumer(nome) {
+    return paraSnakeCase(nome.replace(/^sema/, "")) || paraSnakeCase(nome) || "task_consumer";
+}
 function extrairChamadaServiceTs(node) {
     let encontrado;
     const visitar = (atual) => {
@@ -614,6 +1246,16 @@ function deduplicarEfeitos(effects) {
     }
     return [...mapa.values()];
 }
+function deduplicarVinculos(vinculos) {
+    const mapa = new Map();
+    for (const vinculo of vinculos) {
+        const chave = `${vinculo.tipo}:${vinculo.valor}`;
+        if (!mapa.has(chave)) {
+            mapa.set(chave, vinculo);
+        }
+    }
+    return [...mapa.values()];
+}
 function deduplicarEntidades(entities) {
     const mapa = new Map();
     for (const entity of entities) {
@@ -644,6 +1286,7 @@ function deduplicarTarefas(tasks) {
         existente.output = deduplicarCampos([...existente.output, ...task.output]);
         existente.errors = deduplicarErros([...existente.errors, ...task.errors]);
         existente.effects = deduplicarEfeitos([...existente.effects, ...task.effects]);
+        existente.vinculos = deduplicarVinculos([...(existente.vinculos ?? []), ...(task.vinculos ?? [])]);
     }
     return [...mapa.values()];
 }
@@ -714,6 +1357,7 @@ 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.cs ? [`${indentacao}  cs: ${impl.cs}`] : []),
         ...(impl.java ? [`${indentacao}  java: ${impl.java}`] : []),
         ...(impl.go ? [`${indentacao}  go: ${impl.go}`] : []),
@@ -723,6 +1367,26 @@ function renderizarImpl(impl, indentacao = "  ") {
         "",
     ];
 }
+function renderizarValorVinculo(vinculo) {
+    if (vinculo.tipo === "simbolo") {
+        return vinculo.valor;
+    }
+    if (vinculo.tipo === "arquivo" || vinculo.valor.includes("/") || vinculo.valor.includes("\\") || vinculo.valor.includes("{")) {
+        return `"${escaparTexto(vinculo.valor)}"`;
+    }
+    return vinculo.valor;
+}
+function renderizarVinculos(vinculos, indentacao = "  ") {
+    if (!vinculos || vinculos.length === 0) {
+        return [];
+    }
+    return [
+        `${indentacao}vinculos {`,
+        ...vinculos.map((vinculo) => `${indentacao}  ${vinculo.tipo}: ${renderizarValorVinculo(vinculo)}`),
+        `${indentacao}}`,
+        "",
+    ];
+}
 function renderizarTask(task) {
     const linhas = [
         `  task ${task.nome} {`,
@@ -734,6 +1398,7 @@ function renderizarTask(task) {
         ...renderizarCampos("output", task.output, "    ", true),
         ...renderizarEffects(task.effects, "    "),
         ...renderizarImpl(task.impl, "    "),
+        ...renderizarVinculos(task.vinculos, "    "),
         ...renderizarErrors(task.errors, "    "),
     ];
     linhas.push("    guarantees {");
@@ -791,6 +1456,7 @@ function moduloParaCodigo(modulo) {
         `    resumo: "${escaparTexto(modulo.resumo)}"`,
         "  }",
         "",
+        ...renderizarVinculos(modulo.vinculos, "  "),
         ...modulo.enums.flatMap(renderizarEnum),
         ...modulo.entities.flatMap(renderizarEntidade),
         ...modulo.tasks.flatMap(renderizarTask),
@@ -1369,6 +2035,14 @@ function caminhoImplPython(diretorioBase, arquivo, simbolo) {
 function caminhoImplDart(diretorioBase, arquivo, simbolo) {
     return caminhoImplGenerico(diretorioBase, arquivo, simbolo);
 }
+function caminhoImplLua(diretorioBase, arquivo, simbolo) {
+    const caminhoBase = caminhoImplGenerico(diretorioBase, arquivo, "");
+    const ultimoSegmentoArquivo = caminhoBase.split(".").filter(Boolean).at(-1);
+    const simboloNormalizado = ultimoSegmentoArquivo && simbolo.startsWith(`${ultimoSegmentoArquivo}.`)
+        ? simbolo.slice(ultimoSegmentoArquivo.length + 1)
+        : simbolo;
+    return [...caminhoBase.split(".").filter(Boolean), simboloNormalizado].filter(Boolean).join(".");
+}
 function dividirParametrosPython(parametros) {
     const partes = [];
     let atual = "";
@@ -1672,7 +2346,54 @@ async function importarDartBase(diretorio, namespaceBase) {
     }
     return modulos;
 }
-function criarModuloImportadoSimples(nome, resumo, tasks, routes = []) {
+async function importarLuaBase(diretorio, namespaceBase) {
+    const arquivos = (await listarArquivosRecursivos(diretorio, [".lua"]))
+        .filter((arquivo) => !/(^|[\\/])(spec|specs|test|tests)([\\/]|$)/i.test(arquivo))
+        .filter((arquivo) => !/[_-](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, { preservarUltimo: true });
+        const nomeModulo = [namespaceBase, ...contextoSegmentos].join(".");
+        const tasks = [];
+        for (const simbolo of extrairSimbolosLua(texto)) {
+            const nomeBase = simbolo.simbolo.split(".").at(-1) ?? simbolo.simbolo;
+            const input = simbolo.parametros.map((parametro) => ({
+                nome: normalizarNomeCampoImportado(parametro.nome),
+                tipo: "Json",
+                obrigatorio: parametro.obrigatorio,
+            }));
+            const output = /\breturn\b/.test(texto)
+                ? [{ nome: "resultado", tipo: "Json", obrigatorio: false }]
+                : [];
+            tasks.push({
+                nome: paraSnakeCase(nomeBase),
+                resumo: `Task importada automaticamente de ${relacao}#${simbolo.simbolo}.`,
+                input,
+                output,
+                errors: [],
+                effects: descreverEfeitosPorHeuristica(texto),
+                impl: { lua: caminhoImplLua(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: [],
+        });
+    }
+    return modulos;
+}
+function criarModuloImportadoSimples(nome, resumo, tasks, routes = [], vinculos = []) {
     sincronizarRotasComTasks(routes, tasks);
     return {
         nome,
@@ -1681,6 +2402,7 @@ function criarModuloImportadoSimples(nome, resumo, tasks, routes = []) {
         routes: deduplicarRotas(routes),
         entities: [],
         enums: [],
+        vinculos: deduplicarVinculos(vinculos),
     };
 }
 function acumularModuloImportado(modulos, modulo) {
@@ -1693,6 +2415,7 @@ function acumularModuloImportado(modulos, modulo) {
     existente.routes = deduplicarRotas([...existente.routes, ...modulo.routes]);
     existente.entities = deduplicarEntidades([...existente.entities, ...modulo.entities]);
     existente.enums = deduplicarEnums([...existente.enums, ...modulo.enums]);
+    existente.vinculos = deduplicarVinculos([...(existente.vinculos ?? []), ...(modulo.vinculos ?? [])]);
 }
 function selecionarSimbolosPreferidos(simbolos) {
     const mapa = new Map();
@@ -2029,6 +2752,18 @@ export async function importarProjetoLegado(fonte, diretorio, namespaceBase) {
     else if (fonte === "nextjs") {
         modulos = await importarNextJsBase(base, namespace);
     }
+    else if (fonte === "nextjs-consumer") {
+        modulos = await importarNextJsConsumerBase(base, namespace);
+    }
+    else if (fonte === "react-vite-consumer") {
+        modulos = await importarReactViteConsumerBase(base, namespace);
+    }
+    else if (fonte === "angular-consumer") {
+        modulos = await importarAngularConsumerBase(base, namespace);
+    }
+    else if (fonte === "flutter-consumer") {
+        modulos = await importarFlutterConsumerBase(base, namespace);
+    }
     else if (fonte === "firebase") {
         modulos = await importarFirebaseBase(base, namespace);
     }
@@ -2047,6 +2782,9 @@ 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 === "dotnet") {
         modulos = await importarDotnetBase(base, namespace);
     }