@semacode/cli 2.3.1 → 3.0.0

package/dist/drift.part12.js

@@ -1,12 +1,11 @@
 // 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 { definirDiretoriosIgnoradosAtivos, obterDiretoriosIgnoradosAtivos, normalizarFragmentoArquivo, quebrarTermosEscopo, extrairTermosEscopoDrift, resolverDiretoriosIgnoradosAtivos, resolverOpcoesDrift } from "./drift.part01.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";
-import { planejarEscopoDrift } from "./driftEscopo.js";
 export const EXTENSOES_BUSCA_IMPACTO = [
     ".sema",
     ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
@@ -98,23 +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") {
-        const plano = await planejarEscopoDrift(contexto, {
-            escopo: opcoesResolvidas.escopo,
-            ignorarWorktrees: opcoesResolvidas.ignorarWorktrees,
-            ignorarConsumidoresLaterais: opcoesResolvidas.ignorarConsumidoresLaterais,
-            termosEscopo: extrairTermosEscopoDrift(contexto, opcoesResolvidas.escopo),
-        });
-        for (const arquivo of plano.arquivos) {
-            arquivos.add(arquivo);
+        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);
         }
     }
@@ -175,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"]);
@@ -210,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,
@@ -253,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();
@@ -260,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,52 +1,33 @@
 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 DiagnosticoOrcamentoArquivo } from "./driftOrcamento.js";
-import { type CatalogoDrift, type MetricasCatalogoDrift, type ObservadorOperacaoDrift } from "./driftCatalogo.js";
-import { type PoliticaCacheDrift } from "./driftCache.js";
-import { type MetricasCacheIncrementalDrift } from "./driftCacheIncremental.js";
+import { type MetricasCatalogoDrift, type ObservadorOperacaoDrift } from "./driftCatalogo.js";
 import { type PlanoEscopoDrift } from "./driftEscopo.js";
-type IndiceTypeScriptDrift = Awaited<ReturnType<typeof indexarTypeScript>>;
-type IndiceDartDrift = Awaited<ReturnType<typeof indexarDart>>;
-type DetalhesPersistenciaDrift = Awaited<ReturnType<typeof indexarPersistenciaDetalhada>>;
-interface IndicesDriftSerializaveis {
-    arquivosOrcamentoAvaliados: string[];
-    detalhesPersistencia: DetalhesPersistenciaDrift;
-    diagnosticosOrcamento: DiagnosticoOrcamentoArquivo[];
-    indexDart: IndiceDartDrift;
-    indexTs: IndiceTypeScriptDrift;
-    todasRotasIndexadas: RotaResolvida[];
-    todosArquivosConhecidos: string[];
-    todosRecursos: RecursoResolvido[];
-    todosSimbolos: SimboloResolvido[];
+import type { AvisoModoCacheDrift, ModoCacheDrift } from "./driftCacheModes.js";
+export interface LeitorArquivosPlanejadosDrift {
+    contem(caminho: string): boolean;
+    lerTexto(caminho: string): Promise<string>;
 }
-export interface EstadoCacheIndicesDrift {
-    politica: PoliticaCacheDrift;
-    origem: "cache" | "calculado" | "nao_aplicavel";
-    chave?: string;
-    incremental?: MetricasCacheIncrementalDrift;
-    fasesMs?: {
-        planejamento: number;
-        catalogacao: number;
-        dependencias: number;
-        assinaturas: number;
-        indexacao: number;
-        total: number;
-    };
+export interface OpcoesPrepararIndicesDrift {
+    observador?: ObservadorOperacaoDrift;
+    modoCache?: ModoCacheDrift;
+    avisosModoCache?: readonly AvisoModoCacheDrift[];
 }
-export interface IndicesDriftPreparados extends IndicesDriftSerializaveis {
+export interface IndicesDriftPreparados {
+    detalhesPersistencia: Awaited<ReturnType<typeof indexarPersistenciaDetalhada>>;
+    indexDart: Awaited<ReturnType<typeof indexarDart>>;
+    indexTs: Awaited<ReturnType<typeof indexarTypeScript>>;
     mapaImpl: Map<string, SimboloResolvido>;
     mapaRecursos: Map<string, RecursoResolvido[]>;
+    todasRotasIndexadas: RotaResolvida[];
+    todosArquivosConhecidos: string[];
+    todosRecursos: RecursoResolvido[];
+    todosSimbolos: SimboloResolvido[];
     planoEscopo: PlanoEscopoDrift;
-    cache: EstadoCacheIndicesDrift;
+    cache: EstadoCacheDriftAplicado;
     catalogo: MetricasCatalogoDrift;
-    leitorArquivosPlanejados?: Pick<CatalogoDrift, "contem" | "lerTexto">;
-}
-export interface OpcoesPrepararIndicesDrift {
-    politicaCache?: PoliticaCacheDrift;
-    observador?: ObservadorOperacaoDrift;
+    leitorArquivosPlanejados: LeitorArquivosPlanejadosDrift;
 }
 export declare function prepararIndicesDrift(contexto: ContextoProjetoCarregado, configuracaoEscopo: ConfiguracaoEscopoDriftAplicada, opcoes?: OpcoesPrepararIndicesDrift): Promise<IndicesDriftPreparados>;
-export {};