@semacode/cli 3.13.1 → 4.1.0

package/dist/index.part06.js

@@ -17,6 +17,8 @@ import { descobrirDocsIa, normalizarModoResumo, normalizarTamanhoResumo, renderi
 import { gerarResumoProjetoIa } from "./index.part04.js";
 import { carregarContextoModuloIa, gerarArquivosResumoModuloIa } from "./index.part03.js";
 import { coletarResumoSemanticoModulo, renderizarResumoModuloMarkdown, renderizarResumoModuloTexto } from "./index.part02.js";
+import { criarContextPackAPartirDoResumo } from "./contextPack.js";
+import { selecionarIndiceContexto } from "./indexPack.js";
 export async function comandoCompilar(entrada, alvo, saida, estrutura, framework, cwd = process.cwd()) {
     const incompatibilidade = validarCompatibilidadeFramework(alvo, framework);
     if (incompatibilidade) {
@@ -200,8 +202,8 @@ export async function comandoAjudaIa() {
     ]));
     console.log("");
     console.log(renderizarSecaoAscii("Capacidade de IA", [
-        "fraca: `sema resumo <arquivo> --micro --drift none --json` usa stdout compacto sem inventar evidência de implementação",
-        "média: `sema resumo <arquivo> --curto --drift none --json` + `sema drift <arquivo> --cache fresh --json`",
+        "fraca: `sema resumo <arquivo> --micro --drift none --json` já devolve o context-pack compacto sem inventar evidência de implementação",
+        "média: `sema resumo <arquivo> --curto --drift none --json` já compacta o resumo; use `sema drift <arquivo> --cache fresh --json` quando precisar de evidência do código",
         "forte: `sema contexto-ia <arquivo.sema> --saida <diretorio> --json` materializa o pacote completo",
     ]));
     console.log("");
@@ -212,7 +214,7 @@ export async function comandoAjudaIa() {
         "Use `sema interativo pipelines --json` para jogos, simulações e híbridos 3D, 2D, retro, texto, XR ou headless.",
         "Use `sema sync-codex` para regenerar o contexto governado do Codex na raiz.",
         "Use `sema instalar-exemplos` para materializar `exemplos/` oficiais sem sobrescrever arquivos locais.",
-        "Use `sema resumo <arquivo> --micro --para onboarding --drift none --json` para IA fraca; o resumo contratual vem no stdout e campos derivados ficam não avaliados.",
+        "Use `sema resumo <arquivo> --micro --para onboarding --drift none --json` para IA fraca; o context-pack é automático e campos derivados ficam não avaliados.",
         "Se `sema resumo` ou outro gate estourar timeout local, aumente o timeout e tente de novo; timeout do agente nao e falha do Sema.",
         "Use `sema prompt-curto <arquivo> --curto --para mudanca` para colar contexto em modelo gratuito.",
         "Use `sema prompt-ia`, `sema prompt-ia-ui`, `sema prompt-ia-react` e `sema prompt-ia-sema-primeiro` conforme a tarefa.",
@@ -287,6 +289,9 @@ export async function comandoExemplosPromptIa() {
 export async function comandoResumo(entrada, args, emJson) {
     const tamanho = normalizarTamanhoResumo(args);
     const modo = normalizarModoResumo(obterOpcao(args, "--para"));
+    const pedido = obterOpcao(args, "--pedido");
+    const somentePacote = possuiFlag(args, "--somente-pacote");
+    const pedidoExplícito = obterOpcao(args, "--pedido")?.trim();
     const pastaSaida = obterOpcao(args, "--saida");
     const escreverNaRaiz = possuiFlag(args, "--raiz");
     const alvo = entrada ? path.resolve(process.cwd(), entrada) : process.cwd();
@@ -299,6 +304,20 @@ export async function comandoResumo(entrada, args, emJson) {
         const texto = tamanho === "medio"
             ? renderizarResumoModuloMarkdown(resumoSemantico, modo, guiaPorCapacidade)
             : renderizarResumoModuloTexto(resumoSemantico, tamanho, modo);
+        const contextPack = criarContextPackAPartirDoResumo({
+            resumo: resumoSemantico,
+            pedido: pedidoExplícito,
+            modo,
+            tamanho,
+            analiseDrift: {
+                modo: contexto.drift.modo,
+                executada: contexto.drift.executada,
+                sucesso: contexto.drift.sucesso,
+                aviso: contexto.drift.aviso,
+            },
+            guiaPorCapacidade,
+            texto,
+        });
         let pastaResumo;
         let artefatosCompactos = [];
         if (pastaSaida) {
@@ -308,6 +327,14 @@ export async function comandoResumo(entrada, args, emJson) {
             artefatosCompactos = gerado.artefatosCompactos;
         }
         if (emJson) {
+            if (somentePacote && contextPack) {
+                console.log(JSON.stringify(contextPack, null, 2));
+                return contexto.drift.sucesso === false ? 1 : 0;
+            }
+            if (somentePacote) {
+                console.log(JSON.stringify(contextPack, null, 2));
+                return contexto.drift.sucesso === false ? 1 : 0;
+            }
             console.log(JSON.stringify({
                 comando: "resumo",
                 modo,
@@ -325,9 +352,7 @@ export async function comandoResumo(entrada, args, emJson) {
                     avisos: analiseDrift.avisos,
                     cache: contexto.drift.drift?.escopo_aplicado.cache ?? null,
                 },
-                guiaPorCapacidade,
-                resumo: resumoSemantico,
-                texto,
+                contextPack,
             }, null, 2));
             return contexto.drift.sucesso === false ? 1 : 0;
         }
@@ -335,17 +360,25 @@ export async function comandoResumo(entrada, args, emJson) {
             console.log(`Resumo IA-first gerado em ${pastaResumo}`);
             console.log("");
         }
-        console.log(texto);
+        console.log(JSON.stringify(contextPack, null, 2));
         return contexto.drift.sucesso === false ? 1 : 0;
     }
     const resumoProjeto = await gerarResumoProjetoIa(alvo, pastaSaida, escreverNaRaiz, analiseDrift);
-    const arquivoResumo = tamanho === "micro"
-        ? "SEMA_BRIEF.micro.txt"
-        : tamanho === "curto"
-            ? "SEMA_BRIEF.curto.txt"
-            : "SEMA_BRIEF.md";
-    const texto = await readFile(path.join(resumoProjeto.pastaSaida, arquivoResumo), "utf8");
+    const indexTexto = await readFile(path.join(resumoProjeto.pastaSaida, "SEMA_INDEX.json"), "utf8").catch(() => "");
+    const indexPack = selecionarIndiceContexto({
+        modulos: resumoProjeto.modulos,
+        request: pedidoExplícito ?? `resumo:${tamanho}`,
+        baseProject: resumoProjeto.baseProjeto,
+        generatedAt: resumoProjeto.geradoEm,
+        mode: modo,
+        drift: resumoProjeto.analiseDrift.modo,
+        sourceIndexChars: indexTexto.length,
+    });
     if (emJson) {
+        if (somentePacote) {
+            console.log(JSON.stringify(indexPack, null, 2));
+            return resumoProjeto.analiseDrift.sucesso === false ? 1 : 0;
+        }
         console.log(JSON.stringify({
             comando: "resumo",
             modo,
@@ -358,15 +391,13 @@ export async function comandoResumo(entrada, args, emJson) {
                 ...resumoProjeto.analiseDrift,
                 avisos: analiseDrift.avisos,
             },
-            guiaPorCapacidade: resumoProjeto.guiaPorCapacidade,
-            modulos: resumoProjeto.modulos,
-            texto,
+            indexPack,
         }, null, 2));
         return resumoProjeto.analiseDrift.sucesso === false ? 1 : 0;
     }
     console.log(`Resumo IA-first do projeto gerado em ${resumoProjeto.pastaSaida}`);
     console.log("");
-    console.log(texto);
+    console.log(JSON.stringify(indexPack, null, 2));
     return resumoProjeto.analiseDrift.sucesso === false ? 1 : 0;
 }
 //# sourceMappingURL=index.part06.js.map

package/dist/index.part07.d.ts

@@ -8,7 +8,7 @@ export declare function alvosSuportadosPelaStack(fontesLegado: string[] | undefi
 export declare function avisoEscopoStackVerificacao(fontesLegado: string[] | undefined, alvosEfetivos: AlvoGeracao[]): string | undefined;
 import { type ResumoModuloVerificacao } from './geracaoCore.js';
 export declare function comandoPromptCurto(entrada: string | undefined, args: string[], emJson: boolean): Promise<number>;
-export declare function comandoContextoIa(arquivo: string, pastaSaida: string | undefined, emJson: boolean): Promise<number>;
+export declare function comandoContextoIa(arquivo: string, pastaSaida: string | undefined, emJson: boolean, args?: string[]): Promise<number>;
 export declare function comandoTestar(arquivo: string, alvo: AlvoGeracao, saida: string, estrutura: EstruturaSaida, framework: FrameworkGeracao): Promise<number>;
 export declare function imprimirResumoVerificacao(resumos: ResumoModuloVerificacao[]): void;
 export declare function comandoVerificar(entrada: string | undefined, baseSaida: string, cwd?: string, opcoes?: OpcoesVerificar): Promise<number>;

package/dist/index.part07.js

@@ -51,8 +51,10 @@ export function avisoEscopoStackVerificacao(fontesLegado, alvosEfetivos) {
     }
     return `Alvos fora da stack detectada (${(fontesLegado ?? []).join(", ")}): ${foraDaStack.join(", ")}. Considere reduzir "alvos" no sema.config.json, remover "fontesLegado" auto-declaradas ou usar --alvo unico.`;
 }
+import { criarAgentContextPack } from './agentContextPack.js';
+import { criarEntrypointPack } from './entrypointPack.js';
 import { escreverArquivos, formatarAvisoArtefatosGeradosAcimaDoLimite, } from './fsGovernado.js';
-import { obterOpcao } from './cliArgs.js';
+import { obterOpcao, possuiFlag } from './cliArgs.js';
 import { avaliarDependenciasVerificacao, imprimirFalhaDependenciasVerificacao } from './doctorCommand.js';
 import { aplicarEstruturaSaida, executarTestesGerados, executarTestesParaVerificacao, gerarArquivosPorAlvo, garantirIr, nomeSubpastaModulo, resolverConfiguracaoVerificacaoPorAlvo, validarCompatibilidadeFramework, } from './geracaoCore.js';
 import { normalizarModoResumo, normalizarTamanhoResumo } from "./index.part01.js";
@@ -137,8 +139,20 @@ ${contextoProjeto.trim()}
     console.log(prompt);
     return 0;
 }
-export async function comandoContextoIa(arquivo, pastaSaida, emJson) {
+export async function comandoContextoIa(arquivo, pastaSaida, emJson, args = []) {
     const resultado = await gerarContextoIa(arquivo, pastaSaida);
+    const capacidadeValor = obterOpcao(args, "--capacidade") ?? "media";
+    const capacidade = capacidadeValor === "fraca" || capacidadeValor === "forte" ? capacidadeValor : "media";
+    if (possuiFlag(args, "--pacote")) {
+        const agentContextPack = criarAgentContextPack(resultado.guiaPorCapacidade);
+        const pacote = criarEntrypointPack({
+            agentContextPack,
+            capacity: capacidade,
+            rawAgentContextChars: JSON.stringify(agentContextPack).length,
+        });
+        console.log(JSON.stringify(pacote, null, 2));
+        return resultado.sucesso ? 0 : 1;
+    }
     if (emJson) {
         console.log(JSON.stringify(resultado, null, 2));
         return 0;

package/dist/index.part08.js

@@ -175,7 +175,7 @@ export async function principal() {
             codigoSaida = await comandoExemplosPromptIa();
             break;
         case "contexto-ia":
-            codigoSaida = await comandoContextoIa(posicionais[0] ?? "", obterOpcao(resto, "--saida"), possuiFlag(resto, "--json"));
+            codigoSaida = await comandoContextoIa(posicionais[0] ?? "", obterOpcao(resto, "--saida"), possuiFlag(resto, "--json"), resto);
             break;
         default:
             throw erroComandoDesconhecido();

package/dist/indexPack.d.ts

@@ -0,0 +1,54 @@
+import type { ResumoSemanticoModuloIa } from "./index.part01.js";
+type EntradaIndice = Pick<ResumoSemanticoModuloIa, "arquivo" | "modulo" | "faz" | "tarefasPrincipais" | "regrasCriticas" | "efeitos" | "riscosPrincipais" | "lacunas" | "arquivosProvaveis" | "checksSugeridos" | "testesMinimos" | "arquivosProvaveisEditar">;
+export type IndexPack = {
+    schema: "sema.ai.index-pack/v1";
+    selection: "deterministic_weighted_match" | "deterministic_summary_projection";
+    request: string;
+    source: {
+        command: "resumo-projeto";
+        baseProject: string;
+        generatedAt: string | null;
+        totalModules: number;
+        mode: string;
+        drift: string;
+    };
+    matches: Array<{
+        module: string;
+        contract: string;
+        relevanceScore: number;
+        purpose: string;
+        relevantTasks: string[];
+        criticalRules: string[];
+        effects: string[];
+        risks: string[];
+        knownGaps: string[];
+        likelyFiles: string[];
+        filesToEdit: string[];
+        requiredChecks: string[];
+        minimumTests: string[];
+    }>;
+    authority: {
+        semaRemainsAuthority: true;
+        rawIndexForwarded: false;
+        executionRequiresFreshValidation: true;
+        omitted: string[];
+    };
+    telemetry: {
+        packChars: number;
+        packEstimatedTokens: number;
+        estimateMethod: "chars_div_4";
+        sourceIndexEstimatedTokens: number;
+        reductionPercent: number;
+        selectedFields: string[];
+    };
+};
+export declare function selecionarIndiceContexto(input: {
+    modulos: readonly EntradaIndice[];
+    request: string;
+    baseProject: string;
+    generatedAt?: string | null;
+    mode?: string;
+    drift?: string;
+    sourceIndexChars?: number;
+}): IndexPack;
+export {};

package/dist/indexPack.js

@@ -0,0 +1,146 @@
+function texto(value) {
+    return typeof value === "string" ? value : "";
+}
+function lista(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === "string" && item.length > 0)
+        : [];
+}
+function tokens(value) {
+    return value
+        .toLocaleLowerCase("pt-BR")
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .split(/[^a-z0-9_]+/)
+        .filter((item) => item.length >= 3);
+}
+function correspondeToken(campo, pedido) {
+    return tokens(campo).some((token) => [...pedido].some((alvo) => token.startsWith(alvo) || alvo.startsWith(token)));
+}
+function selecionarValores(values, requestTokens, maximo, projetarResumoInteiro) {
+    if (projetarResumoInteiro)
+        return values.slice(0, maximo);
+    return values
+        .map((value, index) => ({
+        value,
+        index,
+        score: correspondeToken(value, requestTokens) ? 1 : 0,
+    }))
+        .sort((a, b) => b.score - a.score || a.index - b.index)
+        .filter((item) => item.score > 0)
+        .slice(0, maximo)
+        .map((item) => item.value);
+}
+function estimarTokens(chars) {
+    return Math.ceil(chars / 4);
+}
+function compactarModulo(modulo, requestTokens, projetarResumoInteiro) {
+    const tarefas = lista(modulo.tarefasPrincipais);
+    const regras = lista(modulo.regrasCriticas);
+    const efeitos = lista(modulo.efeitos);
+    const riscos = lista(modulo.riscosPrincipais);
+    const lacunas = lista(modulo.lacunas);
+    const arquivos = lista(modulo.arquivosProvaveis);
+    const arquivosEditar = lista(modulo.arquivosProvaveisEditar);
+    const checks = lista(modulo.checksSugeridos);
+    const testes = lista(modulo.testesMinimos);
+    const camposComPeso = [
+        [texto(modulo.modulo), [texto(modulo.modulo)], 5],
+        [texto(modulo.faz), [texto(modulo.faz)], 3],
+        ["tarefas", tarefas, 4],
+        ["regras", regras, 2],
+        ["efeitos", efeitos, 1],
+        ["riscos", riscos, 2],
+        ["lacunas", lacunas, 1],
+        ["arquivos", [...arquivos, ...arquivosEditar], 1],
+    ];
+    const relevanceScore = projetarResumoInteiro ? 1 : camposComPeso.reduce((total, [, values, weight]) => total + values.reduce((subtotal, value) => subtotal + (correspondeToken(value, requestTokens) ? weight : 0), 0), 0);
+    if (!projetarResumoInteiro && relevanceScore === 0)
+        return null;
+    return {
+        module: texto(modulo.modulo),
+        contract: texto(modulo.arquivo),
+        relevanceScore,
+        purpose: texto(modulo.faz),
+        relevantTasks: selecionarValores(tarefas, requestTokens, 8, projetarResumoInteiro),
+        criticalRules: selecionarValores(regras, requestTokens, 8, projetarResumoInteiro),
+        effects: selecionarValores(efeitos, requestTokens, 6, projetarResumoInteiro),
+        risks: selecionarValores(riscos, requestTokens, 6, projetarResumoInteiro),
+        knownGaps: selecionarValores(lacunas, requestTokens, 6, projetarResumoInteiro),
+        likelyFiles: selecionarValores(arquivos, requestTokens, 8, projetarResumoInteiro),
+        filesToEdit: selecionarValores(arquivosEditar, requestTokens, 8, projetarResumoInteiro),
+        requiredChecks: selecionarValores(checks, requestTokens, 6, projetarResumoInteiro),
+        minimumTests: selecionarValores(testes, requestTokens, 6, projetarResumoInteiro),
+    };
+}
+export function selecionarIndiceContexto(input) {
+    const request = input.request.trim();
+    const requestTokens = new Set(tokens(request));
+    const projetarResumoInteiro = request.length === 0 || request.startsWith("resumo:");
+    const selection = projetarResumoInteiro
+        ? "deterministic_summary_projection"
+        : "deterministic_weighted_match";
+    const matches = input.modulos
+        .map((modulo) => compactarModulo(modulo, requestTokens, projetarResumoInteiro))
+        .filter((item) => item !== null)
+        .sort((a, b) => b.relevanceScore - a.relevanceScore || a.module.localeCompare(b.module, "pt-BR"))
+        .slice(0, projetarResumoInteiro ? input.modulos.length : 8);
+    const base = {
+        schema: "sema.ai.index-pack/v1",
+        selection,
+        request,
+        source: {
+            command: "resumo-projeto",
+            baseProject: input.baseProject,
+            generatedAt: input.generatedAt ?? null,
+            totalModules: input.modulos.length,
+            mode: input.mode ?? "mudanca",
+            drift: input.drift ?? "none",
+        },
+        matches,
+        authority: {
+            semaRemainsAuthority: true,
+            rawIndexForwarded: false,
+            executionRequiresFreshValidation: true,
+            omitted: [
+                "SEMA_INDEX.json completo",
+                "agentContextPack duplicado",
+                "módulos e campos fora do orçamento da projeção compacta",
+                "catálogo e arquivos não relacionados ao pedido",
+            ],
+        },
+    };
+    const packChars = JSON.stringify(base).length;
+    const sourceIndexChars = input.sourceIndexChars ?? 0;
+    const sourceTokens = estimarTokens(sourceIndexChars);
+    return {
+        ...base,
+        telemetry: {
+            packChars,
+            packEstimatedTokens: estimarTokens(packChars),
+            estimateMethod: "chars_div_4",
+            sourceIndexEstimatedTokens: sourceTokens,
+            reductionPercent: sourceIndexChars === 0 ? 0 : Math.round((1 - packChars / sourceIndexChars) * 10000) / 100,
+            selectedFields: [
+                "request",
+                "source.baseProject",
+                "source.generatedAt",
+                "matches.module",
+                "matches.contract",
+                "matches.relevanceScore",
+                "matches.purpose",
+                "matches.relevantTasks",
+                "matches.criticalRules",
+                "matches.effects",
+                "matches.risks",
+                "matches.knownGaps",
+                "matches.likelyFiles",
+                "matches.filesToEdit",
+                "matches.requiredChecks",
+                "matches.minimumTests",
+                "authority",
+            ],
+        },
+    };
+}
+//# sourceMappingURL=indexPack.js.map