@semacode/cli 0.8.2

package/dist/importador.js

@@ -0,0 +1,2094 @@
+import { access, readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import ts from "typescript";
+import { compilarProjeto, formatarCodigo, temErros } from "@sema/nucleo";
+import { normalizarSegmentoModulo } from "@sema/padroes";
+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 { extrairParametrosCaminhoFlask, extrairRotasFlaskDecoradas } from "./python-http.js";
+import { extrairRotasRust, extrairSimbolosRust } from "./rust-http.js";
+import { extrairRotasTypeScriptHttp, inferirSemanticaHandlerTypeScriptHttp, localizarExportacaoTypeScriptHttp, } from "./typescript-http.js";
+const DIRETORIOS_IGNORADOS = new Set([
+    ".git",
+    ".hg",
+    ".svn",
+    ".gradle",
+    ".cargo",
+    "node_modules",
+    "dist",
+    "build",
+    "bin",
+    "obj",
+    ".next",
+    ".nuxt",
+    ".dart_tool",
+    "__pycache__",
+    ".venv",
+    "venv",
+    "coverage",
+    ".tmp",
+    "generated",
+    "vendor",
+    "ephemeral",
+]);
+const SUFIXOS_WRAPPER = ["Entrada", "Saida", "Dto", "Request", "Response", "Payload", "Body", "Input", "Output"];
+const NOMES_RESERVADOS_CAMPO = new Set([
+    "module",
+    "use",
+    "type",
+    "entity",
+    "enum",
+    "task",
+    "input",
+    "output",
+    "rules",
+    "effects",
+    "impl",
+    "guarantees",
+    "state",
+    "flow",
+    "route",
+    "tests",
+    "error",
+    "docs",
+    "comments",
+    "fields",
+    "invariants",
+    "transitions",
+    "given",
+    "when",
+    "expect",
+    "caso",
+    "required",
+]);
+function escaparTexto(texto) {
+    return texto.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function paraSnakeCase(valor) {
+    return valor
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .replace(/[^A-Za-z0-9_]+/g, "_")
+        .replace(/_{2,}/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .toLowerCase();
+}
+function paraIdentificadorModulo(valor) {
+    return normalizarSegmentoModulo(valor).replace(/_+/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
+}
+function normalizarNomeCampoImportado(valor) {
+    const normalizado = paraSnakeCase(valor);
+    return NOMES_RESERVADOS_CAMPO.has(normalizado)
+        ? `${normalizado}_campo`
+        : normalizado;
+}
+function nomeProjetoPadrao(diretorio) {
+    const base = path.basename(diretorio);
+    if (["src", "app", "api", "backend", "server"].includes(base.toLowerCase())) {
+        return `${path.basename(path.dirname(diretorio))}.${base}`;
+    }
+    return base;
+}
+export function inferirNamespaceBase(diretorio, namespaceExplicito) {
+    if (namespaceExplicito) {
+        return namespaceExplicito
+            .split(".")
+            .map((segmento) => paraIdentificadorModulo(segmento))
+            .filter(Boolean)
+            .join(".");
+    }
+    return ["legado", ...nomeProjetoPadrao(diretorio).split(/[\\/._-]+/g)]
+        .map((segmento) => paraIdentificadorModulo(segmento))
+        .filter(Boolean)
+        .join(".");
+}
+async function listarArquivosRecursivos(diretorio, extensoes) {
+    const entradas = await readdir(diretorio, { withFileTypes: true });
+    const encontrados = [];
+    for (const entrada of entradas) {
+        if (DIRETORIOS_IGNORADOS.has(entrada.name)) {
+            continue;
+        }
+        const caminhoAtual = path.join(diretorio, entrada.name);
+        if (entrada.isDirectory()) {
+            encontrados.push(...await listarArquivosRecursivos(caminhoAtual, extensoes));
+            continue;
+        }
+        if (extensoes.some((extensao) => entrada.name.endsWith(extensao))) {
+            encontrados.push(caminhoAtual);
+        }
+    }
+    return encontrados.sort((a, b) => a.localeCompare(b, "pt-BR"));
+}
+function inferirContextoPorArquivo(relacao, opcoes) {
+    const semExtensao = relacao.replace(/\.[^.]+$/, "");
+    const segmentosOriginais = semExtensao.split(path.sep).filter(Boolean);
+    const segmentos = segmentosOriginais.map((segmento) => paraIdentificadorModulo(segmento)).filter(Boolean);
+    if (segmentos[0] === "src" || segmentos[0] === "app") {
+        segmentos.shift();
+        segmentosOriginais.shift();
+    }
+    const ultimo = segmentos.at(-1) ?? "";
+    const semSufixo = ultimo
+        .replace(/(\.controller|\.service|\.module|_router|_service|_schemas|_contract)$/g, "")
+        .replace(/(controller|service|module|router|schemas|contract)$/g, "")
+        .replace(/_+$/g, "");
+    if (segmentos.length === 0) {
+        return ["importado"];
+    }
+    if (!opcoes?.preservarUltimo && semSufixo && semSufixo !== ultimo) {
+        segmentos[segmentos.length - 1] = semSufixo;
+    }
+    if (opcoes?.snakeCaseUltimo && segmentos.length > 0) {
+        segmentos[segmentos.length - 1] = paraSnakeCase(segmentosOriginais[segmentosOriginais.length - 1] ?? ultimo);
+    }
+    if (segmentos.length > 1 && segmentos[segmentos.length - 1] === segmentos[segmentos.length - 2]) {
+        segmentos.pop();
+    }
+    return segmentos;
+}
+function juntarCaminhoHttp(base, sufixo) {
+    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 extrairTextoLiteral(expr) {
+    if (!expr) {
+        return undefined;
+    }
+    if (ts.isStringLiteralLike(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) {
+        return expr.text;
+    }
+    if (ts.isNumericLiteral(expr)) {
+        return expr.text;
+    }
+    return undefined;
+}
+function listarDecoradores(node) {
+    return ts.canHaveDecorators(node) ? ts.getDecorators(node) ?? [] : [];
+}
+function lerDecorator(node, nomes) {
+    for (const decorator of listarDecoradores(node)) {
+        const expressao = decorator.expression;
+        if (ts.isCallExpression(expressao)) {
+            const alvo = expressao.expression;
+            if (ts.isIdentifier(alvo) && nomes.includes(alvo.text)) {
+                return { nome: alvo.text, argumentos: expressao.arguments };
+            }
+        }
+        else if (ts.isIdentifier(expressao) && nomes.includes(expressao.text)) {
+            return { nome: expressao.text, argumentos: ts.factory.createNodeArray() };
+        }
+    }
+    return undefined;
+}
+function mapearTipoPrimitivo(tipo) {
+    const limpo = tipo.trim().replace(/\s+/g, "");
+    const base = limpo
+        .replace(/^Promise<(.*)>$/, "$1")
+        .replace(/\|undefined/g, "")
+        .replace(/\|null/g, "")
+        .replace(/\bundefined\|/g, "")
+        .replace(/\bnull\|/g, "")
+        .trim();
+    const minusculo = base.toLowerCase();
+    if (minusculo === "string" || minusculo === "texto") {
+        return "Texto";
+    }
+    if (minusculo === "number" || minusculo === "float" || minusculo === "double") {
+        return "Decimal";
+    }
+    if (minusculo === "int" || minusculo === "integer" || minusculo === "inteiro") {
+        return "Inteiro";
+    }
+    if (minusculo === "boolean" || minusculo === "bool") {
+        return "Booleano";
+    }
+    if (minusculo === "date") {
+        return "Data";
+    }
+    if (minusculo === "datetime" || minusculo === "timestamp") {
+        return "DataHora";
+    }
+    if (minusculo === "id" || minusculo.endsWith("id")) {
+        return "Id";
+    }
+    if (minusculo.includes("[]") || minusculo.startsWith("array<") || minusculo.startsWith("record<") || minusculo.startsWith("list[") || minusculo.startsWith("dict[")) {
+        return "Json";
+    }
+    if (minusculo === "json" || minusculo === "object" || minusculo === "unknown" || minusculo === "any" || minusculo === "void" || minusculo === "none") {
+        return minusculo === "void" || minusculo === "none" ? "Vazio" : "Json";
+    }
+    return tipo.trim();
+}
+function limparTipoBackend(tipo) {
+    if (!tipo) {
+        return undefined;
+    }
+    return tipo
+        .trim()
+        .replace(/^Task<(.+)>$/i, "$1")
+        .replace(/^ActionResult<(.+)>$/i, "$1")
+        .replace(/^IActionResult$/i, "Json")
+        .replace(/^Results<(.+)>$/i, "$1")
+        .replace(/^ResponseEntity<(.+)>$/i, "$1")
+        .replace(/^Optional<(.+)>$/i, "$1")
+        .replace(/^Result<(.+)>$/i, "$1")
+        .replace(/^impl\s+IntoResponse$/i, "Json")
+        .replace(/^Json<(.+)>$/i, "$1")
+        .replace(/^Option<(.+)>$/i, "$1")
+        .replace(/^Vec<(.+)>$/i, "Json")
+        .replace(/^List<(.+)>$/i, "Json")
+        .replace(/^Map<(.+)>$/i, "Json")
+        .replace(/^Dictionary<(.+)>$/i, "Json");
+}
+function mapearTipoBackendParaSema(tipo) {
+    const limpo = limparTipoBackend(tipo);
+    if (!limpo) {
+        return "Json";
+    }
+    const basico = mapearTipoPrimitivo(limpo);
+    if (basico !== limpo) {
+        return basico;
+    }
+    if (/\[\]$/.test(limpo) || /^(IEnumerable|IReadOnlyList|List|Vec|HashMap|Map|Dictionary)</.test(limpo)) {
+        return "Json";
+    }
+    if (/^(void|unit|\(\)|nil)$/i.test(limpo)) {
+        return "Vazio";
+    }
+    if (/\b(uuid|guid)\b/i.test(limpo)) {
+        return "Id";
+    }
+    return "Json";
+}
+function criarCampoResultadoBackend(tipo) {
+    const tipoSema = mapearTipoBackendParaSema(tipo);
+    return tipoSema === "Vazio"
+        ? []
+        : [{ nome: "resultado", tipo: tipoSema, obrigatorio: false }];
+}
+function camposDeParametrosRotaBackend(parametros) {
+    return parametros.map((parametro) => ({
+        nome: normalizarNomeCampoImportado(parametro.nome),
+        tipo: parametro.tipoSema,
+        obrigatorio: true,
+    }));
+}
+function pareceWrapperTipo(nome) {
+    return SUFIXOS_WRAPPER.some((sufixo) => nome.endsWith(sufixo)) || /(entrada|saida|dto|request|response|payload|body|input|output)/i.test(nome);
+}
+function descreverEfeitosPorHeuristica(codigo) {
+    const texto = codigo.toLowerCase();
+    const efeitos = [];
+    const adicionar = (categoria, alvo, criticidade) => {
+        if (!efeitos.some((efeito) => efeito.categoria === categoria && efeito.alvo === alvo)) {
+            efeitos.push({ categoria, alvo, criticidade });
+        }
+    };
+    if (/(prisma\.|repository\.|\.create\(|\.update\(|\.delete\(|\.save\()/i.test(codigo)) {
+        adicionar("persistencia", "banco", "alta");
+    }
+    if (/(findmany|findunique|findfirst|\.find\(|\.select\(|\.query\(|\.get\()/i.test(texto)) {
+        adicionar("consulta", "dados", "media");
+    }
+    if (/(emit\(|publish\(|dispatch\(|eventbus|event_emitter)/i.test(texto)) {
+        adicionar("evento", "dominio", "media");
+    }
+    if (/(notify|notification|sendmessage|send_email|telegram|smtp|mail)/i.test(texto)) {
+        adicionar("notificacao", "usuarios", "media");
+    }
+    if (/(audit|logger|logging|log\.|trace|observability)/i.test(texto)) {
+        adicionar("auditoria", "operacao", "baixa");
+    }
+    return efeitos;
+}
+function normalizarNomeErroBruto(nome) {
+    return paraSnakeCase(nome.replace(/(Error|Erro|Exception)$/i, "")) || "erro_importado";
+}
+function extrairErrosTs(node, sourceFile) {
+    const encontrados = new Map();
+    const visitar = (atual) => {
+        if (ts.isThrowStatement(atual) && atual.expression) {
+            const expressao = atual.expression;
+            if (ts.isNewExpression(expressao)) {
+                const nomeErro = expressao.expression.getText(sourceFile);
+                const mensagem = extrairTextoLiteral(expressao.arguments?.[0]) ?? `Erro importado automaticamente de ${nomeErro}.`;
+                encontrados.set(normalizarNomeErroBruto(nomeErro), mensagem);
+            }
+        }
+        atual.forEachChild(visitar);
+    };
+    node.forEachChild(visitar);
+    return [...encontrados.entries()].map(([nome, mensagem]) => ({ nome, mensagem }));
+}
+function extrairTiposTs(sourceFile) {
+    const tipos = new Map();
+    const adicionarObjeto = (nome, campos) => {
+        if (!campos.length || tipos.has(nome)) {
+            return;
+        }
+        tipos.set(nome, { tipo: "objeto", nome, campos });
+    };
+    const adicionarEnum = (nome, valores) => {
+        if (!valores.length || tipos.has(nome)) {
+            return;
+        }
+        tipos.set(nome, { tipo: "enum", nome, valores });
+    };
+    sourceFile.forEachChild((node) => {
+        if (ts.isInterfaceDeclaration(node) && node.name) {
+            const campos = node.members
+                .filter(ts.isPropertySignature)
+                .map((member) => ({
+                nome: member.name.getText(sourceFile),
+                tipoTexto: member.type?.getText(sourceFile),
+                obrigatorio: !member.questionToken,
+            }));
+            adicionarObjeto(node.name.text, campos);
+            return;
+        }
+        if (ts.isClassDeclaration(node) && node.name) {
+            const campos = node.members
+                .filter((member) => ts.isPropertyDeclaration(member) && Boolean(member.name))
+                .map((member) => ({
+                nome: member.name.getText(sourceFile),
+                tipoTexto: member.type?.getText(sourceFile),
+                obrigatorio: !member.questionToken,
+            }));
+            adicionarObjeto(node.name.text, campos);
+            return;
+        }
+        if (ts.isTypeAliasDeclaration(node) && node.name) {
+            if (ts.isUnionTypeNode(node.type) && node.type.types.every((tipo) => ts.isLiteralTypeNode(tipo) && ts.isStringLiteralLike(tipo.literal))) {
+                adicionarEnum(node.name.text, node.type.types
+                    .map((tipo) => ts.isLiteralTypeNode(tipo) && ts.isStringLiteralLike(tipo.literal) ? tipo.literal.text : undefined)
+                    .filter((valor) => Boolean(valor)));
+                return;
+            }
+            if (ts.isTypeLiteralNode(node.type)) {
+                const campos = node.type.members
+                    .filter(ts.isPropertySignature)
+                    .map((member) => ({
+                    nome: member.name.getText(sourceFile),
+                    tipoTexto: member.type?.getText(sourceFile),
+                    obrigatorio: !member.questionToken,
+                }));
+                adicionarObjeto(node.name.text, campos);
+            }
+        }
+    });
+    return tipos;
+}
+function mapearTipoTsParaSema(tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados) {
+    if (!tipoTexto) {
+        return "Json";
+    }
+    const basico = mapearTipoPrimitivo(tipoTexto);
+    if (basico !== tipoTexto.trim()) {
+        return basico;
+    }
+    const limpo = tipoTexto
+        .trim()
+        .replace(/^Promise<(.*)>$/, "$1")
+        .replace(/\| undefined/g, "")
+        .replace(/\| null/g, "")
+        .replace(/Readonly<(.+)>/, "$1")
+        .replace(/Partial<(.+)>/, "$1")
+        .trim();
+    if (tipos.has(limpo)) {
+        const encontrado = tipos.get(limpo);
+        if (encontrado.tipo === "enum") {
+            enumsReferenciados.add(encontrado.nome);
+            return encontrado.nome;
+        }
+        if (!pareceWrapperTipo(encontrado.nome)) {
+            entidadesReferenciadas.add(encontrado.nome);
+            return encontrado.nome;
+        }
+    }
+    return "Json";
+}
+function expandirCamposTs(nomeParametro, tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados, obrigatorio) {
+    if (!tipoTexto) {
+        return [{ nome: normalizarNomeCampoImportado(nomeParametro), tipo: "Json", obrigatorio }];
+    }
+    const limpo = tipoTexto
+        .trim()
+        .replace(/^Promise<(.*)>$/, "$1")
+        .replace(/\| undefined/g, "")
+        .replace(/\| null/g, "")
+        .replace(/Readonly<(.+)>/, "$1")
+        .replace(/Partial<(.+)>/, "$1")
+        .trim();
+    const descoberto = tipos.get(limpo);
+    if (descoberto?.tipo === "objeto" && pareceWrapperTipo(descoberto.nome)) {
+        return descoberto.campos.map((campo) => ({
+            nome: normalizarNomeCampoImportado(campo.nome),
+            tipo: mapearTipoTsParaSema(campo.tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados),
+            obrigatorio: campo.obrigatorio,
+        }));
+    }
+    return [{
+            nome: normalizarNomeCampoImportado(nomeParametro),
+            tipo: mapearTipoTsParaSema(tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados),
+            obrigatorio,
+        }];
+}
+function criarEntidadesReferenciadas(tipos, entidadesReferenciadas, enumsReferenciados) {
+    const fila = [...entidadesReferenciadas];
+    const processadas = new Set();
+    const entities = [];
+    while (fila.length > 0) {
+        const nomeAtual = fila.shift();
+        if (processadas.has(nomeAtual)) {
+            continue;
+        }
+        processadas.add(nomeAtual);
+        const tipo = tipos.get(nomeAtual);
+        if (!tipo || tipo.tipo !== "objeto") {
+            continue;
+        }
+        const entidade = {
+            nome: tipo.nome,
+            campos: tipo.campos.map((campo) => ({
+                nome: normalizarNomeCampoImportado(campo.nome),
+                tipo: mapearTipoTsParaSema(campo.tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados),
+                obrigatorio: campo.obrigatorio,
+            })),
+        };
+        entities.push(entidade);
+        for (const referenciado of entidadesReferenciadas) {
+            if (!processadas.has(referenciado) && !fila.includes(referenciado)) {
+                fila.push(referenciado);
+            }
+        }
+    }
+    const enums = [...enumsReferenciados]
+        .map((nome) => tipos.get(nome))
+        .filter((item) => Boolean(item && item.tipo === "enum"))
+        .map((tipo) => ({
+        nome: tipo.nome,
+        valores: tipo.valores,
+    }))
+        .filter((enumItem, indice, lista) => lista.findIndex((item) => item.nome === enumItem.nome) === indice);
+    return { entities: deduplicarEntidades(entities), enums };
+}
+function caminhoImplTs(diretorioBase, arquivo, simbolo) {
+    const relativo = path.relative(diretorioBase, arquivo).replace(/\.[^.]+$/, "");
+    const segmentos = relativo.split(path.sep).map((segmento) => paraIdentificadorModulo(segmento)).filter(Boolean);
+    return [...segmentos, simbolo].join(".");
+}
+function mapearCampoInferidoTypeScriptHttp(campo, tipos, entidadesReferenciadas, enumsReferenciados) {
+    const tipoBasico = campo.tipoTexto ? mapearTipoPrimitivo(campo.tipoTexto) : "Json";
+    return {
+        nome: paraSnakeCase(campo.nome),
+        tipo: ["Texto", "Decimal", "Inteiro", "Booleano", "Data", "DataHora", "Id", "Json", "Vazio"].includes(tipoBasico)
+            ? tipoBasico
+            : campo.tipoTexto
+                ? mapearTipoTsParaSema(campo.tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados)
+                : "Json",
+        obrigatorio: campo.obrigatorio,
+    };
+}
+function camposDeSemanticaTypeScriptHttp(campos, tipos, entidadesReferenciadas, enumsReferenciados) {
+    return campos.map((campo) => mapearCampoInferidoTypeScriptHttp(campo, tipos, entidadesReferenciadas, enumsReferenciados));
+}
+function camposEstruturadosTypeScriptHttp(nomeParametro, tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados) {
+    const campos = expandirCamposTs(nomeParametro, tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados, false);
+    const nomeWrapper = normalizarNomeCampoImportado(nomeParametro);
+    if (campos.length === 1 && campos[0]?.nome === nomeWrapper && campos[0]?.tipo === "Json") {
+        return [];
+    }
+    return campos;
+}
+function errosPorStatusHttp(statuses) {
+    return [...new Set(statuses)].map((status) => {
+        switch (status) {
+            case 401:
+                return { nome: "nao_autorizado", mensagem: "Falha HTTP importada automaticamente com status 401." };
+            case 403:
+                return { nome: "acesso_negado", mensagem: "Falha HTTP importada automaticamente com status 403." };
+            case 404:
+                return { nome: "nao_encontrado", mensagem: "Falha HTTP importada automaticamente com status 404." };
+            case 409:
+                return { nome: "conflito", mensagem: "Falha HTTP importada automaticamente com status 409." };
+            case 422:
+                return { nome: "entrada_invalida", mensagem: "Falha HTTP importada automaticamente com status 422." };
+            case 500:
+                return { nome: "erro_interno", mensagem: "Falha HTTP importada automaticamente com status 500." };
+            default:
+                return { nome: `erro_http_${status}`, mensagem: `Falha HTTP importada automaticamente com status ${status}.` };
+        }
+    });
+}
+function resolverEscopoImportacaoNextJs(diretorioEntrada) {
+    const resolvido = path.resolve(diretorioEntrada);
+    const partes = path.parse(resolvido);
+    const relativoSemRaiz = resolvido.slice(partes.root.length);
+    const segmentos = relativoSemRaiz.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));
+    const indiceSrcAppApi = procurarSequencia(["src", "app", "api"]);
+    if (indiceSrcAppApi >= 0) {
+        return {
+            baseProjeto: montarBase(indiceSrcAppApi),
+            diretorioEscopo: resolvido,
+        };
+    }
+    const indiceAppApi = procurarSequencia(["app", "api"]);
+    if (indiceAppApi >= 0) {
+        return {
+            baseProjeto: montarBase(indiceAppApi),
+            diretorioEscopo: resolvido,
+        };
+    }
+    const indiceSrcApp = procurarSequencia(["src", "app"]);
+    if (indiceSrcApp >= 0) {
+        return {
+            baseProjeto: montarBase(indiceSrcApp),
+            diretorioEscopo: resolvido,
+        };
+    }
+    const indiceApp = procurarSequencia(["app"]);
+    if (indiceApp >= 0) {
+        return {
+            baseProjeto: montarBase(indiceApp),
+            diretorioEscopo: resolvido,
+        };
+    }
+    return {
+        baseProjeto: resolvido,
+        diretorioEscopo: resolvido,
+    };
+}
+function extrairChamadaServiceTs(node) {
+    let encontrado;
+    const visitar = (atual) => {
+        if (encontrado) {
+            return;
+        }
+        if (ts.isCallExpression(atual) && ts.isPropertyAccessExpression(atual.expression)) {
+            const alvo = atual.expression.expression;
+            if (ts.isPropertyAccessExpression(alvo) && alvo.expression.kind === ts.SyntaxKind.ThisKeyword && alvo.name.text.endsWith("Service")) {
+                encontrado = atual.expression.name.text;
+                return;
+            }
+        }
+        atual.forEachChild(visitar);
+    };
+    node.forEachChild(visitar);
+    return encontrado;
+}
+function deduplicarCampos(campos) {
+    const mapa = new Map();
+    for (const campo of campos) {
+        if (!mapa.has(campo.nome)) {
+            mapa.set(campo.nome, campo);
+        }
+    }
+    return [...mapa.values()];
+}
+function deduplicarErros(errors) {
+    const mapa = new Map();
+    for (const erro of errors) {
+        if (!mapa.has(erro.nome)) {
+            mapa.set(erro.nome, erro);
+        }
+    }
+    return [...mapa.values()];
+}
+function deduplicarEfeitos(effects) {
+    const mapa = new Map();
+    for (const effect of effects) {
+        const chave = `${effect.categoria}:${effect.alvo}`;
+        if (!mapa.has(chave)) {
+            mapa.set(chave, effect);
+        }
+    }
+    return [...mapa.values()];
+}
+function deduplicarEntidades(entities) {
+    const mapa = new Map();
+    for (const entity of entities) {
+        if (!mapa.has(entity.nome)) {
+            mapa.set(entity.nome, entity);
+        }
+    }
+    return [...mapa.values()];
+}
+function deduplicarEnums(enums) {
+    const mapa = new Map();
+    for (const enumItem of enums) {
+        if (!mapa.has(enumItem.nome)) {
+            mapa.set(enumItem.nome, enumItem);
+        }
+    }
+    return [...mapa.values()];
+}
+function deduplicarTarefas(tasks) {
+    const mapa = new Map();
+    for (const task of tasks) {
+        if (!mapa.has(task.nome)) {
+            mapa.set(task.nome, task);
+            continue;
+        }
+        const existente = mapa.get(task.nome);
+        existente.input = deduplicarCampos([...existente.input, ...task.input]);
+        existente.output = deduplicarCampos([...existente.output, ...task.output]);
+        existente.errors = deduplicarErros([...existente.errors, ...task.errors]);
+        existente.effects = deduplicarEfeitos([...existente.effects, ...task.effects]);
+    }
+    return [...mapa.values()];
+}
+function deduplicarRotas(routes) {
+    const mapa = new Map();
+    for (const route of routes) {
+        const chave = `${route.metodo}:${route.caminho}`;
+        if (!mapa.has(chave)) {
+            mapa.set(chave, route);
+        }
+    }
+    return [...mapa.values()];
+}
+function sincronizarRotasComTasks(routes, tasks) {
+    const mapaTasks = new Map(tasks.map((task) => [task.nome, task]));
+    for (const route of routes) {
+        const task = mapaTasks.get(route.task);
+        if (!task) {
+            continue;
+        }
+        if (route.output.length === 0) {
+            route.output = task.output.map((campo) => ({ ...campo, obrigatorio: true }));
+        }
+        if (route.errors.length === 0) {
+            route.errors = task.errors;
+        }
+    }
+}
+function renderizarCampos(bloco, campos, indentacao = "  ", sempre = false) {
+    if (campos.length === 0 && !sempre) {
+        return [];
+    }
+    return [
+        `${indentacao}${bloco} {`,
+        ...campos.map((campo) => `${indentacao}  ${normalizarNomeCampoImportado(campo.nome)}: ${campo.tipo}${campo.obrigatorio ? " required" : ""}`),
+        `${indentacao}}`,
+        "",
+    ];
+}
+function renderizarErrors(erros, indentacao = "  ") {
+    if (erros.length === 0) {
+        return [];
+    }
+    return [
+        `${indentacao}error {`,
+        ...erros.map((erro) => `${indentacao}  ${erro.nome}: "${escaparTexto(erro.mensagem)}"`),
+        `${indentacao}}`,
+        "",
+    ];
+}
+function renderizarEffects(effects, indentacao = "  ") {
+    if (effects.length === 0) {
+        return [];
+    }
+    return [
+        `${indentacao}effects {`,
+        ...effects.map((effect) => `${indentacao}  ${effect.categoria} ${effect.alvo}${effect.criticidade ? ` criticidade = ${effect.criticidade}` : ""}`),
+        `${indentacao}}`,
+        "",
+    ];
+}
+function renderizarImpl(impl, indentacao = "  ") {
+    if (!impl || Object.keys(impl).length === 0) {
+        return [];
+    }
+    return [
+        `${indentacao}impl {`,
+        ...(impl.ts ? [`${indentacao}  ts: ${impl.ts}`] : []),
+        ...(impl.py ? [`${indentacao}  py: ${impl.py}`] : []),
+        ...(impl.dart ? [`${indentacao}  dart: ${impl.dart}`] : []),
+        ...(impl.cs ? [`${indentacao}  cs: ${impl.cs}`] : []),
+        ...(impl.java ? [`${indentacao}  java: ${impl.java}`] : []),
+        ...(impl.go ? [`${indentacao}  go: ${impl.go}`] : []),
+        ...(impl.rust ? [`${indentacao}  rust: ${impl.rust}`] : []),
+        ...(impl.cpp ? [`${indentacao}  cpp: ${impl.cpp}`] : []),
+        `${indentacao}}`,
+        "",
+    ];
+}
+function renderizarTask(task) {
+    const linhas = [
+        `  task ${task.nome} {`,
+        "    docs {",
+        `      resumo: "${escaparTexto(task.resumo)}"`,
+        "    }",
+        "",
+        ...renderizarCampos("input", task.input, "    ", true),
+        ...renderizarCampos("output", task.output, "    ", true),
+        ...renderizarEffects(task.effects, "    "),
+        ...renderizarImpl(task.impl, "    "),
+        ...renderizarErrors(task.errors, "    "),
+    ];
+    linhas.push("    guarantees {");
+    for (const campo of task.output) {
+        linhas.push(`      ${normalizarNomeCampoImportado(campo.nome)} existe`);
+    }
+    linhas.push("    }");
+    linhas.push("");
+    linhas.push("  }");
+    linhas.push("");
+    return linhas;
+}
+function renderizarRoute(route) {
+    const caminhoRenderizado = /[{}]/.test(route.caminho)
+        ? `"${escaparTexto(route.caminho)}"`
+        : route.caminho;
+    return [
+        `  route ${route.nome} {`,
+        "    docs {",
+        `      resumo: "${escaparTexto(route.resumo)}"`,
+        "    }",
+        "",
+        `    metodo: ${route.metodo}`,
+        `    caminho: ${caminhoRenderizado}`,
+        `    task: ${route.task}`,
+        ...renderizarCampos("input", route.input, "    "),
+        ...renderizarCampos("output", route.output, "    "),
+        ...renderizarErrors(route.errors, "    "),
+        "  }",
+        "",
+    ];
+}
+function renderizarEnum(enumItem) {
+    return [
+        `  enum ${enumItem.nome} {`,
+        `    ${enumItem.valores.join(",\n    ")}`,
+        "  }",
+        "",
+    ];
+}
+function renderizarEntidade(entity) {
+    return [
+        `  entity ${entity.nome} {`,
+        "    fields {",
+        ...entity.campos.map((campo) => `      ${normalizarNomeCampoImportado(campo.nome)}: ${campo.tipo}`),
+        "    }",
+        "  }",
+        "",
+    ];
+}
+function moduloParaCodigo(modulo) {
+    const linhas = [
+        `module ${modulo.nome} {`,
+        "  docs {",
+        `    resumo: "${escaparTexto(modulo.resumo)}"`,
+        "  }",
+        "",
+        ...modulo.enums.flatMap(renderizarEnum),
+        ...modulo.entities.flatMap(renderizarEntidade),
+        ...modulo.tasks.flatMap(renderizarTask),
+        ...modulo.routes.flatMap(renderizarRoute),
+        "}",
+        "",
+    ];
+    return linhas.join("\n");
+}
+async function formatarModuloImportado(codigo, caminhoVirtual) {
+    const formatado = formatarCodigo(codigo, caminhoVirtual);
+    return formatado.codigoFormatado ?? codigo;
+}
+function nomeArquivoModulo(modulo) {
+    const segmentos = modulo.split(".");
+    return `${segmentos.at(-1) ?? "modulo"}.sema`;
+}
+function contextoArquivoModulo(modulo, namespaceBase) {
+    const prefixo = namespaceBase.split(".");
+    const segmentos = modulo.split(".");
+    const relativos = segmentos.slice(prefixo.length, -1);
+    return relativos.length ? path.join(...relativos) : "";
+}
+function montarArquivoImportado(modulo, namespaceBase, conteudo) {
+    const pasta = contextoArquivoModulo(modulo.nome, namespaceBase);
+    const caminhoRelativo = pasta ? path.join(pasta, nomeArquivoModulo(modulo.nome)) : nomeArquivoModulo(modulo.nome);
+    return {
+        caminhoRelativo,
+        conteudo,
+        modulo: modulo.nome,
+        tarefas: modulo.tasks.length,
+        rotas: modulo.routes.length,
+        entidades: modulo.entities.length,
+        enums: modulo.enums.length,
+    };
+}
+function consolidarTiposTs(contextos) {
+    const tipos = new Map();
+    for (const contexto of contextos) {
+        for (const [nome, tipo] of extrairTiposTs(contexto.sourceFile)) {
+            if (!tipos.has(nome)) {
+                tipos.set(nome, tipo);
+            }
+        }
+    }
+    return tipos;
+}
+function importarNestJsDeArquivo(diretorioBase, arquivo, namespaceBase, tiposGlobais) {
+    const relacao = path.relative(diretorioBase, arquivo);
+    const codigo = ts.sys.readFile(arquivo, "utf8") ?? "";
+    const sourceFile = ts.createSourceFile(arquivo, codigo, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const contextoSegmentos = inferirContextoPorArquivo(relacao);
+    const nomeModulo = [namespaceBase, ...contextoSegmentos].join(".");
+    const entitiesRef = new Set();
+    const enumsRef = new Set();
+    const tasks = [];
+    const routes = [];
+    for (const node of sourceFile.statements) {
+        if (!ts.isClassDeclaration(node)) {
+            continue;
+        }
+        const controllerDecorator = lerDecorator(node, ["Controller"]);
+        if (controllerDecorator) {
+            const basePath = extrairTextoLiteral(controllerDecorator.argumentos[0]);
+            for (const member of node.members) {
+                if (!ts.isMethodDeclaration(member) || !member.body) {
+                    continue;
+                }
+                const httpDecorator = lerDecorator(member, ["Get", "Post", "Put", "Patch", "Delete"]);
+                if (!httpDecorator) {
+                    continue;
+                }
+                const taskOriginal = extrairChamadaServiceTs(member.body) ?? member.name.getText(sourceFile);
+                const taskNome = paraSnakeCase(taskOriginal);
+                const routeInput = member.parameters.flatMap((parametro) => expandirCamposTs(parametro.name.getText(sourceFile), parametro.type?.getText(sourceFile), tiposGlobais, entitiesRef, enumsRef, !parametro.questionToken));
+                const routeOutputTipo = member.type?.getText(sourceFile);
+                const routeOutput = !routeOutputTipo || mapearTipoPrimitivo(routeOutputTipo) === "Vazio"
+                    ? []
+                    : deduplicarCampos(expandirCamposTs("resultado", routeOutputTipo, tiposGlobais, entitiesRef, enumsRef, false));
+                routes.push({
+                    nome: `${taskNome}_publico`,
+                    resumo: `Rota importada automaticamente de ${relacao}#${member.name.getText(sourceFile)}.`,
+                    metodo: httpDecorator.nome.toUpperCase(),
+                    caminho: juntarCaminhoHttp(basePath, extrairTextoLiteral(httpDecorator.argumentos[0])),
+                    task: taskNome,
+                    input: deduplicarCampos(routeInput),
+                    output: routeOutput,
+                    errors: [],
+                });
+            }
+        }
+        if (!node.name?.text.endsWith("Service")) {
+            continue;
+        }
+        for (const member of node.members) {
+            if (!ts.isMethodDeclaration(member) || !member.body || !member.name) {
+                continue;
+            }
+            if (member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.PrivateKeyword || modifier.kind === ts.SyntaxKind.ProtectedKeyword)) {
+                continue;
+            }
+            const nomeMetodo = member.name.getText(sourceFile);
+            if (nomeMetodo === "constructor") {
+                continue;
+            }
+            const input = member.parameters.flatMap((parametro) => expandirCamposTs(parametro.name.getText(sourceFile), parametro.type?.getText(sourceFile), tiposGlobais, entitiesRef, enumsRef, !parametro.questionToken));
+            const output = member.type?.getText(sourceFile) && mapearTipoPrimitivo(member.type.getText(sourceFile)) === "Vazio"
+                ? []
+                : deduplicarCampos(expandirCamposTs("resultado", member.type?.getText(sourceFile), tiposGlobais, entitiesRef, enumsRef, false));
+            tasks.push({
+                nome: paraSnakeCase(nomeMetodo),
+                resumo: `Task importada automaticamente de ${relacao}#${nomeMetodo}.`,
+                input: deduplicarCampos(input),
+                output,
+                errors: extrairErrosTs(member.body, sourceFile),
+                effects: descreverEfeitosPorHeuristica(member.body.getText(sourceFile)),
+                impl: { ts: caminhoImplTs(diretorioBase, arquivo, nomeMetodo) },
+                origemArquivo: relacao,
+                origemSimbolo: nomeMetodo,
+            });
+        }
+    }
+    if (!tasks.length && !routes.length) {
+        return [];
+    }
+    const { entities, enums } = criarEntidadesReferenciadas(tiposGlobais, entitiesRef, enumsRef);
+    sincronizarRotasComTasks(routes, tasks);
+    return [{
+            nome: nomeModulo,
+            resumo: `Rascunho Sema importado de um contexto NestJS legado em ${contextoSegmentos.join("/")}.`,
+            entities,
+            enums,
+            tasks: deduplicarTarefas(tasks),
+            routes: deduplicarRotas(routes),
+        }];
+}
+async function importarTypeScriptBase(diretorio, namespaceBase, modoNestjs = false) {
+    const arquivos = await listarArquivosRecursivos(diretorio, [".ts"]);
+    const uteis = arquivos.filter((arquivo) => !arquivo.endsWith(".spec.ts")
+        && !arquivo.endsWith(".test.ts")
+        && !arquivo.endsWith(".d.ts")
+        && !(modoNestjs && !arquivo.endsWith(".controller.ts") && !arquivo.endsWith(".service.ts")));
+    const contextosTodos = await Promise.all(arquivos
+        .filter((arquivo) => !arquivo.endsWith(".spec.ts") && !arquivo.endsWith(".test.ts") && !arquivo.endsWith(".d.ts"))
+        .map(async (arquivo) => {
+        const texto = await readFile(arquivo, "utf8");
+        return {
+            sourceFile: ts.createSourceFile(arquivo, texto, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS),
+            texto,
+            relacao: path.relative(diretorio, arquivo),
+        };
+    }));
+    const contextos = await Promise.all(uteis.map(async (arquivo) => {
+        const texto = await readFile(arquivo, "utf8");
+        return {
+            sourceFile: ts.createSourceFile(arquivo, texto, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS),
+            texto,
+            relacao: path.relative(diretorio, arquivo),
+        };
+    }));
+    const tiposGlobais = consolidarTiposTs(contextosTodos);
+    const modulos = new Map();
+    if (modoNestjs) {
+        for (const contexto of contextos) {
+            for (const modulo of importarNestJsDeArquivo(diretorio, path.join(diretorio, contexto.relacao), namespaceBase, tiposGlobais)) {
+                const existente = modulos.get(modulo.nome);
+                if (!existente) {
+                    modulos.set(modulo.nome, modulo);
+                    continue;
+                }
+                existente.tasks = deduplicarTarefas([...existente.tasks, ...modulo.tasks]);
+                existente.routes = deduplicarRotas([...existente.routes, ...modulo.routes]);
+                existente.entities = deduplicarEntidades([...existente.entities, ...modulo.entities]);
+                existente.enums = deduplicarEnums([...existente.enums, ...modulo.enums]);
+            }
+        }
+        return [...modulos.values()];
+    }
+    for (const contexto of contextos) {
+        const entitiesRef = new Set();
+        const enumsRef = new Set();
+        const contextoSegmentos = inferirContextoPorArquivo(contexto.relacao);
+        const nomeModulo = [namespaceBase, ...contextoSegmentos].join(".");
+        const tasks = [];
+        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));
+                const errors = node.body ? extrairErrosTs(node.body, contexto.sourceFile) : [];
+                const effects = node.body ? descreverEfeitosPorHeuristica(node.body.getText(contexto.sourceFile)) : [];
+                tasks.push({
+                    nome: paraSnakeCase(nome),
+                    resumo: `Task importada automaticamente de ${contexto.relacao}#${nome}.`,
+                    input: deduplicarCampos(input),
+                    output,
+                    errors,
+                    effects,
+                    impl: { ts: caminhoImplTs(diretorio, path.join(diretorio, 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));
+                    tasks.push({
+                        nome: paraSnakeCase(nomeMetodo),
+                        resumo: `Task 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: caminhoImplTs(diretorio, path.join(diretorio, contexto.relacao), `${nomeClasse}.${nomeMetodo}`) },
+                        origemArquivo: contexto.relacao,
+                        origemSimbolo: `${nomeClasse}.${nomeMetodo}`,
+                    });
+                }
+            }
+        });
+        if (tasks.length === 0) {
+            continue;
+        }
+        const { entities, enums } = criarEntidadesReferenciadas(tiposGlobais, entitiesRef, enumsRef);
+        modulos.set(nomeModulo, {
+            nome: nomeModulo,
+            resumo: `Rascunho Sema importado automaticamente de ${contexto.relacao}.`,
+            tasks: deduplicarTarefas(tasks),
+            routes: [],
+            entities,
+            enums,
+        });
+    }
+    return [...modulos.values()];
+}
+function nomeTaskParaRotaTypeScript(caminho, metodo) {
+    const segmentos = caminho
+        .replace(/^\/+|\/+$/g, "")
+        .split("/")
+        .filter(Boolean)
+        .map((segmento) => segmento.replace(/[{}]/g, ""));
+    return paraSnakeCase([...segmentos, metodo.toLowerCase()].join("_")) || `rota_${metodo.toLowerCase()}`;
+}
+function camposDeParametrosRotaTypeScript(parametros) {
+    return parametros.map((parametro) => ({
+        nome: paraSnakeCase(parametro.nome),
+        tipo: parametro.tipoSema,
+        obrigatorio: true,
+    }));
+}
+function extrairColecoesFirebaseImportacao(texto) {
+    const encontrados = new Set();
+    for (const match of texto.matchAll(/\b(?:export\s+)?const\s+\w*COLLECTIONS?\w*\s*=\s*\{([\s\S]*?)\n\}/g)) {
+        const corpo = match[1] ?? "";
+        for (const valor of corpo.matchAll(/:\s*["'`]([^"'`]+)["'`]/g)) {
+            encontrados.add(valor[1]);
+        }
+    }
+    return [...encontrados];
+}
+async function importarNextJsBase(diretorio, namespaceBase) {
+    const escopo = resolverEscopoImportacaoNextJs(diretorio);
+    const arquivos = await listarArquivosRecursivos(escopo.diretorioEscopo, [".ts", ".tsx", ".js", ".jsx"]);
+    const uteis = arquivos.filter((arquivo) => !arquivo.endsWith(".spec.ts")
+        && !arquivo.endsWith(".test.ts")
+        && !arquivo.endsWith(".d.ts")
+        && /(\\|\/)(?:src\\|src\/)?app(\\|\/)api(\\|\/).+(\\|\/)route\.(ts|tsx|js|jsx)$/i.test(arquivo));
+    const contextos = await Promise.all(uteis.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(escopo.baseProjeto, arquivo),
+        };
+    }));
+    const tiposGlobais = consolidarTiposTs(contextos);
+    const modulos = new Map();
+    for (const contexto of contextos) {
+        const entitiesRef = new Set();
+        const enumsRef = new Set();
+        const contextoSegmentos = inferirContextoPorArquivo(contexto.relacao.replace(/[\\/]route\.(?:ts|tsx|js|jsx)$/i, "")).filter((segmento, indice) => !(indice === 0 && segmento === "app"));
+        const nomeModulo = [namespaceBase, ...contextoSegmentos].join(".");
+        const tasks = [];
+        const routes = [];
+        for (const rota of extrairRotasTypeScriptHttp(contexto.sourceFile, contexto.relacao).filter((item) => item.origem === "nextjs")) {
+            const taskNome = nomeTaskParaRotaTypeScript(rota.caminho, rota.metodo);
+            const exportacao = localizarExportacaoTypeScriptHttp(contexto.sourceFile, rota.simbolo);
+            const semantica = inferirSemanticaHandlerTypeScriptHttp(contexto.sourceFile, rota.simbolo);
+            const input = deduplicarCampos([
+                ...camposDeParametrosRotaTypeScript(rota.parametros),
+                ...camposDeSemanticaTypeScriptHttp(semantica?.query ?? [], tiposGlobais, entitiesRef, enumsRef),
+                ...camposEstruturadosTypeScriptHttp("body", semantica?.bodyTipoTexto, tiposGlobais, entitiesRef, enumsRef),
+                ...camposDeSemanticaTypeScriptHttp(semantica?.body ?? [], tiposGlobais, entitiesRef, enumsRef),
+            ]);
+            const output = semantica && semantica.response.length > 0
+                ? deduplicarCampos(camposDeSemanticaTypeScriptHttp(semantica.response, tiposGlobais, entitiesRef, enumsRef))
+                : semantica?.responseTipoTexto
+                    ? deduplicarCampos(expandirCamposTs("resultado", semantica.responseTipoTexto, tiposGlobais, entitiesRef, enumsRef, false))
+                    : exportacao?.retorno && mapearTipoPrimitivo(exportacao.retorno) === "Vazio"
+                        ? []
+                        : deduplicarCampos(expandirCamposTs("resultado", exportacao?.retorno, tiposGlobais, entitiesRef, enumsRef, false));
+            const taskOutput = output.length > 0 ? output : [{ nome: "resultado", tipo: "Json", obrigatorio: false }];
+            const resumoBase = `Rota Next.js App Router importada automaticamente de ${contexto.relacao}#${rota.simbolo}.`;
+            const errors = deduplicarErros([
+                ...(exportacao?.corpo ? extrairErrosTs(exportacao.corpo, contexto.sourceFile) : []),
+                ...errosPorStatusHttp(semantica?.errorStatuses ?? []),
+            ]);
+            tasks.push({
+                nome: taskNome,
+                resumo: `Task derivada automaticamente de ${contexto.relacao}#${rota.simbolo}.`,
+                input,
+                output: taskOutput,
+                errors,
+                effects: exportacao?.corpo ? descreverEfeitosPorHeuristica(exportacao.corpo.getText(contexto.sourceFile)) : descreverEfeitosPorHeuristica(contexto.texto),
+                impl: { ts: caminhoImplTs(escopo.baseProjeto, path.join(escopo.baseProjeto, contexto.relacao), rota.simbolo) },
+                origemArquivo: contexto.relacao,
+                origemSimbolo: rota.simbolo,
+            });
+            routes.push({
+                nome: `${taskNome}_publico`,
+                resumo: resumoBase,
+                metodo: rota.metodo,
+                caminho: rota.caminho,
+                task: taskNome,
+                input,
+                output: taskOutput,
+                errors,
+            });
+        }
+        if (!tasks.length && !routes.length) {
+            continue;
+        }
+        sincronizarRotasComTasks(routes, tasks);
+        const { entities, enums } = criarEntidadesReferenciadas(tiposGlobais, entitiesRef, enumsRef);
+        modulos.set(nomeModulo, {
+            nome: nomeModulo,
+            resumo: `Rascunho Sema importado automaticamente de ${contexto.relacao}.`,
+            tasks: deduplicarTarefas(tasks),
+            routes: deduplicarRotas(routes),
+            entities,
+            enums,
+        });
+    }
+    return [...modulos.values()];
+}
+async function importarFirebaseBase(diretorio, namespaceBase) {
+    const arquivos = await listarArquivosRecursivos(diretorio, [".ts", ".tsx", ".js", ".jsx"]);
+    const uteis = arquivos.filter((arquivo) => !arquivo.endsWith(".spec.ts")
+        && !arquivo.endsWith(".test.ts")
+        && !arquivo.endsWith(".d.ts")
+        && /(sema_contract_bridge|health-check|collections?|firestore)/i.test(arquivo));
+    const contextos = await Promise.all(uteis.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(diretorio, arquivo),
+        };
+    }));
+    const tiposGlobais = consolidarTiposTs(contextos);
+    const modulos = new Map();
+    for (const contexto of contextos) {
+        const entitiesRef = new Set();
+        const enumsRef = new Set();
+        const contextoSegmentos = inferirContextoPorArquivo(contexto.relacao);
+        const nomeModulo = [namespaceBase, ...contextoSegmentos].join(".");
+        const tasks = [];
+        const routes = [];
+        for (const node of contexto.sourceFile.statements) {
+            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: paraSnakeCase(nome.replace(/^sema/, "")) || paraSnakeCase(nome),
+                    resumo: `Task Firebase/worker importada automaticamente de ${contexto.relacao}#${nome}.`,
+                    input: deduplicarCampos(input),
+                    output: output.length > 0 ? output : [{ nome: "resultado", tipo: "Json", obrigatorio: false }],
+                    errors: node.body ? extrairErrosTs(node.body, contexto.sourceFile) : [],
+                    effects: node.body ? descreverEfeitosPorHeuristica(node.body.getText(contexto.sourceFile)) : descreverEfeitosPorHeuristica(contexto.texto),
+                    impl: { ts: caminhoImplTs(diretorio, path.join(diretorio, contexto.relacao), nome) },
+                    origemArquivo: contexto.relacao,
+                    origemSimbolo: nome,
+                });
+            }
+        }
+        for (const rota of extrairRotasTypeScriptHttp(contexto.sourceFile, contexto.relacao).filter((item) => item.origem === "firebase")) {
+            const taskNome = nomeTaskParaRotaTypeScript(rota.caminho, rota.metodo);
+            const exportacao = localizarExportacaoTypeScriptHttp(contexto.sourceFile, rota.simbolo);
+            const input = deduplicarCampos(camposDeParametrosRotaTypeScript(rota.parametros));
+            const output = exportacao?.retorno && mapearTipoPrimitivo(exportacao.retorno) === "Vazio"
+                ? []
+                : deduplicarCampos(expandirCamposTs("resultado", exportacao?.retorno, tiposGlobais, entitiesRef, enumsRef, false));
+            const taskOutput = output.length > 0 ? output : [{ nome: "resultado", tipo: "Json", obrigatorio: false }];
+            tasks.push({
+                nome: taskNome,
+                resumo: `Task HTTP do worker importada automaticamente de ${contexto.relacao}#${rota.simbolo}.`,
+                input,
+                output: taskOutput,
+                errors: exportacao?.corpo ? extrairErrosTs(exportacao.corpo, contexto.sourceFile) : [],
+                effects: exportacao?.corpo ? descreverEfeitosPorHeuristica(exportacao.corpo.getText(contexto.sourceFile)) : descreverEfeitosPorHeuristica(contexto.texto),
+                impl: { ts: caminhoImplTs(diretorio, path.join(diretorio, contexto.relacao), rota.simbolo) },
+                origemArquivo: contexto.relacao,
+                origemSimbolo: rota.simbolo,
+            });
+            routes.push({
+                nome: `${taskNome}_publico`,
+                resumo: `Rota do worker importada automaticamente de ${contexto.relacao}#${rota.simbolo}.`,
+                metodo: rota.metodo,
+                caminho: rota.caminho,
+                task: taskNome,
+                input,
+                output: taskOutput,
+                errors: exportacao?.corpo ? extrairErrosTs(exportacao.corpo, contexto.sourceFile) : [],
+            });
+        }
+        for (const colecao of extrairColecoesFirebaseImportacao(contexto.texto)) {
+            tasks.push({
+                nome: paraSnakeCase(`inventariar_${colecao}`),
+                resumo: `Task sintetica para registrar o recurso persistido ${colecao} descoberto em ${contexto.relacao}.`,
+                input: [],
+                output: [{ nome: "colecao", tipo: "Texto", obrigatorio: false }],
+                errors: [],
+                effects: [{ categoria: "persistencia", alvo: colecao, criticidade: "media" }],
+                origemArquivo: contexto.relacao,
+                origemSimbolo: colecao,
+            });
+        }
+        if (!tasks.length && !routes.length) {
+            continue;
+        }
+        sincronizarRotasComTasks(routes, tasks);
+        const { entities, enums } = criarEntidadesReferenciadas(tiposGlobais, entitiesRef, enumsRef);
+        modulos.set(nomeModulo, {
+            nome: nomeModulo,
+            resumo: `Rascunho Sema importado automaticamente de ${contexto.relacao}.`,
+            tasks: deduplicarTarefas(tasks),
+            routes: deduplicarRotas(routes),
+            entities,
+            enums,
+        });
+    }
+    return [...modulos.values()];
+}
+function extrairTiposPython(texto) {
+    const encontrados = new Map();
+    const regexBaseModel = /^class\s+(\w+)(?:\(([^)]*)\))?:\n((?:^[ \t].*(?:\n|$))*)/gm;
+    for (const match of texto.matchAll(regexBaseModel)) {
+        const [, nome, bases = "", corpo] = match;
+        if (!bases.includes("BaseModel")) {
+            continue;
+        }
+        const campos = [...corpo.matchAll(/^\s{4}(\w+)\s*:\s*([^\n=]+)(?:\s*=.+)?$/gm)].map((campo) => ({
+            nome: campo[1],
+            tipoTexto: campo[2].trim(),
+            obrigatorio: !/=/.test(campo[0]),
+        }));
+        encontrados.set(nome, { tipo: "objeto", nome: nome, campos });
+    }
+    const regexEnum = /^class\s+(\w+)(?:\(([^)]*)\))?:\n((?:^[ \t].*(?:\n|$))*)/gm;
+    for (const match of texto.matchAll(regexEnum)) {
+        const [, nome, bases = "", corpo] = match;
+        if (!/(Enum|StrEnum)/.test(bases)) {
+            continue;
+        }
+        const valores = [...corpo.matchAll(/^\s{4}(\w+)\s*=\s*["']([^"']+)["']$/gm)].map((valor) => valor[1]).filter(Boolean);
+        if (valores.length) {
+            encontrados.set(nome, { tipo: "enum", nome: nome, valores });
+        }
+    }
+    return encontrados;
+}
+function mapearTipoPythonParaSema(tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados) {
+    if (!tipoTexto) {
+        return "Json";
+    }
+    const limpo = tipoTexto.replace(/\s+/g, "");
+    const basico = mapearTipoPrimitivo(limpo);
+    if (basico !== limpo) {
+        return basico;
+    }
+    const simples = limpo.replace(/Optional\[(.+)\]/, "$1").replace(/list\[(.+)\]/i, "Json").replace(/dict\[(.+)\]/i, "Json");
+    if (tipos.has(simples)) {
+        const encontrado = tipos.get(simples);
+        if (encontrado.tipo === "enum") {
+            enumsReferenciados.add(encontrado.nome);
+            return encontrado.nome;
+        }
+        if (!pareceWrapperTipo(encontrado.nome)) {
+            entidadesReferenciadas.add(encontrado.nome);
+            return encontrado.nome;
+        }
+    }
+    return "Json";
+}
+function expandirCamposPython(nomeParametro, tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados, obrigatorio) {
+    if (!tipoTexto) {
+        return [{ nome: paraSnakeCase(nomeParametro), tipo: "Json", obrigatorio }];
+    }
+    const limpo = tipoTexto.replace(/\s+/g, "").replace(/Optional\[(.+)\]/, "$1");
+    const descoberto = tipos.get(limpo);
+    if (descoberto?.tipo === "objeto" && pareceWrapperTipo(descoberto.nome) && descoberto.campos) {
+        return descoberto.campos.map((campo) => ({
+            nome: paraSnakeCase(campo.nome),
+            tipo: mapearTipoPythonParaSema(campo.tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados),
+            obrigatorio: campo.obrigatorio,
+        }));
+    }
+    return [{
+            nome: paraSnakeCase(nomeParametro),
+            tipo: mapearTipoPythonParaSema(tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados),
+            obrigatorio,
+        }];
+}
+function criarEntidadesPython(tipos, entidadesReferenciadas, enumsReferenciados) {
+    const entities = [...entidadesReferenciadas]
+        .map((nome) => tipos.get(nome))
+        .filter((item) => Boolean(item?.tipo === "objeto" && item.campos))
+        .map((item) => ({
+        nome: item.nome,
+        campos: item.campos.map((campo) => ({
+            nome: paraSnakeCase(campo.nome),
+            tipo: mapearTipoPythonParaSema(campo.tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados),
+            obrigatorio: campo.obrigatorio,
+        })),
+    }));
+    const enums = [...enumsReferenciados]
+        .map((nome) => tipos.get(nome))
+        .filter((item) => Boolean(item?.tipo === "enum" && item.valores))
+        .map((item) => ({
+        nome: item.nome,
+        valores: item.valores,
+    }));
+    return { entities: deduplicarEntidades(entities), enums: deduplicarEnums(enums) };
+}
+function extrairErrosPython(texto) {
+    const erros = new Map();
+    for (const match of texto.matchAll(/raise\s+(\w+)(?:\(([^)]*)\))?/g)) {
+        const nomeBruto = match[1];
+        const mensagem = (match[2] ?? "").match(/["']([^"']+)["']/)?.[1] ?? `Erro importado automaticamente de ${nomeBruto}.`;
+        erros.set(normalizarNomeErroBruto(nomeBruto), 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
+        ? paraSnakeCase(segmento)
+        : paraIdentificadorModulo(segmento))
+        .filter(Boolean);
+    return [...segmentos, simbolo].join(".");
+}
+function caminhoImplPython(diretorioBase, arquivo, simbolo) {
+    return caminhoImplGenerico(diretorioBase, arquivo, simbolo);
+}
+function caminhoImplDart(diretorioBase, arquivo, simbolo) {
+    return caminhoImplGenerico(diretorioBase, arquivo, simbolo);
+}
+function dividirParametrosPython(parametros) {
+    const partes = [];
+    let atual = "";
+    let profundidade = 0;
+    for (const caractere of parametros) {
+        if (caractere === "," && profundidade === 0) {
+            if (atual.trim()) {
+                partes.push(atual.trim());
+            }
+            atual = "";
+            continue;
+        }
+        if (["[", "(", "{", "<"].includes(caractere)) {
+            profundidade += 1;
+        }
+        else if (["]", ")", "}", ">"].includes(caractere) && profundidade > 0) {
+            profundidade -= 1;
+        }
+        atual += caractere;
+    }
+    if (atual.trim()) {
+        partes.push(atual.trim());
+    }
+    return partes;
+}
+function extrairAssinaturaParametrosPython(parametros) {
+    const assinatura = new Map();
+    for (const item of dividirParametrosPython(parametros)) {
+        if (!item || item.startsWith("self") || item.startsWith("cls") || item.startsWith("*")) {
+            continue;
+        }
+        const obrigatorio = !item.includes("=");
+        const semValorPadrao = item.split("=")[0]?.trim() ?? item.trim();
+        const [nomeBruto, tipo] = semValorPadrao.split(":").map((parte) => parte.trim());
+        const nome = nomeBruto?.replace(/^\*{1,2}/, "").trim();
+        if (!nome) {
+            continue;
+        }
+        assinatura.set(nome, {
+            tipoTexto: tipo || undefined,
+            obrigatorio,
+        });
+    }
+    return assinatura;
+}
+function mapearConversorFlaskParaSema(conversor) {
+    switch ((conversor ?? "").toLowerCase()) {
+        case "int":
+            return "Inteiro";
+        case "float":
+            return "Decimal";
+        case "uuid":
+            return "Id";
+        case "path":
+        default:
+            return "Texto";
+    }
+}
+function criarInputRotaFlask(caminho, parametros, tiposGlobais, entitiesRef, enumsRef) {
+    const assinatura = extrairAssinaturaParametrosPython(parametros);
+    return extrairParametrosCaminhoFlask(caminho).map((parametro) => {
+        const correspondente = assinatura.get(parametro.nome);
+        return {
+            nome: paraSnakeCase(parametro.nome),
+            tipo: correspondente?.tipoTexto
+                ? mapearTipoPythonParaSema(correspondente.tipoTexto, tiposGlobais, entitiesRef, enumsRef)
+                : mapearConversorFlaskParaSema(parametro.conversor),
+            obrigatorio: correspondente?.obrigatorio ?? true,
+        };
+    });
+}
+async function importarPythonBase(diretorio, namespaceBase, modoHttp = "nenhum") {
+    const arquivos = (await listarArquivosRecursivos(diretorio, [".py"]))
+        .filter((arquivo) => !arquivo.endsWith("__init__.py") && !/tests?[\\/]/i.test(arquivo));
+    const textos = new Map();
+    const tiposGlobais = new Map();
+    for (const arquivo of arquivos) {
+        const texto = await readFile(arquivo, "utf8");
+        textos.set(arquivo, texto);
+        for (const [nome, tipo] of extrairTiposPython(texto)) {
+            if (!tiposGlobais.has(nome)) {
+                tiposGlobais.set(nome, tipo);
+            }
+        }
+    }
+    const modulos = new Map();
+    for (const arquivo of arquivos) {
+        const texto = textos.get(arquivo);
+        const relacao = path.relative(diretorio, arquivo);
+        const contextoSegmentos = inferirContextoPorArquivo(relacao);
+        const nomeModulo = [namespaceBase, ...contextoSegmentos].join(".");
+        const entitiesRef = new Set();
+        const enumsRef = new Set();
+        const tasks = [];
+        const routes = [];
+        if (modoHttp === "fastapi") {
+            const prefixo = texto.match(/APIRouter\s*\(\s*prefix\s*=\s*["']([^"']+)["']/)?.[1];
+            const routeRegex = /@(?:router|app)\.(get|post|put|patch|delete)\(([^)]*)\)\s*\n(?:async\s+)?def\s+(\w+)\(([^)]*)\)(?:\s*->\s*([^:]+))?:/g;
+            for (const match of texto.matchAll(routeRegex)) {
+                const metodo = match[1].toUpperCase();
+                const argumentoDecorator = match[2] ?? "";
+                const sufixo = argumentoDecorator.match(/["']([^"']+)["']/)?.[1];
+                const nomeFuncao = match[3];
+                const parametros = match[4];
+                const retorno = match[5]?.trim();
+                const routeInput = parametros
+                    .split(",")
+                    .map((item) => item.trim())
+                    .filter(Boolean)
+                    .filter((item) => !item.startsWith("self") && !item.startsWith("cls"))
+                    .flatMap((item) => {
+                    const [nome, tipo] = item.split(":").map((parte) => parte.trim());
+                    const obrigatorio = !item.includes("=");
+                    return expandirCamposPython(nome, tipo, tiposGlobais, entitiesRef, enumsRef, obrigatorio);
+                });
+                const routeOutput = retorno && mapearTipoPrimitivo(retorno) === "Vazio"
+                    ? []
+                    : deduplicarCampos(expandirCamposPython("resultado", retorno, tiposGlobais, entitiesRef, enumsRef, false));
+                const taskNome = paraSnakeCase(nomeFuncao);
+                routes.push({
+                    nome: `${taskNome}_publico`,
+                    resumo: `Rota FastAPI importada automaticamente de ${relacao}#${nomeFuncao}.`,
+                    metodo,
+                    caminho: juntarCaminhoHttp(prefixo, sufixo),
+                    task: taskNome,
+                    input: deduplicarCampos(routeInput),
+                    output: routeOutput,
+                    errors: [],
+                });
+            }
+        }
+        else if (modoHttp === "flask") {
+            for (const rota of extrairRotasFlaskDecoradas(texto)) {
+                const taskNome = paraSnakeCase(rota.nomeFuncao);
+                const nomeBase = `${taskNome}_publico`;
+                const nome = routes.some((route) => route.nome === nomeBase)
+                    ? `${taskNome}_${rota.metodo.toLowerCase()}_publico`
+                    : nomeBase;
+                routes.push({
+                    nome,
+                    resumo: `Rota Flask importada automaticamente de ${relacao}#${rota.nomeFuncao}.`,
+                    metodo: rota.metodo,
+                    caminho: rota.caminho,
+                    task: taskNome,
+                    input: deduplicarCampos(criarInputRotaFlask(rota.caminho, rota.parametros, tiposGlobais, entitiesRef, enumsRef)),
+                    output: [],
+                    errors: [],
+                });
+            }
+        }
+        const funcRegex = /^(async\s+def|def)\s+(\w+)\(([^)]*)\)(?:\s*->\s*([^:]+))?:/gm;
+        for (const match of texto.matchAll(funcRegex)) {
+            const nomeFuncao = match[2];
+            if (nomeFuncao.startsWith("_")) {
+                continue;
+            }
+            const parametros = match[3];
+            const retorno = match[4]?.trim();
+            const inicioCorpo = match.index ?? 0;
+            const trecho = texto.slice(inicioCorpo, Math.min(texto.length, inicioCorpo + 1500));
+            const input = parametros
+                .split(",")
+                .map((item) => item.trim())
+                .filter(Boolean)
+                .filter((item) => !item.startsWith("self") && !item.startsWith("cls"))
+                .flatMap((item) => {
+                const [nome, tipo] = item.split(":").map((parte) => parte.trim());
+                const obrigatorio = !item.includes("=");
+                return expandirCamposPython(nome, tipo, tiposGlobais, entitiesRef, enumsRef, obrigatorio);
+            });
+            const output = retorno && mapearTipoPrimitivo(retorno) === "Vazio"
+                ? []
+                : deduplicarCampos(expandirCamposPython("resultado", retorno, tiposGlobais, entitiesRef, enumsRef, false));
+            tasks.push({
+                nome: paraSnakeCase(nomeFuncao),
+                resumo: `Task importada automaticamente de ${relacao}#${nomeFuncao}.`,
+                input: deduplicarCampos(input),
+                output,
+                errors: extrairErrosPython(trecho),
+                effects: descreverEfeitosPorHeuristica(trecho),
+                impl: { py: caminhoImplPython(diretorio, arquivo, nomeFuncao) },
+                origemArquivo: relacao,
+                origemSimbolo: nomeFuncao,
+            });
+        }
+        const classRegex = /^class\s+(\w+)(?:\(([^)]*)\))?:\n((?:^[ \t].*(?:\n|$))*)/gm;
+        for (const match of texto.matchAll(classRegex)) {
+            const nomeClasse = match[1];
+            const bases = match[2] ?? "";
+            const corpo = match[3];
+            if (/(BaseModel|Enum|StrEnum)/.test(bases)) {
+                continue;
+            }
+            for (const metodo of corpo.matchAll(/^\s{4}(?:async\s+def|def)\s+(\w+)\(([^)]*)\)(?:\s*->\s*([^:]+))?:/gm)) {
+                const nomeMetodo = metodo[1];
+                if (nomeMetodo.startsWith("_")) {
+                    continue;
+                }
+                const parametros = metodo[2];
+                const retorno = metodo[3]?.trim();
+                const input = parametros
+                    .split(",")
+                    .map((item) => item.trim())
+                    .filter(Boolean)
+                    .filter((item) => !item.startsWith("self") && !item.startsWith("cls"))
+                    .flatMap((item) => {
+                    const [nome, tipo] = item.split(":").map((parte) => parte.trim());
+                    const obrigatorio = !item.includes("=");
+                    return expandirCamposPython(nome, tipo, tiposGlobais, entitiesRef, enumsRef, obrigatorio);
+                });
+                const output = retorno && mapearTipoPrimitivo(retorno) === "Vazio"
+                    ? []
+                    : deduplicarCampos(expandirCamposPython("resultado", retorno, tiposGlobais, entitiesRef, enumsRef, false));
+                tasks.push({
+                    nome: paraSnakeCase(nomeMetodo),
+                    resumo: `Task importada automaticamente de ${relacao}#${nomeClasse}.${nomeMetodo}.`,
+                    input: deduplicarCampos(input),
+                    output,
+                    errors: extrairErrosPython(corpo),
+                    effects: descreverEfeitosPorHeuristica(corpo),
+                    impl: { py: caminhoImplPython(diretorio, arquivo, `${nomeClasse}.${nomeMetodo}`) },
+                    origemArquivo: relacao,
+                    origemSimbolo: `${nomeClasse}.${nomeMetodo}`,
+                });
+            }
+        }
+        if (!tasks.length && !routes.length) {
+            continue;
+        }
+        const { entities, enums } = criarEntidadesPython(tiposGlobais, entitiesRef, enumsRef);
+        sincronizarRotasComTasks(routes, tasks);
+        modulos.set(nomeModulo, {
+            nome: nomeModulo,
+            resumo: `Rascunho Sema importado automaticamente de ${relacao}.`,
+            tasks: deduplicarTarefas(tasks),
+            routes: deduplicarRotas(routes),
+            entities,
+            enums,
+        });
+    }
+    return [...modulos.values()];
+}
+async function importarDartBase(diretorio, namespaceBase) {
+    const arquivos = (await listarArquivosRecursivos(diretorio, [".dart"]))
+        .filter((arquivo) => !arquivo.endsWith(".g.dart") && !arquivo.endsWith(".freezed.dart"));
+    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 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+/);
+                const nomeParametro = partes.at(-1) ?? "param";
+                const tipoParametro = partes.length > 1 ? partes.slice(0, -1).join(" ") : undefined;
+                return {
+                    nome: paraSnakeCase(nomeParametro),
+                    tipo: mapearTipoPrimitivo(tipoParametro ?? "Json"),
+                    obrigatorio: item.includes("required"),
+                };
+            });
+            const output = retorno && mapearTipoPrimitivo(retorno) === "Vazio"
+                ? []
+                : [{ nome: "resultado", tipo: mapearTipoPrimitivo(retorno || "Json"), obrigatorio: false }];
+            tasks.push({
+                nome: paraSnakeCase(nome),
+                resumo: `Task importada automaticamente de ${relacao}#${nome}.`,
+                input,
+                output,
+                errors: [],
+                effects: descreverEfeitosPorHeuristica(texto),
+                impl: { dart: caminhoImplDart(diretorio, arquivo, nome) },
+                origemArquivo: relacao,
+                origemSimbolo: nome,
+            });
+        }
+        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 = []) {
+    sincronizarRotasComTasks(routes, tasks);
+    return {
+        nome,
+        resumo,
+        tasks: deduplicarTarefas(tasks),
+        routes: deduplicarRotas(routes),
+        entities: [],
+        enums: [],
+    };
+}
+function acumularModuloImportado(modulos, modulo) {
+    const existente = modulos.get(modulo.nome);
+    if (!existente) {
+        modulos.set(modulo.nome, modulo);
+        return;
+    }
+    existente.tasks = deduplicarTarefas([...existente.tasks, ...modulo.tasks]);
+    existente.routes = deduplicarRotas([...existente.routes, ...modulo.routes]);
+    existente.entities = deduplicarEntidades([...existente.entities, ...modulo.entities]);
+    existente.enums = deduplicarEnums([...existente.enums, ...modulo.enums]);
+}
+function selecionarSimbolosPreferidos(simbolos) {
+    const mapa = new Map();
+    for (const simbolo of simbolos) {
+        const chave = simbolo.simbolo.split(".").at(-1) ?? simbolo.simbolo;
+        const existente = mapa.get(chave);
+        if (!existente) {
+            mapa.set(chave, simbolo);
+            continue;
+        }
+        const pontuacaoAtual = simbolo.simbolo.split(".").length;
+        const pontuacaoExistente = existente.simbolo.split(".").length;
+        if (pontuacaoAtual > pontuacaoExistente) {
+            mapa.set(chave, simbolo);
+        }
+    }
+    return [...mapa.values()];
+}
+async function existeArquivo(caminho) {
+    try {
+        await access(caminho);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolverArquivoRustParaSimbolo(diretorio, relacaoFonte, simbolo) {
+    const partes = simbolo.split(".").filter(Boolean);
+    if (partes.length <= 1) {
+        return path.join(diretorio, relacaoFonte);
+    }
+    const moduloPartes = partes.slice(0, -1);
+    const baseAtual = path.dirname(relacaoFonte);
+    const candidatos = [
+        path.join(baseAtual, ...moduloPartes) + ".rs",
+        path.join(baseAtual, ...moduloPartes, "mod.rs"),
+        path.join("src", ...moduloPartes) + ".rs",
+        path.join("src", ...moduloPartes, "mod.rs"),
+    ];
+    for (const candidato of candidatos) {
+        const absoluto = path.join(diretorio, candidato);
+        if (await existeArquivo(absoluto)) {
+            return absoluto;
+        }
+    }
+    return path.join(diretorio, relacaoFonte);
+}
+async function importarDotnetBase(diretorio, namespaceBase) {
+    const arquivos = (await listarArquivosRecursivos(diretorio, [".cs"]))
+        .filter((arquivo) => !/(^|[\\/])(bin|obj|Test[s]?)([\\/]|$)/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, { preservarUltimo: true, snakeCaseUltimo: true });
+        const nomeModulo = [namespaceBase, ...contextoSegmentos].join(".");
+        const tasks = [];
+        const routes = [];
+        for (const simbolo of extrairSimbolosDotnet(texto)) {
+            const taskNome = paraSnakeCase(simbolo.simbolo.split(".").at(-1) ?? simbolo.simbolo);
+            tasks.push({
+                nome: taskNome,
+                resumo: `Task importada automaticamente de ${relacao}#${simbolo.simbolo}.`,
+                input: simbolo.parametros.map((parametro) => ({
+                    nome: paraSnakeCase(parametro.nome),
+                    tipo: mapearTipoBackendParaSema(parametro.tipoTexto),
+                    obrigatorio: parametro.obrigatorio,
+                })),
+                output: criarCampoResultadoBackend(simbolo.retorno),
+                errors: [],
+                effects: descreverEfeitosPorHeuristica(texto),
+                impl: { cs: caminhoImplGenerico(diretorio, arquivo, simbolo.simbolo, { snakeCaseUltimoArquivo: true }) },
+                origemArquivo: relacao,
+                origemSimbolo: simbolo.simbolo,
+            });
+        }
+        for (const rota of extrairRotasDotnet(texto)) {
+            const taskNome = paraSnakeCase(rota.simbolo.split(".").at(-1) ?? rota.simbolo);
+            const output = criarCampoResultadoBackend(rota.retorno);
+            tasks.push({
+                nome: taskNome,
+                resumo: `Task HTTP ASP.NET Core importada automaticamente de ${relacao}#${rota.simbolo}.`,
+                input: camposDeParametrosRotaBackend(rota.parametros),
+                output,
+                errors: [],
+                effects: [{ categoria: "consulta", alvo: "http", criticidade: "media" }],
+                impl: { cs: caminhoImplGenerico(diretorio, arquivo, rota.simbolo, { snakeCaseUltimoArquivo: true }) },
+                origemArquivo: relacao,
+                origemSimbolo: rota.simbolo,
+            });
+            routes.push({
+                nome: `${taskNome}_publico`,
+                resumo: `Rota ASP.NET Core 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));
+    }
+    return [...modulos.values()];
+}
+async function importarJavaBase(diretorio, namespaceBase) {
+    const arquivos = (await listarArquivosRecursivos(diretorio, [".java"]))
+        .filter((arquivo) => !/(^|[\\/])(target|build|out|Test[s]?)([\\/]|$)/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, { preservarUltimo: true, snakeCaseUltimo: true });
+        const nomeModulo = [namespaceBase, ...contextoSegmentos].join(".");
+        const tasks = [];
+        const routes = [];
+        for (const simbolo of extrairSimbolosJava(texto)) {
+            const taskNome = paraSnakeCase(simbolo.simbolo.split(".").at(-1) ?? simbolo.simbolo);
+            tasks.push({
+                nome: taskNome,
+                resumo: `Task importada automaticamente de ${relacao}#${simbolo.simbolo}.`,
+                input: simbolo.parametros.map((parametro) => ({
+                    nome: paraSnakeCase(parametro.nome),
+                    tipo: mapearTipoBackendParaSema(parametro.tipoTexto),
+                    obrigatorio: parametro.obrigatorio,
+                })),
+                output: criarCampoResultadoBackend(simbolo.retorno),
+                errors: [],
+                effects: descreverEfeitosPorHeuristica(texto),
+                impl: { java: caminhoImplGenerico(diretorio, arquivo, simbolo.simbolo, { snakeCaseUltimoArquivo: true }) },
+                origemArquivo: relacao,
+                origemSimbolo: simbolo.simbolo,
+            });
+        }
+        for (const rota of extrairRotasJava(texto)) {
+            const taskNome = paraSnakeCase(rota.simbolo.split(".").at(-1) ?? rota.simbolo);
+            const output = criarCampoResultadoBackend(rota.retorno);
+            tasks.push({
+                nome: taskNome,
+                resumo: `Task HTTP Spring Boot importada automaticamente de ${relacao}#${rota.simbolo}.`,
+                input: camposDeParametrosRotaBackend(rota.parametros),
+                output,
+                errors: [],
+                effects: [{ categoria: "consulta", alvo: "http", criticidade: "media" }],
+                impl: { java: caminhoImplGenerico(diretorio, arquivo, rota.simbolo, { snakeCaseUltimoArquivo: true }) },
+                origemArquivo: relacao,
+                origemSimbolo: rota.simbolo,
+            });
+            routes.push({
+                nome: `${taskNome}_publico`,
+                resumo: `Rota Spring Boot 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));
+    }
+    return [...modulos.values()];
+}
+async function importarGoBase(diretorio, namespaceBase) {
+    const arquivos = await listarArquivosRecursivos(diretorio, [".go"]);
+    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 extrairSimbolosGo(texto)) {
+            const taskNome = paraSnakeCase(simbolo.simbolo.split(".").at(-1) ?? simbolo.simbolo);
+            tasks.push({
+                nome: taskNome,
+                resumo: `Task importada automaticamente de ${relacao}#${simbolo.simbolo}.`,
+                input: simbolo.parametros.map((parametro) => ({
+                    nome: paraSnakeCase(parametro.nome),
+                    tipo: mapearTipoBackendParaSema(parametro.tipoTexto),
+                    obrigatorio: parametro.obrigatorio,
+                })),
+                output: criarCampoResultadoBackend(simbolo.retorno),
+                errors: [],
+                effects: descreverEfeitosPorHeuristica(texto),
+                impl: { go: caminhoImplGenerico(diretorio, arquivo, simbolo.simbolo) },
+                origemArquivo: relacao,
+                origemSimbolo: simbolo.simbolo,
+            });
+        }
+        for (const rota of extrairRotasGo(texto)) {
+            const taskNome = paraSnakeCase(rota.simbolo.split(".").at(-1) ?? rota.simbolo);
+            tasks.push({
+                nome: taskNome,
+                resumo: `Task HTTP Go importada automaticamente de ${relacao}#${rota.simbolo}.`,
+                input: camposDeParametrosRotaBackend(rota.parametros),
+                output: [{ nome: "resultado", tipo: "Json", obrigatorio: false }],
+                errors: [],
+                effects: [{ categoria: "consulta", alvo: "http", criticidade: "media" }],
+                impl: { go: caminhoImplGenerico(diretorio, arquivo, rota.simbolo) },
+                origemArquivo: relacao,
+                origemSimbolo: rota.simbolo,
+            });
+            routes.push({
+                nome: `${taskNome}_publico`,
+                resumo: `Rota Go importada automaticamente de ${relacao}#${rota.simbolo}.`,
+                metodo: rota.metodo,
+                caminho: rota.caminho,
+                task: taskNome,
+                input: camposDeParametrosRotaBackend(rota.parametros),
+                output: [{ nome: "resultado", tipo: "Json", obrigatorio: false }],
+                errors: [],
+            });
+        }
+        if (tasks.length === 0 && routes.length === 0) {
+            continue;
+        }
+        modulos.set(nomeModulo, criarModuloImportadoSimples(nomeModulo, `Rascunho Sema importado automaticamente de ${relacao}.`, tasks, routes));
+    }
+    return [...modulos.values()];
+}
+async function importarRustBase(diretorio, namespaceBase) {
+    const arquivos = await listarArquivosRecursivos(diretorio, [".rs"]);
+    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 extrairSimbolosRust(texto)) {
+            const taskNome = paraSnakeCase(simbolo.simbolo.split(".").at(-1) ?? simbolo.simbolo);
+            tasks.push({
+                nome: taskNome,
+                resumo: `Task importada automaticamente de ${relacao}#${simbolo.simbolo}.`,
+                input: simbolo.parametros.map((parametro) => ({
+                    nome: paraSnakeCase(parametro.nome),
+                    tipo: mapearTipoBackendParaSema(parametro.tipoTexto),
+                    obrigatorio: parametro.obrigatorio,
+                })),
+                output: criarCampoResultadoBackend(simbolo.retorno),
+                errors: [],
+                effects: descreverEfeitosPorHeuristica(texto),
+                impl: { rust: caminhoImplGenerico(diretorio, arquivo, simbolo.simbolo) },
+                origemArquivo: relacao,
+                origemSimbolo: simbolo.simbolo,
+            });
+        }
+        acumularModuloImportado(modulos, criarModuloImportadoSimples(nomeModulo, `Rascunho Sema importado automaticamente de ${relacao}.`, tasks, routes));
+        for (const rota of extrairRotasRust(texto)) {
+            const simboloLimpo = rota.simbolo.replace(/::/g, ".");
+            const nomeSimbolo = simboloLimpo.split(".").at(-1) ?? simboloLimpo;
+            const arquivoAlvo = await resolverArquivoRustParaSimbolo(diretorio, relacao, simboloLimpo);
+            const relacaoAlvo = path.relative(diretorio, arquivoAlvo);
+            const moduloAlvo = [namespaceBase, ...inferirContextoPorArquivo(relacaoAlvo)].join(".");
+            const taskNome = paraSnakeCase(rota.simbolo.split(".").at(-1) ?? rota.simbolo);
+            const task = {
+                nome: taskNome,
+                resumo: `Task HTTP Axum importada automaticamente de ${relacao}#${rota.simbolo}.`,
+                input: camposDeParametrosRotaBackend(rota.parametros),
+                output: [{ nome: "resultado", tipo: "Json", obrigatorio: false }],
+                errors: [],
+                effects: [{ categoria: "consulta", alvo: "http", criticidade: "media" }],
+                impl: { rust: caminhoImplGenerico(diretorio, arquivoAlvo, nomeSimbolo) },
+                origemArquivo: relacaoAlvo,
+                origemSimbolo: nomeSimbolo,
+            };
+            const route = {
+                nome: `${taskNome}_publico`,
+                resumo: `Rota Axum importada automaticamente de ${relacao}#${rota.simbolo}.`,
+                metodo: rota.metodo,
+                caminho: rota.caminho,
+                task: taskNome,
+                input: camposDeParametrosRotaBackend(rota.parametros),
+                output: [{ nome: "resultado", tipo: "Json", obrigatorio: false }],
+                errors: [],
+            };
+            acumularModuloImportado(modulos, criarModuloImportadoSimples(moduloAlvo, `Rascunho Sema importado automaticamente de ${relacaoAlvo}.`, [task], [route]));
+        }
+    }
+    return [...modulos.values()];
+}
+async function importarCppBase(diretorio, namespaceBase) {
+    const arquivos = (await listarArquivosRecursivos(diretorio, [".cpp", ".cc", ".cxx", ".hpp", ".h"]))
+        .filter((arquivo) => !/(^|[\\/])(windows|linux|macos|runner|flutter|ephemeral|build|vendor)([\\/]|$)/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 = [];
+        for (const simbolo of selecionarSimbolosPreferidos(extrairSimbolosCpp(texto))) {
+            const taskNome = paraSnakeCase(simbolo.simbolo.split(".").at(-1) ?? simbolo.simbolo);
+            tasks.push({
+                nome: taskNome,
+                resumo: `Task importada automaticamente de ${relacao}#${simbolo.simbolo}.`,
+                input: simbolo.parametros.map((parametro) => ({
+                    nome: paraSnakeCase(parametro.nome),
+                    tipo: mapearTipoBackendParaSema(parametro.tipoTexto),
+                    obrigatorio: parametro.obrigatorio,
+                })),
+                output: [{ nome: "resultado", tipo: "Json", obrigatorio: false }],
+                errors: [],
+                effects: descreverEfeitosPorHeuristica(texto),
+                impl: { cpp: caminhoImplGenerico(diretorio, arquivo, simbolo.simbolo) },
+                origemArquivo: relacao,
+                origemSimbolo: simbolo.simbolo,
+            });
+        }
+        if (tasks.length === 0) {
+            continue;
+        }
+        acumularModuloImportado(modulos, criarModuloImportadoSimples(nomeModulo, `Rascunho Sema importado automaticamente de ${relacao}.`, tasks));
+    }
+    return [...modulos.values()];
+}
+export async function importarProjetoLegado(fonte, diretorio, namespaceBase) {
+    const base = path.resolve(diretorio);
+    const namespace = inferirNamespaceBase(base, namespaceBase);
+    let modulos = [];
+    if (fonte === "nestjs") {
+        modulos = await importarTypeScriptBase(base, namespace, true);
+    }
+    else if (fonte === "nextjs") {
+        modulos = await importarNextJsBase(base, namespace);
+    }
+    else if (fonte === "firebase") {
+        modulos = await importarFirebaseBase(base, namespace);
+    }
+    else if (fonte === "typescript") {
+        modulos = await importarTypeScriptBase(base, namespace, false);
+    }
+    else if (fonte === "fastapi") {
+        modulos = await importarPythonBase(base, namespace, "fastapi");
+    }
+    else if (fonte === "flask") {
+        modulos = await importarPythonBase(base, namespace, "flask");
+    }
+    else if (fonte === "python") {
+        modulos = await importarPythonBase(base, namespace, "nenhum");
+    }
+    else if (fonte === "dart") {
+        modulos = await importarDartBase(base, namespace);
+    }
+    else if (fonte === "dotnet") {
+        modulos = await importarDotnetBase(base, namespace);
+    }
+    else if (fonte === "java") {
+        modulos = await importarJavaBase(base, namespace);
+    }
+    else if (fonte === "go") {
+        modulos = await importarGoBase(base, namespace);
+    }
+    else if (fonte === "rust") {
+        modulos = await importarRustBase(base, namespace);
+    }
+    else if (fonte === "cpp") {
+        modulos = await importarCppBase(base, namespace);
+    }
+    const arquivos = [];
+    for (const modulo of modulos) {
+        const bruto = moduloParaCodigo(modulo);
+        const formatado = await formatarModuloImportado(bruto, `${modulo.nome}.sema`);
+        arquivos.push(montarArquivoImportado(modulo, namespace, formatado));
+    }
+    const diagnosticos = compilarProjeto(arquivos.map((arquivo) => ({
+        caminho: path.join(base, ".tmp", "importado", arquivo.caminhoRelativo),
+        codigo: arquivo.conteudo,
+    }))).diagnosticos;
+    return {
+        fonte,
+        diretorio: base,
+        namespaceBase: namespace,
+        arquivos,
+        diagnosticos,
+    };
+}
+export function resumoImportacao(resultado) {
+    return {
+        modulos: resultado.arquivos.length,
+        tarefas: resultado.arquivos.reduce((total, arquivo) => total + arquivo.tarefas, 0),
+        rotas: resultado.arquivos.reduce((total, arquivo) => total + arquivo.rotas, 0),
+        entidades: resultado.arquivos.reduce((total, arquivo) => total + arquivo.entidades, 0),
+        enums: resultado.arquivos.reduce((total, arquivo) => total + arquivo.enums, 0),
+        diagnosticos: resultado.diagnosticos.length,
+        sucesso: !temErros(resultado.diagnosticos),
+    };
+}
+//# sourceMappingURL=importador.js.map