@semacode/cli 2.3.0 → 3.0.0

package/dist/drift.part12.js

@@ -1,8 +1,8 @@
 // SEMA-GOVERNED: sema.governanca_ia_contexto
 // Descricao: CLI particionada; consulte contratos/sema/governanca_ia_contexto.sema antes de editar.
-import { readFile } from "node:fs/promises";
+import { lstat, open, readdir, realpath } from "node:fs/promises";
 import path from "node:path";
-import { listarArquivosRecursivos, paraIdentificadorModulo } from "./drift.part04.js";
+import { paraIdentificadorModulo } from "./drift.part04.js";
 import { definirDiretoriosIgnoradosAtivos, obterDiretoriosIgnoradosAtivos, normalizarFragmentoArquivo, quebrarTermosEscopo, resolverDiretoriosIgnoradosAtivos, resolverOpcoesDrift } from "./drift.part01.js";
 import { filtrarCaminhosEscopoReal, resolverDiretoriosCodigoEscopoReal, textoCombinaEscopo } from "./drift.part02.js";
 import { analisarDriftLegado } from "./drift.part11.js";
@@ -97,11 +97,164 @@ export function registrarArquivoImpactado(mapa, arquivo, linhas, motivos) {
         motivos: [...new Set(motivos)],
     });
 }
-export async function listarArquivosImpacto(contexto, opcoes) {
+function chaveCaminhoImpacto(caminho) {
+    const absoluto = path.normalize(path.resolve(caminho));
+    return process.platform === "win32" ? absoluto.toLowerCase() : absoluto;
+}
+function caminhoImpactoEstaDentro(raiz, alvo) {
+    const relativo = path.relative(path.resolve(raiz), path.resolve(alvo));
+    return relativo === "" || (relativo !== ".."
+        && !relativo.startsWith(`..${path.sep}`)
+        && !path.isAbsolute(relativo));
+}
+function identidadeArquivoImpactoEstavel(a, b) {
+    return a.isFile()
+        && b.isFile()
+        && !a.isSymbolicLink()
+        && !b.isSymbolicLink()
+        && a.dev === b.dev
+        && a.ino === b.ino
+        && a.size === b.size
+        && a.mtimeNs === b.mtimeNs
+        && a.ctimeNs === b.ctimeNs;
+}
+function identidadeDiretorioImpactoEstavel(a, b) {
+    return a.isDirectory()
+        && b.isDirectory()
+        && !a.isSymbolicLink()
+        && !b.isSymbolicLink()
+        && a.dev === b.dev
+        && a.ino === b.ino
+        && a.mtimeNs === b.mtimeNs
+        && a.ctimeNs === b.ctimeNs;
+}
+function erroImpactoConfinamento(codigo) {
+    return new Error(`impacto_confinamento:${codigo}`);
+}
+async function lerArquivoImpactoConfinado(baseProjeto, baseProjetoReal, arquivo) {
+    const absoluto = path.resolve(arquivo);
+    if (!caminhoImpactoEstaDentro(baseProjeto, absoluto)) {
+        throw erroImpactoConfinamento("fora_workspace");
+    }
+    const informacaoAntes = await lstat(absoluto, { bigint: true });
+    if (!informacaoAntes.isFile() || informacaoAntes.isSymbolicLink()) {
+        throw erroImpactoConfinamento("arquivo_irregular");
+    }
+    const caminhoRealAntes = await realpath(absoluto);
+    if (!caminhoImpactoEstaDentro(baseProjetoReal, caminhoRealAntes)) {
+        throw erroImpactoConfinamento("fora_workspace_real");
+    }
+    const handle = await open(absoluto, "r");
+    try {
+        const informacaoHandleAntes = await handle.stat({ bigint: true });
+        const [informacaoCaminhoAberto, caminhoRealAberto] = await Promise.all([
+            lstat(absoluto, { bigint: true }),
+            realpath(absoluto),
+        ]);
+        if (!caminhoImpactoEstaDentro(baseProjetoReal, caminhoRealAberto)
+            || !identidadeArquivoImpactoEstavel(informacaoAntes, informacaoHandleAntes)
+            || !identidadeArquivoImpactoEstavel(informacaoHandleAntes, informacaoCaminhoAberto)) {
+            throw erroImpactoConfinamento("arquivo_alterado_antes_leitura");
+        }
+        const conteudo = await handle.readFile();
+        const [informacaoHandleDepois, informacaoCaminhoDepois, caminhoRealDepois] = await Promise.all([
+            handle.stat({ bigint: true }),
+            lstat(absoluto, { bigint: true }),
+            realpath(absoluto),
+        ]);
+        if (!caminhoImpactoEstaDentro(baseProjetoReal, caminhoRealDepois)
+            || !identidadeArquivoImpactoEstavel(informacaoHandleAntes, informacaoHandleDepois)
+            || !identidadeArquivoImpactoEstavel(informacaoHandleDepois, informacaoCaminhoDepois)) {
+            throw erroImpactoConfinamento("arquivo_alterado_durante_leitura");
+        }
+        return conteudo.toString("utf8");
+    }
+    finally {
+        await handle.close().catch(() => undefined);
+    }
+}
+async function listarDiretorioImpactoConfinado(diretorio, baseProjeto, baseProjetoReal, visitados) {
+    const absoluto = path.resolve(diretorio);
+    if (!caminhoImpactoEstaDentro(baseProjeto, absoluto)) {
+        return [];
+    }
+    let informacaoAntes;
+    try {
+        informacaoAntes = await lstat(absoluto, { bigint: true });
+    }
+    catch (erro) {
+        if (["ENOENT", "ENOTDIR"].includes(erro.code ?? "")) {
+            return [];
+        }
+        throw erro;
+    }
+    if (!informacaoAntes.isDirectory() || informacaoAntes.isSymbolicLink()) {
+        return [];
+    }
+    const caminhoRealAntes = await realpath(absoluto);
+    if (!caminhoImpactoEstaDentro(baseProjetoReal, caminhoRealAntes)) {
+        return [];
+    }
+    const chaveReal = chaveCaminhoImpacto(caminhoRealAntes);
+    if (visitados.has(chaveReal)) {
+        return [];
+    }
+    visitados.add(chaveReal);
+    const entradas = await readdir(absoluto, { withFileTypes: true, encoding: "utf8" });
+    const [informacaoDepois, caminhoRealDepois] = await Promise.all([
+        lstat(absoluto, { bigint: true }),
+        realpath(absoluto),
+    ]);
+    if (!caminhoImpactoEstaDentro(baseProjetoReal, caminhoRealDepois)
+        || !identidadeDiretorioImpactoEstavel(informacaoAntes, informacaoDepois)) {
+        throw erroImpactoConfinamento("diretorio_alterado_durante_listagem");
+    }
+    const ignorados = obterDiretoriosIgnoradosAtivos();
+    const encontrados = [];
+    for (const entrada of entradas) {
+        if (ignorados.has(entrada.name.toLowerCase()) || entrada.isSymbolicLink()) {
+            continue;
+        }
+        const caminhoAtual = path.join(absoluto, entrada.name);
+        if (entrada.isDirectory()) {
+            encontrados.push(...await listarDiretorioImpactoConfinado(caminhoAtual, baseProjeto, baseProjetoReal, visitados));
+            continue;
+        }
+        if (entrada.isFile() && EXTENSOES_BUSCA_IMPACTO.some((extensao) => entrada.name.toLowerCase().endsWith(extensao))) {
+            encontrados.push(caminhoAtual);
+        }
+    }
+    return encontrados;
+}
+export async function listarArquivosImpacto(contexto, opcoes, arquivosPlanejados = []) {
     const opcoesResolvidas = resolverOpcoesDrift(opcoes);
-    const arquivos = new Set(filtrarCaminhosEscopoReal(contexto.arquivosProjeto, contexto, opcoesResolvidas));
+    const baseProjeto = path.resolve(contexto.baseProjeto);
+    const contratos = opcoesResolvidas.escopo === "projeto"
+        ? contexto.arquivosProjeto
+        : contexto.modulosSelecionados.map((modulo) => modulo.caminho);
+    const arquivos = new Set();
+    for (const arquivo of filtrarCaminhosEscopoReal(contratos, contexto, opcoesResolvidas)) {
+        const absoluto = path.resolve(arquivo);
+        if (caminhoImpactoEstaDentro(baseProjeto, absoluto)) {
+            arquivos.add(absoluto);
+        }
+    }
+    if (opcoesResolvidas.escopo !== "projeto") {
+        for (const arquivo of arquivosPlanejados) {
+            if (arquivo.startsWith("[fora_do_workspace]/")) {
+                continue;
+            }
+            const absoluto = path.resolve(baseProjeto, arquivo);
+            if (caminhoImpactoEstaDentro(baseProjeto, absoluto)) {
+                arquivos.add(absoluto);
+            }
+        }
+        return [...arquivos].sort((a, b) => a.localeCompare(b, "pt-BR"));
+    }
+    const baseProjetoReal = await realpath(baseProjeto);
+    const visitados = new Set();
     for (const diretorio of resolverDiretoriosCodigoEscopoReal(contexto, opcoesResolvidas)) {
-        for (const arquivo of await listarArquivosRecursivos(diretorio, EXTENSOES_BUSCA_IMPACTO)) {
+        for (const arquivo of await listarDiretorioImpactoConfinado(diretorio, baseProjeto, baseProjetoReal, visitados)) {
             arquivos.add(arquivo);
         }
     }
@@ -162,9 +315,11 @@ export async function gerarMapaImpactoSemantico(contexto, alvoSemantico, mudanca
         const variantes = construirVariantesSemanticas(alvoSemantico);
         const termos = [...new Set([...quebrarTermosEscopo(alvoSemantico), ...drift.escopo_aplicado.termosEscopo])];
         const arquivosImpactados = new Map();
-        const arquivosBusca = await listarArquivosImpacto(contexto, opcoesResolvidas);
+        const arquivosBusca = await listarArquivosImpacto(contexto, opcoesResolvidas, drift.escopo_aplicado.arquivosPlanejados);
+        const arquivosBuscaPorChave = new Set(arquivosBusca.map(chaveCaminhoImpacto));
+        const baseProjetoReal = await realpath(path.resolve(contexto.baseProjeto));
         for (const arquivo of arquivosBusca) {
-            const codigo = await readFile(arquivo, "utf8");
+            const codigo = await lerArquivoImpactoConfinado(contexto.baseProjeto, baseProjetoReal, arquivo);
             const linhas = extrairLinhasComVariantes(codigo, variantes);
             if (linhas.length > 0) {
                 registrarArquivoImpactado(arquivosImpactados, arquivo, linhas, ["token_semantico_encontrado"]);
@@ -197,21 +352,29 @@ export async function gerarMapaImpactoSemantico(contexto, alvoSemantico, mudanca
         }
         for (const task of drift.tasks.filter((item) => tasksAfetadas.has(`${item.modulo}.${item.task}`))) {
             for (const arquivo of task.arquivosProvaveisEditar) {
-                registrarArquivoImpactado(arquivosImpactados, arquivo, [], ["arquivo_relacionado_por_drift"]);
+                if (arquivosBuscaPorChave.has(chaveCaminhoImpacto(arquivo))) {
+                    registrarArquivoImpactado(arquivosImpactados, arquivo, [], ["arquivo_relacionado_por_drift"]);
+                }
             }
         }
         for (const item of drift.persistencia_real) {
             if (textoIrCombinaTermos(`${item.alvo} ${item.task} ${item.colunas.join(" ")}`, termos)) {
                 persistenciaAfetada.add(`${item.task}:${item.alvo}`);
                 for (const arquivo of [...item.arquivos, ...item.repositorios]) {
-                    registrarArquivoImpactado(arquivosImpactados, arquivo, [], ["persistencia_relacionada"]);
+                    if (arquivosBuscaPorChave.has(chaveCaminhoImpacto(arquivo))) {
+                        registrarArquivoImpactado(arquivosImpactados, arquivo, [], ["persistencia_relacionada"]);
+                    }
                 }
             }
         }
         const contratosAfetados = ordenarArquivosImpacto([...arquivosImpactados.values()].filter((arquivo) => arquivo.tipo === "contrato")).map((arquivo) => arquivo.arquivo);
+        const driftPermiteImpacto = (drift.escopo_aplicado.bloqueios?.length ?? 0) === 0
+            && drift.escopo_aplicado.cobertura !== "parcial"
+            && drift.vinculos_quebrados.length === 0;
         return {
             comando: "impacto",
-            sucesso: arquivosImpactados.size > 0 || tasksAfetadas.size > 0 || persistenciaAfetada.size > 0,
+            sucesso: driftPermiteImpacto
+                && (arquivosImpactados.size > 0 || tasksAfetadas.size > 0 || persistenciaAfetada.size > 0),
             escopo: drift.escopo_aplicado.escopo,
             alvoSemantico,
             mudancaProposta,
@@ -240,6 +403,27 @@ export async function gerarMapaImpactoSemantico(contexto, alvoSemantico, mudanca
 }
 export async function assistirRenomeacaoSemantica(contexto, nomeAtual, nomeNovo, opcoes) {
     const impacto = await gerarMapaImpactoSemantico(contexto, nomeAtual, `renomear ${nomeAtual} para ${nomeNovo}`, opcoes);
+    if (!impacto.sucesso) {
+        return {
+            comando: "renomear-semantico",
+            sucesso: false,
+            escopo: impacto.escopo,
+            de: nomeAtual,
+            para: nomeNovo,
+            arquivos: impacto.arquivos,
+            sugestoes: [],
+            ordemOperacional: [
+                "Renomear primeiro no contrato .sema e nos campos publicos derivados.",
+                "Ajustar repositorios, payloads e bridges que materializam o nome antigo.",
+                "Rodar sema drift e revisar sugestoes restantes antes de fechar a troca.",
+            ],
+            validacoes: [
+                "Rodar sema validar no contrato renomeado.",
+                "Rodar sema drift para confirmar que payload e superficie nao ficaram misturados.",
+                "Reexecutar testes e checar snapshots ou fixtures afetados.",
+            ],
+        };
+    }
     const variantesAntigas = construirVariantesSemanticas(nomeAtual);
     const variantesNovas = construirVariantesSemanticas(nomeNovo);
     const mapaSubstituicao = new Map();
@@ -247,8 +431,9 @@ export async function assistirRenomeacaoSemantica(contexto, nomeAtual, nomeNovo,
         mapaSubstituicao.set(antiga, variantesNovas[indice] ?? nomeNovo);
     });
     const sugestoes = [];
+    const baseProjetoReal = await realpath(path.resolve(contexto.baseProjeto));
     for (const arquivo of impacto.arquivos) {
-        const codigo = await readFile(arquivo.arquivo, "utf8");
+        const codigo = await lerArquivoImpactoConfinado(contexto.baseProjeto, baseProjetoReal, arquivo.arquivo);
         const linhas = codigo.split(/\r?\n/);
         for (let indice = 0; indice < linhas.length; indice += 1) {
             const linha = linhas[indice];

package/dist/drift.part13.d.ts

@@ -1,8 +1,20 @@
 import type { ContextoProjetoCarregado } from "./projeto.js";
-import type { ConfiguracaoEscopoDriftAplicada, RecursoResolvido, RotaResolvida, SimboloResolvido } from "./drift.part01.js";
+import { type ConfiguracaoEscopoDriftAplicada, type EstadoCacheDriftAplicado, type RecursoResolvido, type RotaResolvida, type SimboloResolvido } from "./drift.part01.js";
 import { indexarTypeScript } from "./drift.part06.js";
 import { indexarDart } from "./drift.part07.js";
 import { indexarPersistenciaDetalhada } from "./drift.part08.js";
+import { type MetricasCatalogoDrift, type ObservadorOperacaoDrift } from "./driftCatalogo.js";
+import { type PlanoEscopoDrift } from "./driftEscopo.js";
+import type { AvisoModoCacheDrift, ModoCacheDrift } from "./driftCacheModes.js";
+export interface LeitorArquivosPlanejadosDrift {
+    contem(caminho: string): boolean;
+    lerTexto(caminho: string): Promise<string>;
+}
+export interface OpcoesPrepararIndicesDrift {
+    observador?: ObservadorOperacaoDrift;
+    modoCache?: ModoCacheDrift;
+    avisosModoCache?: readonly AvisoModoCacheDrift[];
+}
 export interface IndicesDriftPreparados {
     detalhesPersistencia: Awaited<ReturnType<typeof indexarPersistenciaDetalhada>>;
     indexDart: Awaited<ReturnType<typeof indexarDart>>;
@@ -13,5 +25,9 @@ export interface IndicesDriftPreparados {
     todosArquivosConhecidos: string[];
     todosRecursos: RecursoResolvido[];
     todosSimbolos: SimboloResolvido[];
+    planoEscopo: PlanoEscopoDrift;
+    cache: EstadoCacheDriftAplicado;
+    catalogo: MetricasCatalogoDrift;
+    leitorArquivosPlanejados: LeitorArquivosPlanejadosDrift;
 }
-export declare function prepararIndicesDrift(contexto: ContextoProjetoCarregado, configuracaoEscopo: ConfiguracaoEscopoDriftAplicada): Promise<IndicesDriftPreparados>;
+export declare function prepararIndicesDrift(contexto: ContextoProjetoCarregado, configuracaoEscopo: ConfiguracaoEscopoDriftAplicada, opcoes?: OpcoesPrepararIndicesDrift): Promise<IndicesDriftPreparados>;