@semacode/cli 2.3.1 → 3.0.0

package/dist/driftEscopoReferencias.js

@@ -1,15 +1,19 @@
 // SEMA-GOVERNED: sema.produto.governanca_ia.drift
 // Descricao: extrai e resolve candidatos exatos de dependencias locais sem caminhada de filesystem.
 import path from "node:path";
+import ts from "typescript";
 const EXTENSOES_DEPENDENCIA_CODIGO = [
-    ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".dart", ".lua", ".cs", ".java",
+    ".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs", ".py", ".dart", ".lua", ".cs", ".java",
     ".go", ".rs", ".php", ".cpp", ".cc", ".cxx", ".hpp", ".h",
     ".sql", ".psql", ".ddl", ".prisma", ".html", ".htm", ".css",
 ];
 const EXTENSOES_TYPESCRIPT_DEPENDENCIA = [
-    ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".html", ".htm", ".css",
+    ".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs", ".html", ".htm", ".css",
 ];
 const PREFIXO_REFERENCIA_PYTHON = "python:";
+const PREFIXO_REFERENCIA_RUST_MODULO = "rust-mod:";
+const PREFIXO_REFERENCIA_RUST_CAMINHO = "rust-path:";
+const REFERENCIA_ALIAS_CONFIG_INCOMPLETA = "alias-config:nao_resolvida";
 function chaveCaminho(caminho) {
     const absoluto = path.normalize(path.resolve(caminho));
     return process.platform === "win32" ? absoluto.toLowerCase() : absoluto;
@@ -20,6 +24,107 @@ function caminhoEstaDentro(raiz, alvo) {
         && !relativo.startsWith(`..${path.sep}`)
         && !path.isAbsolute(relativo));
 }
+function encontrarConfiguracaoTypeScript(contexto, arquivoOrigem) {
+    const baseProjeto = path.resolve(contexto.baseProjeto);
+    let diretorio = path.dirname(path.resolve(arquivoOrigem));
+    if (!caminhoEstaDentro(baseProjeto, diretorio)) {
+        return undefined;
+    }
+    for (;;) {
+        for (const nome of ["tsconfig.json", "jsconfig.json"]) {
+            const candidato = path.join(diretorio, nome);
+            if (ts.sys.fileExists(candidato)) {
+                return candidato;
+            }
+        }
+        if (chaveCaminho(diretorio) === chaveCaminho(baseProjeto)) {
+            return undefined;
+        }
+        const pai = path.dirname(diretorio);
+        if (pai === diretorio || !caminhoEstaDentro(baseProjeto, pai)) {
+            return undefined;
+        }
+        diretorio = pai;
+    }
+}
+function resolverExtendsTypeScript(configuracao, valor) {
+    if (!valor.startsWith(".") && !path.isAbsolute(valor)) {
+        return undefined;
+    }
+    const base = path.resolve(path.dirname(configuracao), valor);
+    for (const candidato of [base, `${base}.json`, path.join(base, "tsconfig.json")]) {
+        if (ts.sys.fileExists(candidato)) {
+            return candidato;
+        }
+    }
+    return undefined;
+}
+function carregarConfiguracaoAliasesTypeScript(contexto, arquivoOrigem) {
+    const configuracaoInicial = encontrarConfiguracaoTypeScript(contexto, arquivoOrigem);
+    if (!configuracaoInicial) {
+        return { regras: [], incompleta: false };
+    }
+    const visitadas = new Set();
+    const carregar = (configuracao) => {
+        const chave = chaveCaminho(configuracao);
+        if (visitadas.has(chave) || visitadas.size >= 8) {
+            return { regras: [], incompleta: true };
+        }
+        visitadas.add(chave);
+        const leitura = ts.readConfigFile(configuracao, ts.sys.readFile);
+        if (leitura.error || !leitura.config || typeof leitura.config !== "object") {
+            return { regras: [], incompleta: true };
+        }
+        const config = leitura.config;
+        const opcoes = config.compilerOptions ?? {};
+        const base = path.resolve(path.dirname(configuracao), opcoes.baseUrl ?? ".");
+        const regrasAtuais = Object.entries(opcoes.paths ?? {})
+            .map(([padrao, alvos]) => {
+            if (!Array.isArray(alvos)) {
+                return undefined;
+            }
+            const alvosValidos = alvos.filter((alvo) => typeof alvo === "string" && alvo.length > 0);
+            return alvosValidos.length > 0 ? { padrao, alvos: alvosValidos, base } : undefined;
+        })
+            .filter((regra) => Boolean(regra));
+        let incompleta = false;
+        const herdadas = [];
+        const extensoes = Array.isArray(config.extends)
+            ? config.extends
+            : config.extends ? [config.extends] : [];
+        for (const extensao of extensoes) {
+            const caminhoBase = resolverExtendsTypeScript(configuracao, extensao);
+            if (!caminhoBase || !caminhoEstaDentro(contexto.baseProjeto, caminhoBase)) {
+                incompleta = true;
+                continue;
+            }
+            const resultadoBase = carregar(caminhoBase);
+            herdadas.push(...resultadoBase.regras);
+            incompleta = incompleta || resultadoBase.incompleta;
+        }
+        const padroesAtuais = new Set(regrasAtuais.map((regra) => regra.padrao));
+        return {
+            regras: [...regrasAtuais, ...herdadas.filter((regra) => !padroesAtuais.has(regra.padrao))],
+            incompleta,
+        };
+    };
+    return carregar(configuracaoInicial);
+}
+function capturarAliasTypeScript(padrao, referencia) {
+    const indiceCoringa = padrao.indexOf("*");
+    if (indiceCoringa < 0) {
+        return padrao === referencia ? "" : undefined;
+    }
+    const prefixo = padrao.slice(0, indiceCoringa);
+    const sufixo = padrao.slice(indiceCoringa + 1);
+    if (!referencia.startsWith(prefixo) || !referencia.endsWith(sufixo)) {
+        return undefined;
+    }
+    return referencia.slice(prefixo.length, referencia.length - sufixo.length);
+}
+function referenciaCorrespondeAliasTypeScript(referencia, configuracao) {
+    return configuracao?.regras.some((regra) => capturarAliasTypeScript(regra.padrao, referencia) !== undefined) ?? false;
+}
 function mascararIntervalo(codigo, saida, inicio, fim) {
     for (let indice = inicio; indice < fim; indice += 1) {
         if (codigo[indice] !== "\n" && codigo[indice] !== "\r") {
@@ -27,7 +132,137 @@ function mascararIntervalo(codigo, saida, inicio, fim) {
         }
     }
 }
-/** Remove comentarios/docstrings sem alterar offsets ou caminhos em literais de imports reais. */
+function avancarStringEmExpressao(codigo, inicio) {
+    const delimitador = codigo[inicio];
+    let indice = inicio + 1;
+    while (indice < codigo.length) {
+        if (codigo[indice] === "\\") {
+            indice += 2;
+            continue;
+        }
+        if (codigo[indice] === delimitador) {
+            return indice + 1;
+        }
+        indice += 1;
+    }
+    return codigo.length;
+}
+function avancarRegexEmExpressao(codigo, inicio) {
+    let indice = inicio + 1;
+    let classe = false;
+    while (indice < codigo.length) {
+        if (codigo[indice] === "\\") {
+            indice += 2;
+            continue;
+        }
+        if (codigo[indice] === "[") {
+            classe = true;
+        }
+        else if (codigo[indice] === "]") {
+            classe = false;
+        }
+        else if (codigo[indice] === "/" && !classe) {
+            indice += 1;
+            while (/[A-Za-z]/u.test(codigo[indice] ?? "")) {
+                indice += 1;
+            }
+            return indice;
+        }
+        indice += 1;
+    }
+    return codigo.length;
+}
+function barraIniciaRegex(codigo, indice) {
+    let anterior = indice - 1;
+    while (anterior >= 0 && /\s/u.test(codigo[anterior] ?? "")) {
+        anterior -= 1;
+    }
+    return anterior < 0 || /[([{=,:;!?&|+\-*%^~<>]/u.test(codigo[anterior] ?? "");
+}
+function avancarExpressaoTemplate(codigo, inicio, profundidade) {
+    let indice = inicio;
+    let nivelChaves = 1;
+    while (indice < codigo.length) {
+        const atual = codigo[indice];
+        const proximo = codigo[indice + 1];
+        if (atual === "'" || atual === '"') {
+            indice = avancarStringEmExpressao(codigo, indice);
+            continue;
+        }
+        if (atual === "`") {
+            indice = avancarTemplateLiteral(codigo, indice, profundidade + 1).fim;
+            continue;
+        }
+        if (atual === "/" && proximo === "/") {
+            const fimLinha = codigo.indexOf("\n", indice + 2);
+            indice = fimLinha < 0 ? codigo.length : fimLinha;
+            continue;
+        }
+        if (atual === "/" && proximo === "*") {
+            const fimComentario = codigo.indexOf("*/", indice + 2);
+            indice = fimComentario < 0 ? codigo.length : fimComentario + 2;
+            continue;
+        }
+        if (atual === "/" && barraIniciaRegex(codigo, indice)) {
+            indice = avancarRegexEmExpressao(codigo, indice);
+            continue;
+        }
+        if (atual === "{") {
+            nivelChaves += 1;
+        }
+        else if (atual === "}") {
+            nivelChaves -= 1;
+            if (nivelChaves === 0) {
+                return indice + 1;
+            }
+        }
+        indice += 1;
+    }
+    return codigo.length;
+}
+function avancarTemplateLiteral(codigo, inicio, profundidade = 0) {
+    if (profundidade > 64) {
+        return { fim: codigo.length, fechado: false, interpolado: true };
+    }
+    let indice = inicio + 1;
+    let interpolado = false;
+    while (indice < codigo.length) {
+        if (codigo[indice] === "\\") {
+            indice += 2;
+            continue;
+        }
+        if (codigo[indice] === "`") {
+            return { fim: indice + 1, fechado: true, interpolado };
+        }
+        if (codigo[indice] === "$" && codigo[indice + 1] === "{") {
+            interpolado = true;
+            indice = avancarExpressaoTemplate(codigo, indice + 2, profundidade);
+            continue;
+        }
+        indice += 1;
+    }
+    return { fim: codigo.length, fechado: false, interpolado };
+}
+function literalEhReferenciaEstatica(codigo, inicio, fim, templateLiteral) {
+    const conteudo = codigo.slice(inicio + 1, Math.max(inicio + 1, fim - 1));
+    if (templateLiteral && conteudo.includes("${")) {
+        return false;
+    }
+    const prefixo = codigo.slice(Math.max(0, inicio - 4_096), inicio);
+    const inicioLinha = prefixo.lastIndexOf("\n") + 1;
+    const prefixoLinha = prefixo.slice(inicioLinha);
+    return /\bstyleUrls\s*:\s*\[[^\]]*$/u.test(prefixo)
+        || /\b(?:import|require)\s*\(\s*$/u.test(prefixoLinha)
+        || /^\s*import\s*$/u.test(prefixoLinha)
+        || /\b(?:import|export)\b[^;]*\bfrom\s*$/u.test(prefixo)
+        || /\b(?:templateUrl|styleUrl)\s*:\s*$/u.test(prefixoLinha)
+        || /^\s*@import\s+(?:url\(\s*)?$/u.test(prefixoLinha)
+        || /^\s*#include\s*$/u.test(prefixoLinha)
+        || /\b(?:require|include)(?:_once)?\s*\(?\s*$/u.test(prefixoLinha)
+        || /\b(?:include|include_str|include_bytes)!\s*\(\s*$/u.test(prefixoLinha)
+        || /^\s*#\[\s*path\s*=\s*$/u.test(prefixoLinha);
+}
+/** Remove comentarios/docstrings sem alterar offsets ou caminhos em imports reais. */
 function removerComentariosDependencias(codigo) {
     const saida = [...codigo];
     let indice = 0;
@@ -44,23 +279,19 @@ function removerComentariosDependencias(codigo) {
         }
         if (atual === "`") {
             const inicio = indice;
-            indice += 1;
-            while (indice < codigo.length) {
-                if (codigo[indice] === "\\") {
-                    indice += 2;
-                    continue;
-                }
-                if (codigo[indice] === "`") {
-                    indice += 1;
-                    break;
-                }
-                indice += 1;
+            const resultado = avancarTemplateLiteral(codigo, inicio);
+            indice = resultado.fim;
+            if (!resultado.fechado
+                || resultado.interpolado
+                || !literalEhReferenciaEstatica(codigo, inicio, indice, true)) {
+                mascararIntervalo(codigo, saida, inicio, indice);
             }
-            mascararIntervalo(codigo, saida, inicio, indice);
             continue;
         }
         if (atual === "'" || atual === '"') {
+            const inicio = indice;
             const delimitador = atual;
+            let fechado = false;
             indice += 1;
             while (indice < codigo.length) {
                 if (codigo[indice] === "\\") {
@@ -69,10 +300,14 @@ function removerComentariosDependencias(codigo) {
                 }
                 if (codigo[indice] === delimitador) {
                     indice += 1;
+                    fechado = true;
                     break;
                 }
                 indice += 1;
             }
+            if (!fechado || !literalEhReferenciaEstatica(codigo, inicio, indice, false)) {
+                mascararIntervalo(codigo, saida, inicio, indice);
+            }
             continue;
         }
         if (atual === "/" && proximo === "/") {
@@ -92,7 +327,8 @@ function removerComentariosDependencias(codigo) {
         if (atual === "#") {
             const inicioLinha = codigo.lastIndexOf("\n", indice - 1) + 1;
             const prefixoLinha = codigo.slice(inicioLinha, indice);
-            if (/^\s*$/u.test(prefixoLinha) && codigo.slice(indice).startsWith("#include")) {
+            if (/^\s*$/u.test(prefixoLinha)
+                && (codigo.slice(indice).startsWith("#include") || codigo.slice(indice).startsWith("#[path"))) {
                 indice += 1;
                 continue;
             }
@@ -106,8 +342,10 @@ function removerComentariosDependencias(codigo) {
     }
     return saida.join("");
 }
-function referenciaTypescriptLocal(referencia) {
-    return referencia.startsWith(".") || referencia.startsWith("@/");
+function referenciaTypescriptLocal(referencia, aliases) {
+    return referencia.startsWith(".")
+        || referencia.startsWith("@/")
+        || referenciaCorrespondeAliasTypeScript(referencia, aliases);
 }
 function adicionarImportacoesPython(codigo, referencias) {
     const adicionarModulo = (modulo) => {
@@ -133,24 +371,67 @@ function adicionarImportacoesPython(codigo, referencias) {
         }
     }
 }
-export function extrairReferenciasLocaisDrift(codigo) {
+function adicionarReferenciasRust(codigo, referencias) {
+    const padraoModulo = /(?:^\s*#\[\s*path\s*=\s*["'`]([^"'`\r\n]+)["'`]\s*\]\s*(?:\r?\n\s*)?)?^\s*(?:(?:pub(?:\([^)]*\))?)\s+)?mod\s+([A-Za-z_][A-Za-z0-9_]*)\s*;/gmu;
+    for (const ocorrencia of codigo.matchAll(padraoModulo)) {
+        const caminhoExplicito = ocorrencia[1]?.trim();
+        const modulo = ocorrencia[2]?.trim();
+        if (caminhoExplicito) {
+            const seguro = !path.posix.isAbsolute(caminhoExplicito)
+                && !path.win32.isAbsolute(caminhoExplicito)
+                && !caminhoExplicito.includes(":");
+            referencias.add(`${PREFIXO_REFERENCIA_RUST_CAMINHO}${seguro ? caminhoExplicito : "nao_resolvida"}`);
+        }
+        else if (modulo) {
+            referencias.add(`${PREFIXO_REFERENCIA_RUST_MODULO}${modulo}`);
+        }
+    }
+    for (const ocorrencia of codigo.matchAll(/\b(?:include|include_str|include_bytes)!\s*\(\s*["'`]([^"'`\r\n]+)["'`]\s*\)/gu)) {
+        const referencia = ocorrencia[1]?.trim();
+        if (referencia && !referencia.includes(":")) {
+            referencias.add(referencia);
+        }
+    }
+}
+export function extrairReferenciasLocaisDrift(codigo, opcoes = {}) {
     const referencias = new Set();
     const codigoExecutavel = removerComentariosDependencias(codigo);
+    const aliases = opcoes.contexto && opcoes.arquivoOrigem
+        ? carregarConfiguracaoAliasesTypeScript(opcoes.contexto, opcoes.arquivoOrigem)
+        : undefined;
+    let encontrouReferenciaNaoRelativa = false;
+    const adicionarReferenciaTypescript = (referenciaBruta) => {
+        const referencia = referenciaBruta?.trim();
+        if (!referencia) {
+            return;
+        }
+        if (referenciaTypescriptLocal(referencia, aliases)) {
+            referencias.add(referencia);
+        }
+        else if (!referencia.startsWith(".") && aliases?.incompleta) {
+            encontrouReferenciaNaoRelativa = true;
+        }
+    };
     const padroesTypescript = [
         /^\s*(?:import|export)\s+(?:type\s+)?(?:[A-Za-z_$][\w$]*\s*,\s*)?\{[^}]*\}\s+from\s+["'`]([^"'`\r\n]+)["'`]/gmu,
         /^\s*(?:import|export)\s+(?:type\s+)?(?:[^;"'`\r\n]*?\s+from\s+)?["'`]([^"'`\r\n]+)["'`]/gmu,
         /\b(?:import|require)\s*\(\s*["'`]([^"'`\r\n]+)["'`]\s*\)/gu,
-        /\b(?:templateUrl|styleUrls?)\s*:\s*(?:\[\s*)?["'`]([^"'`\r\n]+)["'`]/gu,
+        /\b(?:templateUrl|styleUrl)\s*:\s*["'`]([^"'`\r\n]+)["'`]/gu,
         /^\s*@import\s+(?:url\(\s*)?["'`]([^"'`\r\n]+)["'`]/gmu,
     ];
     for (const padrao of padroesTypescript) {
         for (const ocorrencia of codigoExecutavel.matchAll(padrao)) {
-            const referencia = ocorrencia[1]?.trim();
-            if (referencia && referenciaTypescriptLocal(referencia)) {
-                referencias.add(referencia);
-            }
+            adicionarReferenciaTypescript(ocorrencia[1]);
+        }
+    }
+    for (const ocorrencia of codigoExecutavel.matchAll(/\bstyleUrls\s*:\s*\[([^\]]*)\]/gu)) {
+        for (const estilo of (ocorrencia[1] ?? "").matchAll(/["'`]([^"'`\r\n]+)["'`]/gu)) {
+            adicionarReferenciaTypescript(estilo[1]);
         }
     }
+    if (encontrouReferenciaNaoRelativa) {
+        referencias.add(REFERENCIA_ALIAS_CONFIG_INCOMPLETA);
+    }
     for (const ocorrencia of codigoExecutavel.matchAll(/^\s*#include\s+["']([^"'\r\n]+)["']/gmu)) {
         const referencia = ocorrencia[1]?.trim();
         if (referencia && !referencia.includes(":")) {
@@ -167,6 +448,7 @@ export function extrairReferenciasLocaisDrift(codigo) {
         }
     }
     adicionarImportacoesPython(codigoExecutavel, referencias);
+    adicionarReferenciasRust(codigoExecutavel, referencias);
     return [...referencias];
 }
 export function raizesCodigoLogicasDrift(contexto) {
@@ -188,20 +470,61 @@ function adicionarVariantesArquivo(candidatos, base, extensoesPermitidas) {
             candidatos.set(chave, absoluto);
         }
     };
-    adicionar(base);
-    if ([".js", ".jsx", ".mjs", ".cjs"].includes(extensao)) {
+    const substituicoesNodeNext = {
+        ".js": [".ts", ".tsx", ".d.ts", ".js", ".jsx"],
+        ".jsx": [".tsx", ".jsx"],
+        ".mjs": [".mts", ".d.mts", ".mjs"],
+        ".cjs": [".cts", ".d.cts", ".cjs"],
+    };
+    const substituicoes = substituicoesNodeNext[extensao];
+    if (substituicoes) {
         const semExtensao = base.slice(0, -extensao.length);
-        for (const alternativa of [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]) {
+        for (const alternativa of substituicoes) {
             adicionar(`${semExtensao}${alternativa}`);
         }
+        return;
     }
-    else if (!extensaoConhecida) {
+    adicionar(base);
+    if (!extensaoConhecida) {
         for (const alternativa of extensoesPermitidas) {
             adicionar(`${base}${alternativa}`);
             adicionar(path.join(base, `index${alternativa}`));
         }
     }
 }
+function adicionarCandidatosAliasTypeScript(candidatos, contexto, arquivoOrigem, referencia) {
+    const configuracao = carregarConfiguracaoAliasesTypeScript(contexto, arquivoOrigem);
+    const regrasCorrespondentes = configuracao.regras
+        .map((regra) => ({ regra, captura: capturarAliasTypeScript(regra.padrao, referencia) }))
+        .filter((item) => item.captura !== undefined)
+        .sort((a, b) => {
+        const especificidadeA = a.regra.padrao.replace("*", "").length;
+        const especificidadeB = b.regra.padrao.replace("*", "").length;
+        return especificidadeB - especificidadeA;
+    });
+    const melhorPadrao = regrasCorrespondentes[0]?.regra.padrao;
+    if (!melhorPadrao) {
+        return false;
+    }
+    for (const { regra, captura } of regrasCorrespondentes.filter((item) => item.regra.padrao === melhorPadrao)) {
+        for (const alvo of regra.alvos) {
+            adicionarVariantesArquivo(candidatos, path.resolve(regra.base, alvo.replace("*", captura)), EXTENSOES_TYPESCRIPT_DEPENDENCIA);
+        }
+    }
+    return true;
+}
+function adicionarCandidatosModuloRust(candidatos, arquivoOrigem, modulo) {
+    const nomeArquivo = path.basename(arquivoOrigem, path.extname(arquivoOrigem));
+    const baseModulo = ["lib", "main", "mod"].includes(nomeArquivo)
+        ? path.dirname(arquivoOrigem)
+        : path.join(path.dirname(arquivoOrigem), nomeArquivo);
+    for (const candidato of [
+        path.join(baseModulo, `${modulo}.rs`),
+        path.join(baseModulo, modulo, "mod.rs"),
+    ]) {
+        candidatos.set(chaveCaminho(candidato), path.resolve(candidato));
+    }
+}
 function candidatosModuloPython(contexto, arquivoOrigem, moduloDeclarado) {
     const candidatos = new Map();
     const correspondencia = /^(\.*)(.*)$/u.exec(moduloDeclarado);
@@ -239,13 +562,37 @@ function candidatosModuloPython(contexto, arquivoOrigem, moduloDeclarado) {
     return [...candidatos.values()];
 }
 export function candidatosReferenciaLocalDrift(contexto, arquivoOrigem, referencia) {
+    if (referencia === REFERENCIA_ALIAS_CONFIG_INCOMPLETA) {
+        return [];
+    }
     if (referencia.startsWith(PREFIXO_REFERENCIA_PYTHON)) {
         if (path.extname(arquivoOrigem).toLowerCase() !== ".py") {
             return [];
         }
         return candidatosModuloPython(contexto, arquivoOrigem, referencia.slice(PREFIXO_REFERENCIA_PYTHON.length));
     }
+    if (referencia.startsWith(PREFIXO_REFERENCIA_RUST_MODULO)) {
+        if (path.extname(arquivoOrigem).toLowerCase() !== ".rs") {
+            return [];
+        }
+        const candidatos = new Map();
+        adicionarCandidatosModuloRust(candidatos, arquivoOrigem, referencia.slice(PREFIXO_REFERENCIA_RUST_MODULO.length));
+        return [...candidatos.values()];
+    }
+    if (referencia.startsWith(PREFIXO_REFERENCIA_RUST_CAMINHO)) {
+        if (path.extname(arquivoOrigem).toLowerCase() !== ".rs") {
+            return [];
+        }
+        const declarado = referencia.slice(PREFIXO_REFERENCIA_RUST_CAMINHO.length);
+        if (path.isAbsolute(declarado) || path.win32.isAbsolute(declarado) || declarado.includes(":")) {
+            return [];
+        }
+        return [path.resolve(path.dirname(arquivoOrigem), declarado)];
+    }
     const candidatos = new Map();
+    if (adicionarCandidatosAliasTypeScript(candidatos, contexto, arquivoOrigem, referencia)) {
+        return [...candidatos.values()];
+    }
     if (referencia.startsWith("@/")) {
         const relativoAlias = referencia.slice(2);
         const raizes = raizesCodigoLogicasDrift(contexto).sort((a, b) => {

package/dist/driftOrcamento.d.ts

@@ -36,12 +36,6 @@ export interface DiagnosticoOrcamentoArquivo {
     limite_aviso_linhas: number;
     limite_bloqueio_linhas: number;
 }
-/**
- * Leitor limitado a um conjunto de arquivos previamente catalogado.
- *
- * Quando fornecido, o gate de orcamento nao faz fallback para o filesystem:
- * um caminho fora do leitor e simplesmente ignorado nesta etapa.
- */
 export interface LeitorArquivosOrcamento {
     contem(caminho: string): boolean;
     lerTexto(caminho: string): Promise<string>;

package/dist/driftOrcamento.js

@@ -11,8 +11,9 @@ export const LIMITE_BLOQUEIO_LINHAS_CONTRATO_SEMA = 500;
 export const LIMITE_AVISO_LINHAS_ORCAMENTO_SEMANTICO = LIMITE_AVISO_LINHAS_CODIGO_GOVERNADO;
 export const LIMITE_BLOQUEIO_LINHAS_ORCAMENTO_SEMANTICO = LIMITE_BLOQUEIO_LINHAS_CODIGO_GOVERNADO;
 export async function workspaceExigeCabecalhoCodigoGovernado(baseProjeto, modoEstrito) {
-    if (!modoEstrito)
+    if (!modoEstrito) {
         return false;
+    }
     try {
         return (await lstat(path.resolve(baseProjeto, "AGENTS.md"))).isFile();
     }

package/dist/execucoesExternas.js

@@ -1,7 +1,6 @@
-// SEMA-GOVERNED
-// M?dulo: sema.produto.orcamento_semantico
-// Contrato: contratos/sema/orcamento_semantico.sema
-// Descri??o: detec??o de comandos externos usados por doctor, testes gerados e runners opcionais.
+// SEMA-GOVERNED: sema.produto.cli_toolchain_local
+// Contrato: contratos/sema/cli_toolchain_local.sema
+// Descrição: detecção de comandos externos usados por doctor, testes gerados e runners opcionais.
 import { spawnSync } from "node:child_process";
 import { createRequire } from "node:module";
 const requireRuntimeCli = createRequire(import.meta.url);
@@ -16,14 +15,29 @@ function resolverImportadorNodeOpcional(especificador) {
 export const TSX_IMPORTADOR_CLI = resolverImportadorNodeOpcional("tsx");
 export const TSX_EXECUTOR_CLI = resolverImportadorNodeOpcional("tsx/cli");
 const TIMEOUT_CHECAGEM_COMANDO_MS = 5_000;
+const disponibilidadeComandosNoProcesso = new Map();
 export function comandoDisponivel(comando, argumentos = ["--version"]) {
+    const chaveSondagem = JSON.stringify({
+        comando,
+        argumentos,
+        cwd: process.cwd(),
+        path: process.env.PATH ?? "",
+        pathExt: process.env.PATHEXT ?? "",
+        comSpec: process.env.COMSPEC ?? "",
+    });
+    const resultadoMemorizado = disponibilidadeComandosNoProcesso.get(chaveSondagem);
+    if (resultadoMemorizado !== undefined) {
+        return resultadoMemorizado;
+    }
     const execucao = spawnSync(comando, argumentos, {
         stdio: "ignore",
         shell: process.platform === "win32",
         timeout: TIMEOUT_CHECAGEM_COMANDO_MS,
         windowsHide: true,
     });
-    return !execucao.error && execucao.signal === null && (execucao.status ?? 1) === 0;
+    const disponivel = !execucao.error && execucao.signal === null && (execucao.status ?? 1) === 0;
+    disponibilidadeComandosNoProcesso.set(chaveSondagem, disponivel);
+    return disponivel;
 }
 export function resolverExecucaoPython() {
     if (comandoDisponivel("python")) {

package/dist/geracaoCore.js

@@ -1,7 +1,5 @@
-// SEMA-GOVERNED
-// M?dulo: sema.produto.orcamento_semantico
-// Contrato: contratos/sema/orcamento_semantico.sema
-// Descri??o: normaliza??o de gera??o, escrita estruturada e execu??o de testes gerados por alvo.
+// SEMA-GOVERNED: sema.produto.geradores_nativos
+// Descricao: normaliza geracao, escrita estruturada e execucao de testes gerados por alvo.
 import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { formatarDiagnosticos } from "@sema/nucleo";
@@ -301,7 +299,7 @@ export function executarTestesGerados(alvo, baseSaida, arquivos, silencioso = fa
                 saidaErro: "Nao foi possivel localizar o runner tsx junto da CLI para executar testes TypeScript.",
             };
         }
-        const execucao = spawnSync("node", [TSX_EXECUTOR_CLI, arquivoTeste], {
+        const execucao = spawnSync(process.execPath, [TSX_EXECUTOR_CLI, arquivoTeste], {
             stdio: silencioso ? "pipe" : "inherit",
             cwd: baseSaida,
             encoding: silencioso ? "utf8" : undefined,
@@ -321,7 +319,7 @@ export function executarTestesGerados(alvo, baseSaida, arquivos, silencioso = fa
             }
             return { codigoSaida: 0, quantidadeTestes, saidaPadrao: "", saidaErro: "" };
         }
-        const execucao = spawnSync("node", ["--test", path.join(baseSaida, arquivoTeste)], {
+        const execucao = spawnSync(process.execPath, ["--test", path.join(baseSaida, arquivoTeste)], {
             stdio: silencioso ? "pipe" : "inherit",
             encoding: silencioso ? "utf8" : undefined,
         });