@semacode/cli 2.2.0 → 2.3.1

package/dist/drift.part13.js

@@ -1,26 +1,256 @@
-// SEMA-GOVERNED: sema.governanca_ia_contexto
-// Descricao: prepara indices vivos para drift; consulte contratos/sema/governanca_ia_contexto.sema antes de editar.
-import { resolverDiretoriosCodigoEscopoReal } from "./drift.part02.js";
-import { indexarArquivosRastreaveis } from "./drift.part04.js";
+// SEMA-GOVERNED: sema.produto.governanca_ia.drift
+// Descricao: planeja antes de catalogar e indexa unidades incrementais com uma unica leitura fisica por arquivo.
+import pacoteCli from "../package.json" with { type: "json" };
+import path from "node:path";
+import { performance } from "node:perf_hooks";
+import ts from "typescript";
+import { resolverDiretoriosIgnoradosAtivos } from "./drift.part01.js";
+import { EXTENSOES_ARQUIVOS_RASTREAVEIS_DRIFT, indexarArquivosRastreaveis } from "./drift.part04.js";
 import { indexarTypeScript } from "./drift.part06.js";
-import { indexarCpp, indexarDart, indexarDotnet, indexarGo, indexarJava, indexarLua, indexarPersistenciaDeclarativa, indexarPhp, indexarPython, indexarRust } from "./drift.part07.js";
+import { indexarCpp, indexarDart, indexarDotnet, indexarGo, indexarJava, indexarLua, indexarPersistenciaDeclarativa, indexarPhp, indexarPython, indexarRust, } from "./drift.part07.js";
 import { indexarPersistenciaDetalhada } from "./drift.part08.js";
 import { construirMapaRecursos } from "./drift.part10.js";
-export async function prepararIndicesDrift(contexto, configuracaoEscopo) {
-    const diretoriosCodigoAtivos = resolverDiretoriosCodigoEscopoReal(contexto, configuracaoEscopo);
-    const indexTs = await indexarTypeScript(diretoriosCodigoAtivos);
-    const indexPy = await indexarPython(diretoriosCodigoAtivos);
-    const indexDart = await indexarDart(diretoriosCodigoAtivos);
-    const indexDotnet = await indexarDotnet(diretoriosCodigoAtivos);
-    const indexJava = await indexarJava(diretoriosCodigoAtivos);
-    const indexGo = await indexarGo(diretoriosCodigoAtivos);
-    const indexRust = await indexarRust(diretoriosCodigoAtivos);
-    const indexLua = await indexarLua(diretoriosCodigoAtivos);
-    const indexPhp = await indexarPhp(diretoriosCodigoAtivos);
-    const indexPersistencia = await indexarPersistenciaDeclarativa(diretoriosCodigoAtivos);
-    const detalhesPersistencia = await indexarPersistenciaDetalhada(diretoriosCodigoAtivos);
-    const indexCpp = await indexarCpp(diretoriosCodigoAtivos);
-    const arquivosRastreaveis = await indexarArquivosRastreaveis(diretoriosCodigoAtivos);
+import { emitirDiagnosticosArquivosOrcamento, workspaceExigeCabecalhoCodigoGovernado, } from "./driftOrcamento.js";
+import { criarCatalogoPersistenteDrift } from "./driftCatalogoPersistente.js";
+import { CacheIncrementalDrift, FILE_INDEX_SCHEMA, } from "./driftCacheIncremental.js";
+import { expandirDependenciasPlanoDrift, extrairReferenciasLocaisDrift, mapearDependenciasCatalogadasDrift, planejarEscopoDrift, } from "./driftEscopo.js";
+const EXTENSOES_ANALISE_DRIFT = new Set([
+    ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+    ".py", ".dart", ".lua", ".cs", ".java", ".go", ".rs", ".php",
+    ".cpp", ".cc", ".cxx", ".hpp", ".h",
+    ".sql", ".psql", ".ddl", ".prisma",
+]);
+const EXTENSOES_TYPESCRIPT_DRIFT = new Set([
+    ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+]);
+const EXTENSOES_DEPENDENCIA_TYPESCRIPT_DRIFT = new Set([
+    ...EXTENSOES_TYPESCRIPT_DRIFT,
+    ".html", ".htm", ".css",
+]);
+function chaveCaminho(caminho) {
+    const absoluto = path.normalize(path.resolve(caminho));
+    return process.platform === "win32" ? absoluto.toLowerCase() : absoluto;
+}
+function chaveRelativa(caminho) {
+    const normalizado = caminho.replace(/\\/g, "/");
+    return process.platform === "win32" ? normalizado.toLowerCase() : normalizado;
+}
+function paraJsonCache(valor) {
+    return JSON.parse(JSON.stringify(valor));
+}
+function registroObjeto(valor) {
+    return typeof valor === "object" && valor !== null && !Array.isArray(valor);
+}
+function textoNaoVazio(valor) {
+    return typeof valor === "string" && valor.length > 0;
+}
+function pertenceAoConjunto(valor, conjunto) {
+    return typeof valor === "string" && conjunto.has(valor);
+}
+function inteiroNaoNegativo(valor) {
+    return typeof valor === "number" && Number.isSafeInteger(valor) && valor >= 0;
+}
+const ORIGENS_SIMBOLO_DRIFT = new Set([
+    "ts", "js", "py", "dart", "lua", "cs", "java", "go", "rust", "cpp", "php", "sql",
+]);
+const ORIGENS_ROTA_DRIFT = new Set([
+    "nestjs", "fastapi", "flask", "nextjs", "nextjs-consumer", "react-vite-consumer",
+    "angular-consumer", "flutter-consumer", "firebase", "dotnet", "java", "go", "rust", "php",
+]);
+const ORIGENS_RECURSO_DRIFT = new Set([
+    "firebase", "postgres", "mysql", "sqlite", "mongodb", "redis", "arquivo",
+]);
+const TIPOS_RECURSO_DRIFT = new Set([
+    "colecao", "arquivo_local", "table", "view", "query", "transaction", "index", "constraint",
+    "relationship", "collection", "document", "keyspace", "stream", "lock", "retention", "replication",
+]);
+const CATEGORIAS_PERSISTENCIA_DRIFT = new Set([
+    "relacional", "documental", "chave_valor", "local_arquivo", "desconhecida",
+]);
+const TIPOS_DIAGNOSTICO_ORCAMENTO = new Set([
+    "contrato_monolitico", "codigo_monolitico", "codigo_governado_sem_cabecalho",
+]);
+function simboloResolvidoValido(valor) {
+    return registroObjeto(valor)
+        && pertenceAoConjunto(valor.origem, ORIGENS_SIMBOLO_DRIFT)
+        && textoNaoVazio(valor.caminho)
+        && textoNaoVazio(valor.arquivo)
+        && textoNaoVazio(valor.simbolo);
+}
+function rotaResolvidaValida(valor) {
+    return registroObjeto(valor)
+        && pertenceAoConjunto(valor.origem, ORIGENS_ROTA_DRIFT)
+        && textoNaoVazio(valor.metodo)
+        && textoNaoVazio(valor.caminho)
+        && textoNaoVazio(valor.arquivo)
+        && textoNaoVazio(valor.simbolo);
+}
+function recursoResolvidoValido(valor) {
+    return registroObjeto(valor)
+        && pertenceAoConjunto(valor.origem, ORIGENS_RECURSO_DRIFT)
+        && textoNaoVazio(valor.nome)
+        && textoNaoVazio(valor.arquivo)
+        && (valor.simbolo === undefined || textoNaoVazio(valor.simbolo))
+        && pertenceAoConjunto(valor.tipo, TIPOS_RECURSO_DRIFT);
+}
+function consumerSurfaceValida(valor) {
+    return registroObjeto(valor)
+        && textoNaoVazio(valor.rota)
+        && textoNaoVazio(valor.arquivo)
+        && textoNaoVazio(valor.tipoArquivo);
+}
+function colunaPersistenciaValida(valor) {
+    return registroObjeto(valor)
+        && pertenceAoConjunto(valor.origem, ORIGENS_RECURSO_DRIFT)
+        && pertenceAoConjunto(valor.categoriaPersistencia, CATEGORIAS_PERSISTENCIA_DRIFT)
+        && textoNaoVazio(valor.recurso)
+        && textoNaoVazio(valor.coluna)
+        && textoNaoVazio(valor.arquivo);
+}
+function repositorioPersistenciaValido(valor) {
+    return registroObjeto(valor)
+        && pertenceAoConjunto(valor.origem, ORIGENS_RECURSO_DRIFT)
+        && pertenceAoConjunto(valor.categoriaPersistencia, CATEGORIAS_PERSISTENCIA_DRIFT)
+        && textoNaoVazio(valor.recurso)
+        && textoNaoVazio(valor.arquivo);
+}
+function diagnosticoOrcamentoValido(valor) {
+    return registroObjeto(valor)
+        && pertenceAoConjunto(valor.tipo, TIPOS_DIAGNOSTICO_ORCAMENTO)
+        && textoNaoVazio(valor.arquivo)
+        && inteiroNaoNegativo(valor.linhas)
+        && (valor.severidade === "aviso" || valor.severidade === "erro")
+        && typeof valor.bloqueia === "boolean"
+        && textoNaoVazio(valor.mensagem)
+        && inteiroNaoNegativo(valor.limite_aviso_linhas)
+        && inteiroNaoNegativo(valor.limite_bloqueio_linhas);
+}
+function listaValida(valor, validar) {
+    return Array.isArray(valor) && valor.every(validar);
+}
+function indiceLinguagemValido(valor) {
+    return registroObjeto(valor)
+        && listaValida(valor.simbolos, simboloResolvidoValido)
+        && listaValida(valor.rotas, rotaResolvidaValida)
+        && listaValida(valor.recursos, recursoResolvidoValido)
+        && Array.isArray(valor.consumerSurfaces)
+        && valor.consumerSurfaces.every(consumerSurfaceValida);
+}
+function validarIndicesSerializaveis(valor) {
+    if (!registroObjeto(valor) || !registroObjeto(valor.detalhesPersistencia)) {
+        return false;
+    }
+    const detalhes = valor.detalhesPersistencia;
+    return listaValida(detalhes.colunas, colunaPersistenciaValida)
+        && listaValida(detalhes.repositorios, repositorioPersistenciaValido)
+        && Array.isArray(valor.arquivosOrcamentoAvaliados)
+        && valor.arquivosOrcamentoAvaliados.every(textoNaoVazio)
+        && listaValida(valor.diagnosticosOrcamento, diagnosticoOrcamentoValido)
+        && indiceLinguagemValido(valor.indexDart)
+        && indiceLinguagemValido(valor.indexTs)
+        && listaValida(valor.todasRotasIndexadas, rotaResolvidaValida)
+        && Array.isArray(valor.todosArquivosConhecidos)
+        && valor.todosArquivosConhecidos.every(textoNaoVazio)
+        && listaValida(valor.todosRecursos, recursoResolvidoValido)
+        && listaValida(valor.todosSimbolos, simboloResolvidoValido);
+}
+function indicesPermanecemNoCatalogo(valor, catalogo) {
+    const registros = [
+        ...valor.detalhesPersistencia.colunas,
+        ...valor.detalhesPersistencia.repositorios,
+        ...valor.indexDart.simbolos,
+        ...valor.indexDart.rotas,
+        ...valor.indexDart.recursos,
+        ...valor.indexDart.consumerSurfaces,
+        ...valor.indexTs.simbolos,
+        ...valor.indexTs.rotas,
+        ...valor.indexTs.recursos,
+        ...valor.indexTs.consumerSurfaces,
+        ...valor.todasRotasIndexadas,
+        ...valor.todosRecursos,
+        ...valor.todosSimbolos,
+    ];
+    return registros.every((item) => catalogo.contem(item.arquivo))
+        && valor.todosArquivosConhecidos.every((arquivo) => catalogo.contem(arquivo))
+        && valor.arquivosOrcamentoAvaliados.every((arquivo) => catalogo.contem(path.resolve(catalogo.baseDiretorio, arquivo)))
+        && valor.diagnosticosOrcamento.every((item) => catalogo.contem(path.resolve(catalogo.baseDiretorio, item.arquivo)));
+}
+function reconstruirIndices(serializaveis, planoEscopo, cache, catalogo, leitorArquivosPlanejados) {
+    const mapaImpl = new Map(serializaveis.todosSimbolos
+        .filter((item) => item.origem !== "sql")
+        .map((item) => [item.caminho, item]));
+    return {
+        ...serializaveis,
+        mapaImpl,
+        mapaRecursos: construirMapaRecursos(serializaveis.todosRecursos),
+        planoEscopo,
+        cache,
+        catalogo,
+        leitorArquivosPlanejados,
+    };
+}
+function indicesVazios() {
+    return {
+        arquivosOrcamentoAvaliados: [],
+        detalhesPersistencia: { colunas: [], repositorios: [] },
+        diagnosticosOrcamento: [],
+        indexDart: { simbolos: [], rotas: [], recursos: [], consumerSurfaces: [] },
+        indexTs: { simbolos: [], rotas: [], recursos: [], consumerSurfaces: [] },
+        todasRotasIndexadas: [],
+        todosArquivosConhecidos: [],
+        todosRecursos: [],
+        todosSimbolos: [],
+    };
+}
+function deduplicar(itens, chave) {
+    return [...new Map(itens.map((item) => [chave(item), item])).values()];
+}
+function filtrarAoCatalogo(itens, catalogo) {
+    return itens.filter((item) => catalogo.contem(item.arquivo));
+}
+function sanitizarIndices(indices, catalogo) {
+    const diagnosticosOrcamento = indices.diagnosticosOrcamento.filter((item) => catalogo.contem(path.resolve(catalogo.baseDiretorio, item.arquivo)));
+    return {
+        arquivosOrcamentoAvaliados: indices.arquivosOrcamentoAvaliados.filter((arquivo) => catalogo.contem(path.resolve(catalogo.baseDiretorio, arquivo))),
+        detalhesPersistencia: {
+            colunas: filtrarAoCatalogo(indices.detalhesPersistencia.colunas, catalogo),
+            repositorios: filtrarAoCatalogo(indices.detalhesPersistencia.repositorios, catalogo),
+        },
+        diagnosticosOrcamento,
+        indexDart: {
+            simbolos: filtrarAoCatalogo(indices.indexDart.simbolos, catalogo),
+            rotas: filtrarAoCatalogo(indices.indexDart.rotas, catalogo),
+            recursos: filtrarAoCatalogo(indices.indexDart.recursos, catalogo),
+            consumerSurfaces: filtrarAoCatalogo(indices.indexDart.consumerSurfaces, catalogo),
+        },
+        indexTs: {
+            simbolos: filtrarAoCatalogo(indices.indexTs.simbolos, catalogo),
+            rotas: filtrarAoCatalogo(indices.indexTs.rotas, catalogo),
+            recursos: filtrarAoCatalogo(indices.indexTs.recursos, catalogo),
+            consumerSurfaces: filtrarAoCatalogo(indices.indexTs.consumerSurfaces, catalogo),
+        },
+        todasRotasIndexadas: filtrarAoCatalogo(indices.todasRotasIndexadas, catalogo),
+        todosArquivosConhecidos: indices.todosArquivosConhecidos.filter((arquivo) => catalogo.contem(arquivo)),
+        todosRecursos: filtrarAoCatalogo(indices.todosRecursos, catalogo),
+        todosSimbolos: filtrarAoCatalogo(indices.todosSimbolos, catalogo),
+    };
+}
+async function calcularIndices(diretorios, catalogo, exigirCabecalhoCodigoGovernado) {
+    const [indexTs, indexPy, indexDart, indexDotnet, indexJava, indexGo, indexRust, indexLua, indexPhp, indexPersistencia, detalhesPersistencia, indexCpp, arquivosRastreaveis,] = await Promise.all([
+        indexarTypeScript(diretorios, catalogo),
+        indexarPython(diretorios, catalogo),
+        indexarDart(diretorios, catalogo),
+        indexarDotnet(diretorios, catalogo),
+        indexarJava(diretorios, catalogo),
+        indexarGo(diretorios, catalogo),
+        indexarRust(diretorios, catalogo),
+        indexarLua(diretorios, catalogo),
+        indexarPhp(diretorios, catalogo),
+        indexarPersistenciaDeclarativa(diretorios, catalogo),
+        indexarPersistenciaDetalhada(diretorios, catalogo),
+        indexarCpp(diretorios, catalogo),
+        indexarArquivosRastreaveis(diretorios, catalogo),
+    ]);
     const todosSimbolos = [
         ...indexTs.simbolos,
         ...indexPy.simbolos,
@@ -34,18 +264,6 @@ export async function prepararIndicesDrift(contexto, configuracaoEscopo) {
         ...indexPhp.simbolos,
         ...indexPersistencia.simbolos,
     ];
-    const mapaImpl = new Map([
-        ...indexTs.simbolos.map((item) => [item.caminho, item]),
-        ...indexPy.simbolos.map((item) => [item.caminho, item]),
-        ...indexDart.simbolos.map((item) => [item.caminho, item]),
-        ...indexDotnet.simbolos.map((item) => [item.caminho, item]),
-        ...indexJava.simbolos.map((item) => [item.caminho, item]),
-        ...indexGo.simbolos.map((item) => [item.caminho, item]),
-        ...indexRust.simbolos.map((item) => [item.caminho, item]),
-        ...indexLua.simbolos.map((item) => [item.caminho, item]),
-        ...indexCpp.simbolos.map((item) => [item.caminho, item]),
-        ...indexPhp.simbolos.map((item) => [item.caminho, item]),
-    ]);
     const todosRecursos = [
         ...indexTs.recursos,
         ...indexPy.recursos,
@@ -59,7 +277,6 @@ export async function prepararIndicesDrift(contexto, configuracaoEscopo) {
         ...indexPhp.recursos,
         ...indexPersistencia.recursos,
     ];
-    const mapaRecursos = construirMapaRecursos(todosRecursos);
     const todasRotasIndexadas = [
         ...indexTs.rotas,
         ...indexPy.rotas,
@@ -76,16 +293,423 @@ export async function prepararIndicesDrift(contexto, configuracaoEscopo) {
             ...todasRotasIndexadas.map((item) => item.arquivo),
             ...todosRecursos.map((item) => item.arquivo),
         ])].sort((a, b) => a.localeCompare(b, "pt-BR"));
-    return {
+    const diagnosticosOrcamento = await emitirDiagnosticosArquivosOrcamento({
+        arquivos: catalogo.arquivosCatalogados(),
+        baseProjeto: catalogo.baseDiretorio,
+        exigirCabecalhoCodigoGovernado,
+        leitorArquivos: catalogo,
+    });
+    return sanitizarIndices(paraJsonCache({
+        arquivosOrcamentoAvaliados: catalogo.arquivosCatalogados()
+            .map((arquivo) => pathRelativo(catalogo.baseDiretorio, arquivo)),
         detalhesPersistencia,
+        diagnosticosOrcamento,
         indexDart,
         indexTs,
-        mapaImpl,
-        mapaRecursos,
         todasRotasIndexadas,
         todosArquivosConhecidos,
         todosRecursos,
         todosSimbolos,
+    }), catalogo);
+}
+function mesclarIndices(resumos, todosArquivosCatalogados) {
+    const simbolos = deduplicar(resumos.flatMap((item) => item.todosSimbolos), (item) => item.caminho);
+    const rotas = deduplicar(resumos.flatMap((item) => item.todasRotasIndexadas), (item) => `${item.origem}:${item.metodo}:${item.caminho}:${item.arquivo}:${item.simbolo}`);
+    const recursos = deduplicar(resumos.flatMap((item) => item.todosRecursos), (item) => `${item.origem}:${item.tipo}:${item.nome}:${item.arquivo}:${item.simbolo ?? ""}`);
+    const simbolosTs = deduplicar(resumos.flatMap((item) => item.indexTs.simbolos), (item) => item.caminho);
+    const rotasTs = deduplicar(resumos.flatMap((item) => item.indexTs.rotas), (item) => `${item.origem}:${item.metodo}:${item.caminho}:${item.arquivo}:${item.simbolo}`);
+    const recursosTs = deduplicar(resumos.flatMap((item) => item.indexTs.recursos), (item) => `${item.origem}:${item.tipo}:${item.nome}:${item.arquivo}:${item.simbolo ?? ""}`);
+    const surfacesTs = deduplicar(resumos.flatMap((item) => item.indexTs.consumerSurfaces), (item) => `${item.rota}:${item.arquivo}:${item.tipoArquivo}`);
+    const simbolosDart = deduplicar(resumos.flatMap((item) => item.indexDart.simbolos), (item) => item.caminho);
+    const rotasDart = deduplicar(resumos.flatMap((item) => item.indexDart.rotas), (item) => `${item.origem}:${item.metodo}:${item.caminho}:${item.arquivo}:${item.simbolo}`);
+    const recursosDart = deduplicar(resumos.flatMap((item) => item.indexDart.recursos), (item) => `${item.origem}:${item.tipo}:${item.nome}:${item.arquivo}:${item.simbolo ?? ""}`);
+    const surfacesDart = deduplicar(resumos.flatMap((item) => item.indexDart.consumerSurfaces), (item) => `${item.rota}:${item.arquivo}:${item.tipoArquivo}`);
+    const colunas = deduplicar(resumos.flatMap((item) => item.detalhesPersistencia.colunas), (item) => `${item.origem}:${item.recurso}:${item.coluna}:${item.arquivo}`);
+    const repositorios = deduplicar(resumos.flatMap((item) => item.detalhesPersistencia.repositorios), (item) => `${item.origem}:${item.recurso}:${item.arquivo}`);
+    const diagnosticosOrcamento = deduplicar(resumos.flatMap((item) => item.diagnosticosOrcamento), (item) => `${item.tipo}:${item.arquivo}:${item.severidade}:${item.mensagem}`);
+    return paraJsonCache({
+        arquivosOrcamentoAvaliados: [...new Set(resumos.flatMap((item) => item.arquivosOrcamentoAvaliados))].sort((a, b) => a.localeCompare(b, "pt-BR")),
+        detalhesPersistencia: { colunas, repositorios },
+        diagnosticosOrcamento,
+        indexDart: {
+            simbolos: simbolosDart,
+            rotas: rotasDart,
+            recursos: recursosDart,
+            consumerSurfaces: surfacesDart,
+        },
+        indexTs: {
+            simbolos: simbolosTs,
+            rotas: rotasTs,
+            recursos: recursosTs,
+            consumerSurfaces: surfacesTs,
+        },
+        todasRotasIndexadas: rotas,
+        todosArquivosConhecidos: [...new Set(todosArquivosCatalogados)].sort((a, b) => a.localeCompare(b, "pt-BR")),
+        todosRecursos: recursos,
+        todosSimbolos: simbolos,
+    });
+}
+class CatalogoFiltradoDrift {
+    origem;
+    baseDiretorio;
+    raizes;
+    permitidos;
+    constructor(origem, arquivos) {
+        this.origem = origem;
+        this.baseDiretorio = origem.baseDiretorio;
+        this.raizes = origem.raizes;
+        this.permitidos = new Set(arquivos.map(chaveCaminho));
+    }
+    listar(extensoesOuFiltro = [], raizes) {
+        const arquivos = Array.isArray(extensoesOuFiltro)
+            ? this.origem.listar(extensoesOuFiltro, raizes)
+            : this.origem.listar(extensoesOuFiltro);
+        return arquivos.filter((arquivo) => this.permitidos.has(chaveCaminho(arquivo)));
+    }
+    listarEntradas(filtro = {}) {
+        return this.origem.listarEntradas(filtro)
+            .filter((arquivo) => this.permitidos.has(chaveCaminho(arquivo.caminho)));
+    }
+    listarPorExtensoes(extensoes, raiz) {
+        return this.listarEntradas({ extensoes, raiz }).map((arquivo) => arquivo.caminho);
+    }
+    listarPorRaiz(raiz, extensoes) {
+        return this.listarEntradas({ raiz, extensoes }).map((arquivo) => arquivo.caminho);
+    }
+    arquivosCatalogados() {
+        return this.listar();
+    }
+    async incluir(arquivos) {
+        const fora = arquivos.find((arquivo) => !this.permitidos.has(chaveCaminho(arquivo)));
+        if (fora) {
+            throw new Error(`Arquivo fora da unidade incremental do drift: ${fora}`);
+        }
+    }
+    contem(caminho) {
+        return this.permitidos.has(chaveCaminho(caminho)) && this.origem.contem(caminho);
+    }
+    ler(caminho) {
+        return this.contem(caminho)
+            ? this.origem.ler(caminho)
+            : Promise.reject(new Error(`Arquivo fora da unidade incremental do drift: ${caminho}`));
+    }
+    async lerTexto(caminho) {
+        return (await this.ler(caminho)).texto;
+    }
+    async digest(caminho) {
+        return (await this.ler(caminho)).digest;
+    }
+    fingerprint(caminhos) {
+        const selecionados = (caminhos ?? this.arquivosCatalogados())
+            .filter((arquivo) => this.contem(arquivo));
+        return this.origem.fingerprint(selecionados);
+    }
+    obterFingerprint(caminhos) {
+        return this.fingerprint(caminhos);
+    }
+    emitir(tipo, arquivo) {
+        if (tipo === "ast.create") {
+            this.origem.emitir(tipo, arquivo);
+        }
+    }
+    metricas() {
+        return this.origem.metricas();
+    }
+    snapshot() {
+        const snapshot = this.origem.snapshot();
+        return {
+            ...snapshot,
+            arquivos: snapshot.arquivos.filter((arquivo) => this.permitidos.has(chaveCaminho(path.resolve(this.baseDiretorio, arquivo.caminho)))),
+        };
+    }
+}
+function extrairPerfilAgrupamentoTypeScript(arquivo, codigo) {
+    const relacao = arquivo.replace(/\\/g, "/");
+    const motivos = new Set();
+    if (/(?:^|\n)\s*export\s+(?:type\s+)?(?:\*|\{[\s\S]{0,4000}?\})\s+from\s*["'`][^"'`]+["'`]/mu.test(codigo)) {
+        motivos.add("reexportacao");
+    }
+    if (/(?:^|\/)(?:app\.)?(?:routes?|router|routing)(?:\.[^/]*)?\.(?:ts|tsx|js|jsx|mjs|cjs)$/iu.test(relacao)
+        || /\b(?:createBrowserRouter|useRoutes|loadChildren|loadComponent)\s*[:(]/u.test(codigo)
+        || /\bRouterModule\.(?:forRoot|forChild)\s*\(/u.test(codigo)
+        || /<Routes?\b/u.test(codigo)) {
+        motivos.add("roteamento_consumer");
+    }
+    if (/(?:^|\/)(?:src\/)?(?:app\/)?app\.component\.(?:ts|js)$/iu.test(relacao)) {
+        motivos.add("angular_standalone_raiz");
+    }
+    return {
+        acoplarDependencias: motivos.size > 0,
+        motivos: [...motivos].sort((a, b) => a.localeCompare(b, "pt-BR")),
+    };
+}
+function perfilAgrupamentoTypeScriptValido(valor) {
+    return registroObjeto(valor)
+        && typeof valor.acoplarDependencias === "boolean"
+        && Array.isArray(valor.motivos)
+        && valor.motivos.every(textoNaoVazio);
+}
+function construirGruposIncrementais(arquivos, dependencias, perfisTypeScript) {
+    const porChave = new Map(arquivos.map((arquivo) => [chaveCaminho(arquivo), arquivo]));
+    const analisaveis = arquivos.filter((arquivo) => EXTENSOES_ANALISE_DRIFT.has(path.extname(arquivo).toLowerCase()));
+    const typescript = analisaveis.filter((arquivo) => EXTENSOES_TYPESCRIPT_DRIFT.has(path.extname(arquivo).toLowerCase()));
+    const dependenciasPorChave = new Map();
+    for (const arquivo of typescript) {
+        const destinos = (dependencias[arquivo] ?? [])
+            .map((dependencia) => porChave.get(chaveCaminho(dependencia)))
+            .filter((dependencia) => Boolean(dependencia))
+            .filter((dependencia) => EXTENSOES_DEPENDENCIA_TYPESCRIPT_DRIFT.has(path.extname(dependencia).toLowerCase()));
+        dependenciasPorChave.set(chaveCaminho(arquivo), destinos);
+    }
+    const pai = new Map();
+    const encontrar = (chave) => {
+        const atual = pai.get(chave) ?? chave;
+        if (atual === chave) {
+            pai.set(chave, chave);
+            return chave;
+        }
+        const raiz = encontrar(atual);
+        pai.set(chave, raiz);
+        return raiz;
+    };
+    const unir = (a, b) => {
+        const raizA = encontrar(a);
+        const raizB = encontrar(b);
+        if (raizA !== raizB) {
+            pai.set(raizB, raizA.localeCompare(raizB, "en") <= 0 ? raizA : raizB);
+            pai.set(raizA, raizA.localeCompare(raizB, "en") <= 0 ? raizA : raizB);
+        }
     };
+    for (const semente of typescript) {
+        if (!perfisTypeScript.get(chaveCaminho(semente))?.acoplarDependencias) {
+            continue;
+        }
+        const chaveSemente = chaveCaminho(semente);
+        const fila = [chaveSemente];
+        const fechamento = new Set();
+        while (fila.length > 0) {
+            const atual = fila.shift();
+            if (fechamento.has(atual)) {
+                continue;
+            }
+            fechamento.add(atual);
+            for (const dependencia of dependenciasPorChave.get(atual) ?? []) {
+                const chaveDependencia = chaveCaminho(dependencia);
+                if (!fechamento.has(chaveDependencia)) {
+                    fila.push(chaveDependencia);
+                }
+            }
+        }
+        for (const membro of fechamento) {
+            unir(chaveSemente, membro);
+        }
+    }
+    const gruposPorRaiz = new Map();
+    const usados = new Set();
+    for (const arquivo of arquivos) {
+        const chave = chaveCaminho(arquivo);
+        if (!pai.has(chave)) {
+            continue;
+        }
+        usados.add(chave);
+        const raiz = encontrar(chave);
+        const grupo = gruposPorRaiz.get(raiz) ?? [];
+        grupo.push(arquivo);
+        gruposPorRaiz.set(raiz, grupo);
+    }
+    const grupos = [...gruposPorRaiz.values()]
+        .map((grupo) => grupo.sort((a, b) => a.localeCompare(b, "pt-BR")));
+    for (const arquivo of analisaveis.sort((a, b) => a.localeCompare(b, "pt-BR"))) {
+        const chave = chaveCaminho(arquivo);
+        if (!usados.has(chave)) {
+            usados.add(chave);
+            grupos.push([arquivo]);
+        }
+    }
+    return grupos
+        .filter((grupo) => grupo.length > 0)
+        .sort((a, b) => a[0].localeCompare(b[0], "pt-BR"));
+}
+async function mapearComLimite(itens, limite, executar) {
+    const resultados = new Array(itens.length);
+    let proximo = 0;
+    const trabalhador = async () => {
+        for (;;) {
+            const indice = proximo;
+            proximo += 1;
+            if (indice >= itens.length) {
+                return;
+            }
+            resultados[indice] = await executar(itens[indice]);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(limite, itens.length) }, trabalhador));
+    return resultados;
+}
+function pathRelativo(baseProjeto, alvo) {
+    const relativo = path.relative(baseProjeto, alvo).replace(/\\/g, "/");
+    return relativo || ".";
+}
+function criarIdentidadeCache(contexto, configuracaoEscopo, plano, exigirCabecalhoCodigoGovernado) {
+    const ordenarCaminhos = (caminhos) => [...new Set(caminhos.map((caminho) => path.normalize(path.resolve(caminho))))].sort((a, b) => a.localeCompare(b, "pt-BR"));
+    const representarDiretorios = (diretorios) => {
+        const fisicos = ordenarCaminhos(diretorios);
+        return {
+            fisicos,
+            semanticos: fisicos.map((diretorio) => pathRelativo(contexto.baseProjeto, diretorio)),
+        };
+    };
+    return paraJsonCache({
+        cliVersion: pacoteCli.version,
+        typescriptVersion: ts.version,
+        fileIndexSchema: FILE_INDEX_SCHEMA,
+        extractorBuild: "drift-file-index-v4-2026-07-21",
+        escopo: {
+            solicitado: configuracaoEscopo.escopo,
+            estrategia: plano.estrategia,
+            cobertura: plano.cobertura,
+            termos: [...configuracaoEscopo.termosEscopo].sort((a, b) => a.localeCompare(b, "pt-BR")),
+            modulos: [...plano.modulos].sort((a, b) => a.localeCompare(b, "pt-BR")),
+            arquivosFisicos: ordenarCaminhos(plano.arquivos),
+            arquivosSemanticos: plano.arquivos
+                .map((arquivo) => pathRelativo(contexto.baseProjeto, arquivo))
+                .sort((a, b) => a.localeCompare(b, "pt-BR")),
+        },
+        diretoriosPlano: representarDiretorios(plano.diretorios),
+        diretoriosContexto: representarDiretorios(contexto.diretoriosCodigo),
+        exigirCabecalhoCodigoGovernado,
+        ignorarWorktrees: configuracaoEscopo.ignorarWorktrees,
+        ignorarConsumidoresLaterais: configuracaoEscopo.ignorarConsumidoresLaterais,
+        fontesLegado: contexto.fontesLegado,
+        configuracao: contexto.configCarregada?.config ?? null,
+    });
+}
+export async function prepararIndicesDrift(contexto, configuracaoEscopo, opcoes = {}) {
+    const inicioTotal = performance.now();
+    let planoEscopo = await planejarEscopoDrift(contexto, configuracaoEscopo);
+    const fimPlanejamento = performance.now();
+    const politicaCache = opcoes.politicaCache ?? "auto";
+    if (planoEscopo.bloqueios.length > 0) {
+        return reconstruirIndices(indicesVazios(), planoEscopo, {
+            politica: politicaCache,
+            origem: "nao_aplicavel",
+            fasesMs: {
+                planejamento: Number((fimPlanejamento - inicioTotal).toFixed(3)),
+                catalogacao: 0,
+                dependencias: 0,
+                assinaturas: 0,
+                indexacao: 0,
+                total: Number((performance.now() - inicioTotal).toFixed(3)),
+            },
+        }, {
+            diretoriosVisitados: 0,
+            arquivosCatalogados: 0,
+            leiturasConteudo: 0,
+            bytesLidos: 0,
+            acertosMemoriaConteudo: 0,
+            origem: "plano_explicito",
+            diretoriosValidadosCache: 0,
+        });
+    }
+    const exigirCabecalhoCodigoGovernado = await workspaceExigeCabecalhoCodigoGovernado(contexto.baseProjeto, contexto.configCarregada?.config.modoEstrito === true);
+    const identidadeCache = criarIdentidadeCache(contexto, configuracaoEscopo, planoEscopo, exigirCabecalhoCodigoGovernado);
+    const cache = new CacheIncrementalDrift({
+        baseProjeto: contexto.baseProjeto,
+        politica: politicaCache,
+        identidade: identidadeCache,
+        observador: opcoes.observador,
+    });
+    const catalogo = await criarCatalogoPersistenteDrift({
+        baseDiretorio: contexto.baseProjeto,
+        arquivos: planoEscopo.estrategia === "arquivos_vinculados" ? planoEscopo.arquivos : [],
+        raizes: planoEscopo.estrategia === "projeto" ? planoEscopo.diretorios : [],
+        extensoes: EXTENSOES_ARQUIVOS_RASTREAVEIS_DRIFT,
+        diretoriosIgnorados: resolverDiretoriosIgnoradosAtivos({
+            escopo: configuracaoEscopo.escopo,
+            ignorarWorktrees: configuracaoEscopo.ignorarWorktrees,
+            ignorarConsumidoresLaterais: configuracaoEscopo.ignorarConsumidoresLaterais,
+        }),
+        observador: opcoes.observador,
+    }, { politica: politicaCache, identidade: identidadeCache });
+    const fimCatalogacao = performance.now();
+    try {
+        planoEscopo = await expandirDependenciasPlanoDrift(contexto, planoEscopo, catalogo, cache);
+        if (planoEscopo.estrategia === "projeto") {
+            const arquivosTypeScript = catalogo.arquivosCatalogados()
+                .filter((arquivo) => EXTENSOES_TYPESCRIPT_DRIFT.has(path.extname(arquivo).toLowerCase()));
+            planoEscopo.dependencias = await mapearDependenciasCatalogadasDrift(contexto, catalogo, cache, arquivosTypeScript);
+        }
+        const fimDependencias = performance.now();
+        const membrosUnicos = catalogo.arquivosCatalogados()
+            .filter((arquivo) => {
+            const extensao = path.extname(arquivo).toLowerCase();
+            return EXTENSOES_ANALISE_DRIFT.has(extensao)
+                || EXTENSOES_DEPENDENCIA_TYPESCRIPT_DRIFT.has(extensao);
+        });
+        const estados = await mapearComLimite(membrosUnicos, 8, async (arquivo) => cache.resolverArquivo({
+            arquivo,
+            analise: "dependencias-v4",
+            ler: () => catalogo.ler(arquivo),
+            extrair: (conteudo) => extrairReferenciasLocaisDrift(conteudo.texto),
+            validar: (valor) => Array.isArray(valor) && valor.every((item) => typeof item === "string"),
+        }));
+        const arquivosTypeScript = membrosUnicos
+            .filter((arquivo) => EXTENSOES_TYPESCRIPT_DRIFT.has(path.extname(arquivo).toLowerCase()));
+        const perfis = await mapearComLimite(arquivosTypeScript, 8, async (arquivo) => cache.resolverArquivo({
+            arquivo,
+            analise: "agrupamento-semantico-ts-v1",
+            ler: () => catalogo.ler(arquivo),
+            extrair: (conteudo) => extrairPerfilAgrupamentoTypeScript(arquivo, conteudo.texto),
+            validar: perfilAgrupamentoTypeScriptValido,
+        }));
+        const perfisPorArquivo = new Map(perfis.map((perfil) => [
+            chaveCaminho(path.resolve(contexto.baseProjeto, perfil.caminho)),
+            perfil.valor,
+        ]));
+        const grupos = construirGruposIncrementais(catalogo.arquivosCatalogados(), planoEscopo.dependencias, perfisPorArquivo);
+        const estadoPorArquivo = new Map(estados.map((estado) => [chaveRelativa(estado.caminho), estado]));
+        const fimAssinaturas = performance.now();
+        const resultadosGrupos = await mapearComLimite(grupos, 8, async (grupo) => {
+            const membros = grupo.map((arquivo) => {
+                const estado = estadoPorArquivo.get(chaveRelativa(pathRelativo(contexto.baseProjeto, arquivo)));
+                if (!estado) {
+                    throw new Error(`estado_cache_arquivo_ausente:${arquivo}`);
+                }
+                return { caminho: arquivo, contentHash: estado.contentHash };
+            });
+            const catalogoGrupo = new CatalogoFiltradoDrift(catalogo, grupo);
+            return cache.resolverGrupo({
+                membros,
+                calcular: () => calcularIndices(planoEscopo.diretorios, catalogoGrupo, exigirCabecalhoCodigoGovernado),
+                validar: (valor) => (validarIndicesSerializaveis(valor)
+                    && indicesPermanecemNoCatalogo(valor, catalogoGrupo)),
+            });
+        });
+        await cache.finalizar();
+        const fimIndexacao = performance.now();
+        const serializaveis = mesclarIndices(resultadosGrupos.map((resultado) => resultado.valor), catalogo.arquivosCatalogados());
+        const metricasIncrementais = cache.metricas();
+        const origem = resultadosGrupos.length > 0
+            && resultadosGrupos.every((resultado) => resultado.origem === "cache")
+            ? "cache"
+            : "calculado";
+        return reconstruirIndices(serializaveis, planoEscopo, {
+            politica: politicaCache,
+            origem,
+            chave: cache.identidadeDigest,
+            incremental: metricasIncrementais,
+            fasesMs: {
+                planejamento: Number((fimPlanejamento - inicioTotal).toFixed(3)),
+                catalogacao: Number((fimCatalogacao - fimPlanejamento).toFixed(3)),
+                dependencias: Number((fimDependencias - fimCatalogacao).toFixed(3)),
+                assinaturas: Number((fimAssinaturas - fimDependencias).toFixed(3)),
+                indexacao: Number((fimIndexacao - fimAssinaturas).toFixed(3)),
+                total: Number((fimIndexacao - inicioTotal).toFixed(3)),
+            },
+        }, catalogo.metricas(), catalogo);
+    }
+    finally {
+        await cache.finalizar();
+    }
 }
 //# sourceMappingURL=drift.part13.js.map