@semacode/cli 2.3.0 → 2.3.1

package/dist/driftEscopoReferencias.js

@@ -0,0 +1,265 @@
+// 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";
+const EXTENSOES_DEPENDENCIA_CODIGO = [
+    ".ts", ".tsx", ".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",
+];
+const PREFIXO_REFERENCIA_PYTHON = "python:";
+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));
+}
+function mascararIntervalo(codigo, saida, inicio, fim) {
+    for (let indice = inicio; indice < fim; indice += 1) {
+        if (codigo[indice] !== "\n" && codigo[indice] !== "\r") {
+            saida[indice] = " ";
+        }
+    }
+}
+/** Remove comentarios/docstrings sem alterar offsets ou caminhos em literais de imports reais. */
+function removerComentariosDependencias(codigo) {
+    const saida = [...codigo];
+    let indice = 0;
+    while (indice < codigo.length) {
+        const atual = codigo[indice];
+        const proximo = codigo[indice + 1];
+        if ((atual === "'" || atual === '"') && codigo.slice(indice, indice + 3) === atual.repeat(3)) {
+            const delimitador = atual.repeat(3);
+            const fimEncontrado = codigo.indexOf(delimitador, indice + 3);
+            const fim = fimEncontrado < 0 ? codigo.length : fimEncontrado + 3;
+            mascararIntervalo(codigo, saida, indice, fim);
+            indice = fim;
+            continue;
+        }
+        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;
+            }
+            mascararIntervalo(codigo, saida, inicio, indice);
+            continue;
+        }
+        if (atual === "'" || atual === '"') {
+            const delimitador = atual;
+            indice += 1;
+            while (indice < codigo.length) {
+                if (codigo[indice] === "\\") {
+                    indice += 2;
+                    continue;
+                }
+                if (codigo[indice] === delimitador) {
+                    indice += 1;
+                    break;
+                }
+                indice += 1;
+            }
+            continue;
+        }
+        if (atual === "/" && proximo === "/") {
+            const fimLinha = codigo.indexOf("\n", indice + 2);
+            const fim = fimLinha < 0 ? codigo.length : fimLinha;
+            mascararIntervalo(codigo, saida, indice, fim);
+            indice = fim;
+            continue;
+        }
+        if (atual === "/" && proximo === "*") {
+            const fimEncontrado = codigo.indexOf("*/", indice + 2);
+            const fim = fimEncontrado < 0 ? codigo.length : fimEncontrado + 2;
+            mascararIntervalo(codigo, saida, indice, fim);
+            indice = fim;
+            continue;
+        }
+        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")) {
+                indice += 1;
+                continue;
+            }
+            const fimLinha = codigo.indexOf("\n", indice + 1);
+            const fim = fimLinha < 0 ? codigo.length : fimLinha;
+            mascararIntervalo(codigo, saida, indice, fim);
+            indice = fim;
+            continue;
+        }
+        indice += 1;
+    }
+    return saida.join("");
+}
+function referenciaTypescriptLocal(referencia) {
+    return referencia.startsWith(".") || referencia.startsWith("@/");
+}
+function adicionarImportacoesPython(codigo, referencias) {
+    const adicionarModulo = (modulo) => {
+        const normalizado = modulo.trim();
+        if (/^\.*[A-Za-z_][A-Za-z0-9_.]*$/u.test(normalizado)) {
+            referencias.add(`${PREFIXO_REFERENCIA_PYTHON}${normalizado}`);
+        }
+    };
+    for (const ocorrencia of codigo.matchAll(/^\s*import\s+([^\r\n;]+)$/gmu)) {
+        for (const item of (ocorrencia[1] ?? "").split(",")) {
+            adicionarModulo(item.trim().split(/\s+as\s+/iu)[0] ?? "");
+        }
+    }
+    for (const ocorrencia of codigo.matchAll(/^\s*from\s+(\.*[A-Za-z_][A-Za-z0-9_.]*|\.+)\s+import\s+([^\r\n;]+)$/gmu)) {
+        const modulo = ocorrencia[1] ?? "";
+        adicionarModulo(modulo);
+        const importados = (ocorrencia[2] ?? "").replace(/[()\\]/gu, "");
+        for (const item of importados.split(",")) {
+            const nome = item.trim().split(/\s+as\s+/iu)[0] ?? "";
+            if (nome && nome !== "*" && /^[A-Za-z_][A-Za-z0-9_]*$/u.test(nome)) {
+                adicionarModulo(`${modulo}${modulo.endsWith(".") ? "" : "."}${nome}`);
+            }
+        }
+    }
+}
+export function extrairReferenciasLocaisDrift(codigo) {
+    const referencias = new Set();
+    const codigoExecutavel = removerComentariosDependencias(codigo);
+    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,
+        /^\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);
+            }
+        }
+    }
+    for (const ocorrencia of codigoExecutavel.matchAll(/^\s*#include\s+["']([^"'\r\n]+)["']/gmu)) {
+        const referencia = ocorrencia[1]?.trim();
+        if (referencia && !referencia.includes(":")) {
+            referencias.add(referencia);
+        }
+    }
+    for (const ocorrencia of codigoExecutavel.matchAll(/\b(?:require|include)(?:_once)?\s*\(?\s*["']([^"'\r\n]+)["']/gu)) {
+        const referencia = ocorrencia[1]?.trim();
+        const extensao = path.posix.extname(referencia ?? "").toLowerCase();
+        if (referencia
+            && !referencia.includes(":")
+            && (referencia.startsWith(".") || EXTENSOES_DEPENDENCIA_CODIGO.includes(extensao))) {
+            referencias.add(referencia);
+        }
+    }
+    adicionarImportacoesPython(codigoExecutavel, referencias);
+    return [...referencias];
+}
+export function raizesCodigoLogicasDrift(contexto) {
+    const candidatas = contexto.diretoriosCodigo.length > 0
+        ? contexto.diretoriosCodigo
+        : [contexto.baseProjeto];
+    return [...new Map(candidatas
+            .map((raiz) => path.resolve(raiz))
+            .filter((raiz) => caminhoEstaDentro(contexto.baseProjeto, raiz))
+            .map((raiz) => [chaveCaminho(raiz), raiz])).values()];
+}
+function adicionarVariantesArquivo(candidatos, base, extensoesPermitidas) {
+    const extensao = path.extname(base).toLowerCase();
+    const extensaoConhecida = extensoesPermitidas.includes(extensao);
+    const adicionar = (caminho) => {
+        const absoluto = path.resolve(caminho);
+        const chave = chaveCaminho(absoluto);
+        if (!candidatos.has(chave)) {
+            candidatos.set(chave, absoluto);
+        }
+    };
+    adicionar(base);
+    if ([".js", ".jsx", ".mjs", ".cjs"].includes(extensao)) {
+        const semExtensao = base.slice(0, -extensao.length);
+        for (const alternativa of [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]) {
+            adicionar(`${semExtensao}${alternativa}`);
+        }
+    }
+    else if (!extensaoConhecida) {
+        for (const alternativa of extensoesPermitidas) {
+            adicionar(`${base}${alternativa}`);
+            adicionar(path.join(base, `index${alternativa}`));
+        }
+    }
+}
+function candidatosModuloPython(contexto, arquivoOrigem, moduloDeclarado) {
+    const candidatos = new Map();
+    const correspondencia = /^(\.*)(.*)$/u.exec(moduloDeclarado);
+    const prefixoRelativo = correspondencia?.[1] ?? "";
+    const modulo = correspondencia?.[2] ?? "";
+    const segmentos = modulo.split(".").filter(Boolean);
+    const bases = new Map();
+    const adicionarBase = (base, segmentosBase) => {
+        const caminhoModulo = path.resolve(base, ...segmentosBase);
+        bases.set(chaveCaminho(caminhoModulo), caminhoModulo);
+    };
+    if (prefixoRelativo.length > 0) {
+        let baseRelativa = path.dirname(arquivoOrigem);
+        for (let nivel = 1; nivel < prefixoRelativo.length; nivel += 1) {
+            baseRelativa = path.dirname(baseRelativa);
+        }
+        adicionarBase(baseRelativa, segmentos);
+    }
+    else {
+        const raizes = raizesCodigoLogicasDrift(contexto);
+        for (const base of [path.dirname(arquivoOrigem), contexto.baseProjeto, ...raizes]) {
+            adicionarBase(base, segmentos);
+            const nomeBase = path.basename(base).toLowerCase();
+            if (segmentos[0]?.toLowerCase() === nomeBase) {
+                adicionarBase(base, segmentos.slice(1));
+            }
+        }
+    }
+    for (const base of bases.values()) {
+        const arquivoModulo = `${base}.py`;
+        candidatos.set(chaveCaminho(arquivoModulo), arquivoModulo);
+        const inicializador = path.join(base, "__init__.py");
+        candidatos.set(chaveCaminho(inicializador), inicializador);
+    }
+    return [...candidatos.values()];
+}
+export function candidatosReferenciaLocalDrift(contexto, arquivoOrigem, referencia) {
+    if (referencia.startsWith(PREFIXO_REFERENCIA_PYTHON)) {
+        if (path.extname(arquivoOrigem).toLowerCase() !== ".py") {
+            return [];
+        }
+        return candidatosModuloPython(contexto, arquivoOrigem, referencia.slice(PREFIXO_REFERENCIA_PYTHON.length));
+    }
+    const candidatos = new Map();
+    if (referencia.startsWith("@/")) {
+        const relativoAlias = referencia.slice(2);
+        const raizes = raizesCodigoLogicasDrift(contexto).sort((a, b) => {
+            const aContemOrigem = caminhoEstaDentro(a, arquivoOrigem) ? 1 : 0;
+            const bContemOrigem = caminhoEstaDentro(b, arquivoOrigem) ? 1 : 0;
+            return bContemOrigem - aContemOrigem || b.length - a.length || a.localeCompare(b, "pt-BR");
+        });
+        for (const raiz of raizes) {
+            adicionarVariantesArquivo(candidatos, path.resolve(raiz, relativoAlias), EXTENSOES_TYPESCRIPT_DEPENDENCIA);
+        }
+    }
+    else {
+        adicionarVariantesArquivo(candidatos, path.resolve(path.dirname(arquivoOrigem), referencia), EXTENSOES_DEPENDENCIA_CODIGO);
+    }
+    return [...candidatos.values()];
+}
+//# sourceMappingURL=driftEscopoReferencias.js.map

package/dist/driftOrcamento.d.ts

@@ -4,6 +4,7 @@ export declare const LIMITE_AVISO_LINHAS_CONTRATO_SEMA = 300;
 export declare const LIMITE_BLOQUEIO_LINHAS_CONTRATO_SEMA = 500;
 export declare const LIMITE_AVISO_LINHAS_ORCAMENTO_SEMANTICO = 1000;
 export declare const LIMITE_BLOQUEIO_LINHAS_ORCAMENTO_SEMANTICO = 2000;
+export declare function workspaceExigeCabecalhoCodigoGovernado(baseProjeto: string, modoEstrito: boolean): Promise<boolean>;
 export type TipoArquivoOrcamento = "contrato" | "codigo" | "documentacao" | "gerado" | "migracao_historica";
 export type SeveridadeOrcamentoSemantico = "ok" | "aviso" | "erro";
 export type TipoDiagnosticoOrcamento = "contrato_monolitico" | "codigo_monolitico" | "codigo_governado_sem_cabecalho";
@@ -35,6 +36,16 @@ 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>;
+}
 export interface LimitesOrcamentoSemantico {
     aviso: number;
     bloqueio: number;
@@ -76,4 +87,5 @@ export declare function emitirDiagnosticosArquivosOrcamento(opcoes: {
     arquivos: string[];
     baseProjeto?: string;
     exigirCabecalhoCodigoGovernado?: boolean;
+    leitorArquivos?: LeitorArquivosOrcamento;
 }): Promise<DiagnosticoOrcamentoArquivo[]>;

package/dist/driftOrcamento.js

@@ -2,7 +2,7 @@
 // Módulo: sema.produto.orcamento_semantico
 // Contrato: contratos/sema/orcamento_semantico.sema
 // Descrição: centraliza os gates de linhas e cabeçalho Sema para drift, finalização e snapshots.
-import { readFile } from "node:fs/promises";
+import { lstat, readFile } from "node:fs/promises";
 import path from "node:path";
 export const LIMITE_AVISO_LINHAS_CODIGO_GOVERNADO = 1000;
 export const LIMITE_BLOQUEIO_LINHAS_CODIGO_GOVERNADO = 2000;
@@ -10,6 +10,16 @@ export const LIMITE_AVISO_LINHAS_CONTRATO_SEMA = 300;
 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)
+        return false;
+    try {
+        return (await lstat(path.resolve(baseProjeto, "AGENTS.md"))).isFile();
+    }
+    catch {
+        return false;
+    }
+}
 const EXTENSOES_CODIGO_GOVERNAVEL = new Set([
     ".ts",
     ".tsx",
@@ -289,13 +299,19 @@ export async function emitirDiagnosticosArquivosOrcamento(opcoes) {
         const absoluto = path.isAbsolute(arquivoInformado)
             ? arquivoInformado
             : path.resolve(baseProjeto, arquivoInformado);
-        const chave = path.resolve(absoluto);
+        const resolvido = path.resolve(absoluto);
+        const chave = process.platform === "win32" ? resolvido.toLowerCase() : resolvido;
         if (vistos.has(chave)) {
             continue;
         }
         vistos.add(chave);
+        if (opcoes.leitorArquivos && !opcoes.leitorArquivos.contem(absoluto)) {
+            continue;
+        }
         try {
-            const conteudo = await readFile(absoluto, "utf8");
+            const conteudo = opcoes.leitorArquivos
+                ? await opcoes.leitorArquivos.lerTexto(absoluto)
+                : await readFile(absoluto, "utf8");
             const relativo = path.relative(baseProjeto, absoluto).replace(/\\/g, "/") || arquivoInformado.replace(/\\/g, "/");
             diagnosticos.push(...avaliarOrcamentoArquivo({
                 arquivo: relativo,

package/dist/execucoesExternas.js

@@ -1,6 +1,7 @@
-// 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.
+// 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.
 import { spawnSync } from "node:child_process";
 import { createRequire } from "node:module";
 const requireRuntimeCli = createRequire(import.meta.url);
@@ -15,29 +16,14 @@ 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,
     });
-    const disponivel = !execucao.error && execucao.signal === null && (execucao.status ?? 1) === 0;
-    disponibilidadeComandosNoProcesso.set(chaveSondagem, disponivel);
-    return disponivel;
+    return !execucao.error && execucao.signal === null && (execucao.status ?? 1) === 0;
 }
 export function resolverExecucaoPython() {
     if (comandoDisponivel("python")) {