@semacode/cli 2.3.0 → 2.3.1

package/dist/driftCatalogoPersistente.js

@@ -0,0 +1,77 @@
+// SEMA-GOVERNED: sema.produto.governanca_ia.drift
+// Descricao: reutiliza um snapshot validado do catalogo global sem transformar escopo estreito em varredura ampla.
+import path from "node:path";
+import { criarCacheDrift, digestJsonCanonicoCacheDrift, } from "./driftCache.js";
+import { criarCatalogoDrift, } from "./driftCatalogo.js";
+export const SCHEMA_CACHE_CATALOGO_DRIFT = "sema.drift-catalog-cache/v1";
+function chaveRelativa(base, alvo) {
+    const relativo = path.relative(base, path.resolve(base, alvo)).replace(/\\/g, "/");
+    return relativo || ".";
+}
+function identidadePlanoCatalogo(opcoes) {
+    const base = path.resolve(opcoes.baseDiretorio ?? process.cwd());
+    const ignorados = [...(opcoes.diretoriosIgnorados ?? [])]
+        .map((item) => item.trim().toLowerCase())
+        .filter(Boolean)
+        .sort((a, b) => a.localeCompare(b, "en"));
+    return {
+        schema: SCHEMA_CACHE_CATALOGO_DRIFT,
+        arquivos: [...(opcoes.arquivos ?? [])]
+            .map((arquivo) => chaveRelativa(base, arquivo))
+            .sort((a, b) => a.localeCompare(b, "en")),
+        raizes: [...(opcoes.raizes ?? [])]
+            .map((raiz) => chaveRelativa(base, raiz))
+            .sort((a, b) => a.localeCompare(b, "en")),
+        extensoes: opcoes.extensoes
+            ? [...opcoes.extensoes].map((item) => item.toLowerCase()).sort((a, b) => a.localeCompare(b, "en"))
+            : null,
+        diretoriosIgnorados: ignorados,
+    };
+}
+export async function criarCatalogoPersistenteDrift(opcoes, opcoesCache) {
+    const baseProjeto = path.resolve(opcoes.baseDiretorio ?? process.cwd());
+    if (opcoesCache.politica === "off" || (opcoes.raizes?.length ?? 0) === 0) {
+        return criarCatalogoDrift(opcoes);
+    }
+    const plano = identidadePlanoCatalogo(opcoes);
+    const entrada = {
+        fingerprintConteudo: digestJsonCanonicoCacheDrift(plano),
+        identidade: {
+            schema: SCHEMA_CACHE_CATALOGO_DRIFT,
+            executor: opcoesCache.identidade,
+            plano,
+        },
+    };
+    let catalogoCalculado;
+    const cache = criarCacheDrift({
+        baseProjeto,
+        politica: opcoesCache.politica,
+        observador: opcoes.observador,
+    });
+    const resultado = await cache.obterOuCalcular(entrada, async () => {
+        catalogoCalculado = await criarCatalogoDrift(opcoes);
+        return catalogoCalculado.snapshot();
+    });
+    if (catalogoCalculado) {
+        return catalogoCalculado;
+    }
+    const restauradoOuRecalculado = await criarCatalogoDrift({
+        ...opcoes,
+        snapshot: resultado.valor,
+    });
+    if (restauradoOuRecalculado.metricas().origem === "snapshot") {
+        return restauradoOuRecalculado;
+    }
+    // O envelope estava integro, mas o snapshot ficou obsoleto ou falhou na
+    // validacao runtime. A caminhada ja executada acima e reaproveitada; apenas
+    // substituimos atomicamente a entrada persistente.
+    const refresh = criarCacheDrift({
+        baseProjeto,
+        politica: "refresh",
+        observador: opcoes.observador,
+    });
+    const snapshotAtual = restauradoOuRecalculado.snapshot();
+    await refresh.obterOuCalcular(entrada, async () => snapshotAtual);
+    return restauradoOuRecalculado;
+}
+//# sourceMappingURL=driftCatalogoPersistente.js.map

package/dist/driftEscopo.d.ts

@@ -0,0 +1,23 @@
+import type { ContextoProjetoCarregado } from "./projeto.js";
+import type { ConfiguracaoEscopoDriftAplicada, EscopoDriftReal } from "./drift.part01.js";
+import type { CatalogoDrift } from "./driftCatalogo.js";
+import type { CacheIncrementalDrift } from "./driftCacheIncremental.js";
+export { extrairReferenciasLocaisDrift } from "./driftEscopoReferencias.js";
+export type EstrategiaEscopoDrift = "arquivos_vinculados" | "projeto";
+export type CoberturaEscopoDrift = "completa" | "parcial";
+export interface PlanoEscopoDrift {
+    escopo: EscopoDriftReal;
+    estrategia: EstrategiaEscopoDrift;
+    arquivos: string[];
+    arquivosDeclarados: string[];
+    arquivosInferidos: string[];
+    arquivosAusentes: string[];
+    diretorios: string[];
+    modulos: string[];
+    cobertura: CoberturaEscopoDrift;
+    bloqueios: string[];
+    dependencias: Record<string, string[]>;
+}
+export declare function planejarEscopoDrift(contexto: ContextoProjetoCarregado, configuracao: ConfiguracaoEscopoDriftAplicada): Promise<PlanoEscopoDrift>;
+export declare function expandirDependenciasPlanoDrift(contexto: ContextoProjetoCarregado, plano: PlanoEscopoDrift, catalogo: CatalogoDrift, cache?: CacheIncrementalDrift): Promise<PlanoEscopoDrift>;
+export declare function mapearDependenciasCatalogadasDrift(contexto: ContextoProjetoCarregado, catalogo: CatalogoDrift, cache: CacheIncrementalDrift, arquivos?: readonly string[]): Promise<Record<string, string[]>>;

package/dist/driftEscopo.js

@@ -0,0 +1,563 @@
+// SEMA-GOVERNED: sema.produto.governanca_ia.drift
+// Descricao: planeja o conjunto fisico minimo que pode ser indexado antes de qualquer caminhada de drift.
+import { lstat, realpath } from "node:fs/promises";
+import path from "node:path";
+import { resolverDiretoriosCodigoEscopoReal } from "./drift.part02.js";
+import { candidatosReferenciaLocalDrift, extrairReferenciasLocaisDrift, raizesCodigoLogicasDrift, } from "./driftEscopoReferencias.js";
+export { extrairReferenciasLocaisDrift } from "./driftEscopoReferencias.js";
+const CONCORRENCIA_SONDAGENS_DRIFT = 16;
+const CONCORRENCIA_MAPEAMENTO_DEPENDENCIAS_DRIFT = 8;
+const EXTENSAO_POR_ORIGEM = {
+    // O indexador TypeScript tambem cobre JavaScript legado. Essa compatibilidade
+    // e necessaria para contratos antigos que usam `ts:` para simbolos browser-side.
+    ts: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
+    // O resolvedor semantico trata JS/TS como a mesma familia. O planejamento
+    // precisa sondar a mesma familia para nao descartar uma implementacao `js:`
+    // escrita fisicamente em TypeScript antes de o resolvedor poder avalia-la.
+    js: [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx"],
+    py: [".py"],
+    dart: [".dart"],
+    lua: [".lua"],
+    cs: [".cs"],
+    java: [".java"],
+    go: [".go"],
+    rust: [".rs"],
+    cpp: [".cpp", ".cc", ".cxx", ".hpp", ".h"],
+    php: [".php"],
+};
+function chaveCaminho(caminho) {
+    const absoluto = path.normalize(path.resolve(caminho));
+    return process.platform === "win32" ? absoluto.toLowerCase() : absoluto;
+}
+function caminhoEstaDentro(raiz, alvo) {
+    const relativo = path.relative(path.resolve(raiz), path.resolve(alvo));
+    return relativo === "" || (relativo !== ".."
+        && !relativo.startsWith(`..${path.sep}`)
+        && !path.isAbsolute(relativo));
+}
+async function mapearComLimite(itens, limite, executar) {
+    if (itens.length === 0) {
+        return [];
+    }
+    const resultados = new Array(itens.length);
+    let proximoIndice = 0;
+    const trabalhador = async () => {
+        for (;;) {
+            const indice = proximoIndice;
+            proximoIndice += 1;
+            if (indice >= itens.length) {
+                return;
+            }
+            resultados[indice] = await executar(itens[indice]);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(Math.max(1, limite), itens.length) }, () => trabalhador()));
+    return resultados;
+}
+async function arquivoRegularContido(caminho, raizReal) {
+    try {
+        const informacao = await lstat(caminho);
+        if (!informacao.isFile() || informacao.isSymbolicLink()) {
+            return false;
+        }
+        const caminhoReal = await realpath(caminho);
+        return caminhoEstaDentro(raizReal, caminhoReal);
+    }
+    catch {
+        return false;
+    }
+}
+async function sondarArquivosRegularesContidos(caminhos, raizReal) {
+    const unicos = [...new Map(caminhos.map((caminho) => [chaveCaminho(caminho), caminho])).entries()];
+    const resultados = await mapearComLimite(unicos, CONCORRENCIA_SONDAGENS_DRIFT, async ([chave, caminho]) => [chave, await arquivoRegularContido(caminho, raizReal)]);
+    return new Map(resultados);
+}
+function vinculosModulo(ir) {
+    return [
+        ...ir.vinculos,
+        ...ir.tasks.flatMap((task) => task.vinculos),
+        ...ir.flows.flatMap((flow) => flow.vinculos),
+        ...ir.routes.flatMap((route) => route.vinculos),
+        ...ir.superficies.flatMap((superficie) => superficie.vinculos),
+    ];
+}
+function implementacoesModulo(ir) {
+    return [
+        ...ir.tasks.flatMap((task) => task.implementacoesExternas),
+        ...ir.superficies.flatMap((superficie) => superficie.implementacoesExternas),
+    ];
+}
+function resolverArquivoWorkspace(baseProjeto, valor) {
+    const absoluto = path.isAbsolute(valor)
+        ? path.resolve(valor)
+        : path.resolve(baseProjeto, valor);
+    return caminhoEstaDentro(baseProjeto, absoluto) ? absoluto : undefined;
+}
+function variantesSegmentoDiretorio(segmento) {
+    const camel = segmento.replace(/_([a-z0-9])/gi, (_ocorrencia, caractere) => caractere.toUpperCase());
+    return [...new Set([
+            segmento,
+            segmento.includes("_") ? segmento.replace(/_/g, "-") : undefined,
+            /(?:^|_)id$/i.test(segmento) ? `[${segmento}]` : undefined,
+            /(?:^|_)id$/i.test(segmento) && camel !== segmento ? `[${camel}]` : undefined,
+        ].filter((item) => Boolean(item)))];
+}
+function adicionarCandidatoPreservandoForma(candidatos, baseProjeto, caminho) {
+    const absoluto = path.resolve(caminho);
+    if (!caminhoEstaDentro(baseProjeto, absoluto)) {
+        return;
+    }
+    const chave = chaveCaminho(absoluto);
+    if (!candidatos.has(chave)) {
+        candidatos.set(chave, absoluto);
+    }
+}
+function variantesNomeArquivo(segmento) {
+    const pascal = segmento
+        .split(/[_-]+/)
+        .filter(Boolean)
+        .map((parte) => `${parte[0]?.toUpperCase() ?? ""}${parte.slice(1)}`)
+        .join("");
+    return [...new Set([
+            segmento,
+            segmento.includes("_") ? segmento.replace(/_/g, "-") : undefined,
+            segmento.includes("_") ? segmento.replace(/_/g, ".") : undefined,
+            pascal && pascal !== segmento ? pascal : undefined,
+        ].filter((item) => Boolean(item)))];
+}
+function variantesCaminhoSegmentos(segmentos) {
+    let variantes = [[]];
+    for (const segmento of segmentos) {
+        const opcoes = variantesSegmentoDiretorio(segmento);
+        variantes = variantes.flatMap((prefixo) => opcoes.map((opcao) => [...prefixo, opcao]));
+    }
+    return variantes.slice(0, 16);
+}
+function candidatosArquivoImpl(contexto, impl) {
+    const candidatos = new Map();
+    const adicionar = (caminho) => {
+        adicionarCandidatoPreservandoForma(candidatos, contexto.baseProjeto, caminho);
+    };
+    if (impl.origemArquivo) {
+        const declarado = resolverArquivoWorkspace(contexto.baseProjeto, impl.origemArquivo);
+        if (declarado) {
+            adicionar(declarado);
+        }
+    }
+    const partes = impl.caminho.split(".").map((parte) => parte.trim()).filter(Boolean);
+    if (partes.length < 2) {
+        return [...candidatos.values()];
+    }
+    const bases = [contexto.baseProjeto, ...contexto.diretoriosCodigo];
+    const extensoes = EXTENSAO_POR_ORIGEM[impl.origem] ?? [];
+    for (const removerCauda of [1, 2]) {
+        const segmentosOriginais = partes.slice(0, Math.max(1, partes.length - removerCauda));
+        for (const base of bases) {
+            const nomeBase = path.basename(base).toLowerCase();
+            const segmentos = segmentosOriginais[0]?.toLowerCase() === nomeBase
+                ? segmentosOriginais.slice(1)
+                : segmentosOriginais;
+            if (segmentos.length === 0) {
+                continue;
+            }
+            for (const diretorios of variantesCaminhoSegmentos(segmentos.slice(0, -1))) {
+                for (const nomeArquivo of variantesNomeArquivo(segmentos.at(-1))) {
+                    for (const extensao of extensoes) {
+                        adicionar(path.join(base, ...diretorios, `${nomeArquivo}${extensao}`));
+                    }
+                }
+            }
+            for (const caminhoDiretorio of variantesCaminhoSegmentos(segmentos)) {
+                for (const extensao of extensoes) {
+                    adicionar(path.join(base, ...caminhoDiretorio, `index${extensao}`));
+                }
+            }
+        }
+    }
+    return [...candidatos.values()];
+}
+function candidatosConsumerDeterministicos(contexto, irs, termosEscopo) {
+    const segmentos = new Set();
+    for (const termo of termosEscopo) {
+        segmentos.add(termo);
+        segmentos.add(termo.replace(/_/g, "-"));
+    }
+    for (const ir of irs) {
+        for (const rota of ir.routes) {
+            for (const segmento of (rota.caminho ?? "").split("/").filter((item) => item && !item.startsWith(":"))) {
+                segmentos.add(segmento);
+            }
+        }
+    }
+    const candidatos = new Map();
+    const extensoes = [".ts", ".tsx", ".js", ".jsx"];
+    for (const raiz of contexto.diretoriosCodigo) {
+        for (const segmento of segmentos) {
+            for (const extensao of extensoes) {
+                for (const relativo of [
+                    ["src", "app", segmento, `page${extensao}`],
+                    ["app", segmento, `page${extensao}`],
+                    ["src", "pages", `${segmento}${extensao}`],
+                    ["pages", `${segmento}${extensao}`],
+                ]) {
+                    const absoluto = path.resolve(raiz, ...relativo);
+                    adicionarCandidatoPreservandoForma(candidatos, contexto.baseProjeto, absoluto);
+                }
+            }
+        }
+    }
+    return [...candidatos.values()];
+}
+function candidatosRotasDeterministicos(contexto, irs) {
+    const candidatos = new Map();
+    const extensoes = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py"];
+    const segmentos = new Set();
+    for (const ir of irs) {
+        for (const rota of ir.routes) {
+            for (const segmento of (rota.caminho ?? "").split("/").filter((item) => item && !item.startsWith(":") && !item.startsWith("{"))) {
+                segmentos.add(segmento);
+            }
+        }
+    }
+    for (const raiz of contexto.diretoriosCodigo) {
+        for (const segmento of segmentos) {
+            const nomes = variantesNomeArquivo(segmento);
+            for (const nome of nomes) {
+                for (const extensao of extensoes) {
+                    for (const relativo of [
+                        [segmento, `${nome}.controller${extensao}`],
+                        [`${nome}.controller${extensao}`],
+                        ["controllers", `${nome}.controller${extensao}`],
+                        ["routes", `${nome}${extensao}`],
+                    ]) {
+                        adicionarCandidatoPreservandoForma(candidatos, contexto.baseProjeto, path.resolve(raiz, ...relativo));
+                    }
+                }
+            }
+        }
+    }
+    return [...candidatos.values()];
+}
+function candidatosConvencionaisEscopo(contexto, irs) {
+    const candidatos = new Map();
+    const adicionar = (caminho) => {
+        adicionarCandidatoPreservandoForma(candidatos, contexto.baseProjeto, caminho);
+    };
+    const origens = new Set(irs.flatMap((ir) => implementacoesModulo(ir).map((impl) => impl.origem)));
+    const possuiRotas = irs.some((ir) => ir.routes.length > 0);
+    const possuiPersistencia = irs.some((ir) => ir.databases.length > 0
+        || ir.tasks.some((task) => task.effects.some((efeito) => /\b(?:db|database|persist|storage)\b/i.test(efeito))));
+    const bases = [contexto.baseProjeto, ...contexto.diretoriosCodigo];
+    if (possuiRotas && origens.has("rust")) {
+        for (const base of bases) {
+            adicionar(path.join(base, "main.rs"));
+            adicionar(path.join(base, "src", "main.rs"));
+            adicionar(path.join(base, "lib.rs"));
+            adicionar(path.join(base, "src", "lib.rs"));
+        }
+    }
+    if (possuiPersistencia) {
+        for (const base of bases) {
+            adicionar(path.join(base, "schema.sql"));
+            adicionar(path.join(base, "schema.prisma"));
+            adicionar(path.join(base, "db", "schema.sql"));
+            adicionar(path.join(base, "prisma", "schema.prisma"));
+        }
+    }
+    return [...candidatos.values()];
+}
+function escolherDiretoriosLogicos(contexto, arquivos) {
+    const candidatos = [...new Map(contexto.diretoriosCodigo
+            .map((diretorio) => path.resolve(diretorio))
+            .map((diretorio) => [chaveCaminho(diretorio), diretorio])).values()]
+        .sort((a, b) => b.length - a.length || a.localeCompare(b, "pt-BR"));
+    const escolhidos = new Map();
+    for (const arquivo of arquivos) {
+        const raiz = candidatos.find((diretorio) => caminhoEstaDentro(diretorio, arquivo))
+            ?? path.dirname(arquivo);
+        escolhidos.set(chaveCaminho(raiz), raiz);
+    }
+    return [...escolhidos.values()]
+        .sort((a, b) => a.localeCompare(b, "pt-BR"));
+}
+export async function planejarEscopoDrift(contexto, configuracao) {
+    if (configuracao.escopo === "projeto") {
+        const diretorios = resolverDiretoriosCodigoEscopoReal(contexto, configuracao);
+        return {
+            escopo: configuracao.escopo,
+            estrategia: "projeto",
+            arquivos: [],
+            arquivosDeclarados: [],
+            arquivosInferidos: [],
+            arquivosAusentes: [],
+            diretorios,
+            modulos: contexto.modulosSelecionados
+                .map((modulo) => modulo.resultado.ir?.nome)
+                .filter((nome) => Boolean(nome)),
+            cobertura: "completa",
+            bloqueios: [],
+            dependencias: {},
+        };
+    }
+    const modulosFonte = configuracao.escopo === "arquivo"
+        ? contexto.modulosSelecionados
+        : contexto.modulosCarregados;
+    const irs = modulosFonte
+        .map((modulo) => modulo.resultado.ir)
+        .filter((ir) => Boolean(ir));
+    const declarados = new Map();
+    const ausentes = new Map();
+    const inferidos = new Map();
+    const raizReal = await realpath(contexto.baseProjeto);
+    const vinculosPlanejados = irs.flatMap((ir) => vinculosModulo(ir))
+        .map((vinculo) => vinculo.arquivo ?? (vinculo.tipo === "arquivo" ? vinculo.valor : undefined))
+        .filter((valor) => Boolean(valor))
+        .map((valor) => ({
+        valor,
+        absoluto: resolverArquivoWorkspace(contexto.baseProjeto, valor),
+    }));
+    const implementacoesPlanejadas = irs
+        .flatMap((ir) => implementacoesModulo(ir))
+        .map((impl) => candidatosArquivoImpl(contexto, impl));
+    const candidatosDeterministicos = [
+        ...candidatosConsumerDeterministicos(contexto, irs, configuracao.termosEscopo),
+        ...candidatosRotasDeterministicos(contexto, irs),
+        ...candidatosConvencionaisEscopo(contexto, irs),
+    ];
+    const resultadoSondagens = await sondarArquivosRegularesContidos([
+        ...vinculosPlanejados.flatMap((vinculo) => vinculo.absoluto ? [vinculo.absoluto] : []),
+        ...implementacoesPlanejadas.flat(),
+        ...candidatosDeterministicos,
+    ], raizReal);
+    const arquivoExiste = (arquivo) => resultadoSondagens.get(chaveCaminho(arquivo)) === true;
+    for (const vinculo of vinculosPlanejados) {
+        if (!vinculo.absoluto) {
+            ausentes.set(`fora:${vinculo.valor}`, vinculo.valor);
+            continue;
+        }
+        if (arquivoExiste(vinculo.absoluto)) {
+            const chave = chaveCaminho(vinculo.absoluto);
+            if (!declarados.has(chave)) {
+                declarados.set(chave, vinculo.absoluto);
+            }
+        }
+        else {
+            ausentes.set(chaveCaminho(vinculo.absoluto), vinculo.absoluto);
+        }
+    }
+    for (const candidatos of implementacoesPlanejadas) {
+        const encontrados = candidatos.filter(arquivoExiste);
+        for (const candidato of encontrados) {
+            const chave = chaveCaminho(candidato);
+            if (!declarados.has(chave) && !inferidos.has(chave)) {
+                inferidos.set(chave, candidato);
+            }
+        }
+        if (encontrados.length === 0 && candidatos[0]) {
+            ausentes.set(chaveCaminho(candidatos[0]), candidatos[0]);
+        }
+    }
+    for (const candidato of candidatosDeterministicos.filter(arquivoExiste)) {
+        const chave = chaveCaminho(candidato);
+        if (!declarados.has(chave) && !inferidos.has(chave)) {
+            inferidos.set(chave, candidato);
+        }
+    }
+    const arquivosMesclados = new Map(declarados);
+    for (const [chave, arquivo] of inferidos) {
+        if (!arquivosMesclados.has(chave)) {
+            arquivosMesclados.set(chave, arquivo);
+        }
+    }
+    const arquivos = [...arquivosMesclados.values()]
+        .sort((a, b) => a.localeCompare(b, "pt-BR"));
+    const arquivosAusentes = [...ausentes.values()]
+        .sort((a, b) => a.localeCompare(b, "pt-BR"));
+    const bloqueios = arquivos.length === 0
+        ? ["escopo_estreito_sem_vinculos"]
+        : [];
+    return {
+        escopo: configuracao.escopo,
+        estrategia: "arquivos_vinculados",
+        arquivos,
+        arquivosDeclarados: [...declarados.values()].sort((a, b) => a.localeCompare(b, "pt-BR")),
+        arquivosInferidos: [...inferidos.values()].sort((a, b) => a.localeCompare(b, "pt-BR")),
+        arquivosAusentes,
+        diretorios: escolherDiretoriosLogicos(contexto, arquivos),
+        modulos: irs.map((ir) => ir.nome),
+        cobertura: arquivosAusentes.length === 0 && bloqueios.length === 0 ? "completa" : "parcial",
+        bloqueios,
+        dependencias: {},
+    };
+}
+async function construirConfinamentoDependencias(contexto) {
+    const raizWorkspaceReal = await realpath(contexto.baseProjeto);
+    const logicas = raizesCodigoLogicasDrift(contexto);
+    const reaisPossiveis = await mapearComLimite(logicas, CONCORRENCIA_SONDAGENS_DRIFT, async (raiz) => {
+        try {
+            const raizReal = await realpath(raiz);
+            return caminhoEstaDentro(raizWorkspaceReal, raizReal) ? raizReal : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    });
+    const raizesCodigoReais = [...new Map(reaisPossiveis
+            .filter((raiz) => Boolean(raiz))
+            .map((raiz) => [chaveCaminho(raiz), raiz])).values()];
+    return {
+        raizWorkspaceReal,
+        raizesCodigoLogicas: logicas,
+        raizesCodigoReais,
+    };
+}
+async function arquivoRegularConfinadoDependencias(caminho, confinamento) {
+    const absoluto = path.resolve(caminho);
+    if (!confinamento.raizesCodigoLogicas.some((raiz) => caminhoEstaDentro(raiz, absoluto))) {
+        return false;
+    }
+    try {
+        const informacao = await lstat(absoluto);
+        if (!informacao.isFile() || informacao.isSymbolicLink()) {
+            return false;
+        }
+        const caminhoReal = await realpath(absoluto);
+        return caminhoEstaDentro(confinamento.raizWorkspaceReal, caminhoReal)
+            && confinamento.raizesCodigoReais.some((raiz) => caminhoEstaDentro(raiz, caminhoReal));
+    }
+    catch {
+        return false;
+    }
+}
+async function resolverReferenciaLocalExistente(contexto, arquivoOrigem, referencia, confinamento, catalogados) {
+    for (const candidatoBruto of candidatosReferenciaLocalDrift(contexto, arquivoOrigem, referencia)) {
+        const candidato = catalogados?.get(chaveCaminho(candidatoBruto)) ?? candidatoBruto;
+        if (catalogados && !catalogados.has(chaveCaminho(candidatoBruto))) {
+            continue;
+        }
+        if (await arquivoRegularConfinadoDependencias(candidato, confinamento)) {
+            return candidato;
+        }
+    }
+    return undefined;
+}
+export async function expandirDependenciasPlanoDrift(contexto, plano, catalogo, cache) {
+    if (plano.estrategia !== "arquivos_vinculados" || plano.arquivos.length === 0) {
+        return plano;
+    }
+    const arquivos = new Map(plano.arquivos.map((arquivo) => [chaveCaminho(arquivo), arquivo]));
+    const inferidos = new Map(plano.arquivosInferidos.map((arquivo) => [chaveCaminho(arquivo), arquivo]));
+    const visitados = new Set();
+    const fila = [...plano.arquivos];
+    const confinamento = await construirConfinamentoDependencias(contexto);
+    const dependencias = new Map(Object.entries(plano.dependencias).map(([arquivo, itens]) => [arquivo, new Set(itens)]));
+    while (fila.length > 0) {
+        const lote = fila.splice(0)
+            .filter((arquivo) => {
+            const chave = chaveCaminho(arquivo);
+            if (visitados.has(chave)) {
+                return false;
+            }
+            visitados.add(chave);
+            return true;
+        });
+        const resultadosLote = await mapearComLimite(lote, CONCORRENCIA_MAPEAMENTO_DEPENDENCIAS_DRIFT, async (arquivo) => {
+            let referencias;
+            try {
+                if (cache) {
+                    const estado = await 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"),
+                    });
+                    referencias = estado.valor;
+                }
+                else {
+                    referencias = extrairReferenciasLocaisDrift(await catalogo.lerTexto(arquivo));
+                }
+            }
+            catch {
+                return { arquivo, resolvidas: [] };
+            }
+            const resolvidas = new Map();
+            for (const referencia of referencias) {
+                const candidato = await resolverReferenciaLocalExistente(contexto, arquivo, referencia, confinamento);
+                if (candidato) {
+                    resolvidas.set(chaveCaminho(candidato), candidato);
+                }
+            }
+            return { arquivo, resolvidas: [...resolvidas.values()] };
+        });
+        const novos = new Map();
+        for (const { arquivo, resolvidas } of resultadosLote) {
+            if (resolvidas.length > 0) {
+                const lista = dependencias.get(arquivo) ?? new Set();
+                for (const candidato of resolvidas) {
+                    lista.add(candidato);
+                    const chave = chaveCaminho(candidato);
+                    if (!arquivos.has(chave)) {
+                        novos.set(chave, candidato);
+                    }
+                }
+                dependencias.set(arquivo, lista);
+            }
+        }
+        if (novos.size > 0) {
+            const novosOrdenados = [...novos.values()].sort((a, b) => a.localeCompare(b, "pt-BR"));
+            await catalogo.incluir(novosOrdenados);
+            for (const candidato of novosOrdenados) {
+                const chave = chaveCaminho(candidato);
+                arquivos.set(chave, candidato);
+                inferidos.set(chave, candidato);
+                fila.push(candidato);
+            }
+        }
+    }
+    const arquivosExpandidos = [...arquivos.values()].sort((a, b) => a.localeCompare(b, "pt-BR"));
+    return {
+        ...plano,
+        arquivos: arquivosExpandidos,
+        arquivosInferidos: [...inferidos.values()].sort((a, b) => a.localeCompare(b, "pt-BR")),
+        diretorios: escolherDiretoriosLogicos(contexto, arquivosExpandidos),
+        dependencias: Object.fromEntries([...dependencias.entries()]
+            .sort(([a], [b]) => a.localeCompare(b, "pt-BR"))
+            .map(([arquivo, itens]) => [arquivo, [...itens].sort((a, b) => a.localeCompare(b, "pt-BR"))])),
+    };
+}
+export async function mapearDependenciasCatalogadasDrift(contexto, catalogo, cache, arquivos = catalogo.arquivosCatalogados()) {
+    const confinamento = await construirConfinamentoDependencias(contexto);
+    const catalogados = new Map(catalogo.arquivosCatalogados().map((arquivo) => [chaveCaminho(arquivo), arquivo]));
+    const arquivosOrdenados = [...arquivos].sort((a, b) => a.localeCompare(b, "pt-BR"));
+    const resultados = await mapearComLimite(arquivosOrdenados, CONCORRENCIA_MAPEAMENTO_DEPENDENCIAS_DRIFT, async (arquivo) => {
+        let referencias;
+        try {
+            const estado = await 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"),
+            });
+            referencias = estado.valor;
+        }
+        catch {
+            return undefined;
+        }
+        const resolvidas = new Map();
+        for (const referencia of referencias) {
+            const existente = await resolverReferenciaLocalExistente(contexto, arquivo, referencia, confinamento, catalogados);
+            if (existente) {
+                resolvidas.set(chaveCaminho(existente), existente);
+            }
+        }
+        return [
+            arquivo,
+            [...resolvidas.values()].sort((a, b) => a.localeCompare(b, "pt-BR")),
+        ];
+    });
+    const dependencias = new Map(resultados.filter((item) => Boolean(item)));
+    return Object.fromEntries([...dependencias.entries()].sort(([a], [b]) => a.localeCompare(b, "pt-BR")));
+}
+//# sourceMappingURL=driftEscopo.js.map

package/dist/driftEscopoReferencias.d.ts

@@ -0,0 +1,4 @@
+import type { ContextoProjetoCarregado } from "./projeto.js";
+export declare function extrairReferenciasLocaisDrift(codigo: string): string[];
+export declare function raizesCodigoLogicasDrift(contexto: ContextoProjetoCarregado): string[];
+export declare function candidatosReferenciaLocalDrift(contexto: ContextoProjetoCarregado, arquivoOrigem: string, referencia: string): string[];