@semacode/cli 1.5.48 → 1.5.53

package/dist/billing/index.d.ts

@@ -1,74 +1,17 @@
-/**
- * Billing integration - CLI reports consumption back to MCP
- * Based on contract: mcp_cli_billing_integration.sema
- */
-export interface ConsumoOperacao {
-    id: string;
-    sessao_mcp: string;
-    ferramenta: string;
-    comando_cli: string;
-    semas_estimado: number;
-    semas_real: number;
-    complexidade: "baixa" | "media" | "alta" | "critica";
-    linhas_contrato: number;
-    operacoes_realizadas: string[];
-    timestamp_inicio: string;
-    timestamp_fim: string;
-    status: "sucesso" | "erro" | "timeout";
-}
-export interface ReporteConsumoInput {
-    sessao_mcp: string;
-    ferramenta: string;
-    comando_cli: string;
-    semas_real: number;
-    complexidade: "baixa" | "media" | "alta" | "critica";
-    linhas_contrato: number;
-    operacoes_realizadas: string[];
-    timestamp_inicio: string;
-    timestamp_fim: string;
-    status: "sucesso" | "erro" | "timeout";
-}
-export interface ReporteConsumoOutput {
-    consumo: ConsumoOperacao;
-    ajuste_billing: boolean;
-}
 export interface PreflightCliOutput {
     comando: "preflight";
     surface: "local_cli";
     autorizado: boolean;
     decisao: "use_cli_local" | "blocked";
-    creditos: "ok" | "blocked";
     filesystem: "local_available";
-    origemCobranca: "control_plane";
+    origemCobranca: "local_only";
     operationCode: string;
     toolName: string;
-    requestedSemas: number | null;
-    chargedSemas: number | null;
-    remainingSemas: number | null;
-    infiniteSemas: boolean;
-    tokenPrefix: string;
-    tokenExposto: false;
-    mcpSyncPermitido: false;
     erro?: string;
 }
 export declare function executarPreflightCli(params: {
     comandoCli: string;
     args?: string[];
-    token?: string;
-    controlPlaneUrl?: string;
-    supabaseAnonKey?: string;
     projectId?: string | null;
 }): Promise<PreflightCliOutput>;
 export declare function comandoPreflightCli(args: string[], json: boolean): Promise<number>;
-export declare function calcularConsumoReal(operacoes: string[], linhasContrato: number, complexidade: "baixa" | "media" | "alta" | "critica"): number;
-export declare function determinarComplexidade(linhas: number, aninhamento: number): "baixa" | "media" | "alta" | "critica";
-export declare function gerarRelatorioConsumo(input: Omit<ReporteConsumoInput, "timestamp_fim"> & {
-    timestamp_inicio: string;
-}, operacoesRealizadas: string[], linhasContrato: number, sucesso: boolean): ReporteConsumoOutput;
-export declare function executarComReporte<T>(sessaoMcp: string | undefined, ferramenta: string, comando: string, operacoes: string[], fn: () => Promise<T>): Promise<{
-    resultado: T;
-    relatorio: ReporteConsumoOutput | null;
-}>;
-export declare function exportarConsumoJson(relatorio: ReporteConsumoOutput): string;
-export declare function reportarConsumo(input: ReporteConsumoInput): ReporteConsumoOutput;
-export declare function reportarConsumoCli(input: ReporteConsumoInput): ReporteConsumoOutput;

package/dist/billing/index.js

@@ -1,17 +1,6 @@
 // SEMA-GOVERNED: sema.governanca_ia_contexto
-// Descricao: codigo governado pelo Sema; consulte contratos/sema/governanca_ia_contexto.sema antes de editar.
-/**
- * Billing integration - CLI reports consumption back to MCP
- * Based on contract: mcp_cli_billing_integration.sema
- */
-import { createHash, randomUUID } from "node:crypto";
+// Descricao: preflight local-only da CLI publica.
 import { obterOpcao, obterPosicionais, possuiFlag } from "../cliArgs.js";
-const CLI_TOKEN_ENV_VAR = "SEMA_CLI_AUTH_TOKEN";
-const MCP_TOKEN_ENV_VAR = "SEMA_MCP_AUTH_TOKEN";
-const CLI_CONTROL_PLANE_ENV_VAR = "SEMA_CLI_CONTROL_PLANE_URL";
-const CLI_SUPABASE_ANON_KEY_ENV_VAR = "SEMA_CLI_SUPABASE_ANON_KEY";
-const CLI_CONTROL_PLANE_PADRAO = "https://xsbyxiocqyakqxgmtpmp.supabase.co";
-const CLI_SUPABASE_ANON_KEY_PADRAO = "sb_publishable_J_f7L9Xqq9kAo0ltDafuaA_Mid4vVNS";
 const OPERATION_CODE_BY_CLI_COMMAND = {
     resumo: "tool.sema_resumo",
     validar: "tool.sema_validar",
@@ -19,7 +8,6 @@ const OPERATION_CODE_BY_CLI_COMMAND = {
     inspecionar: "tool.sema_inspecionar",
     drift: "drift.module",
     impacto: "default.operation",
-    sync: "sync.contracts",
     verificar: "verify.full",
 };
 function normalizarComandoCli(comandoCli) {
@@ -38,138 +26,30 @@ function resolverOperationCodeCli(comandoCli, args) {
 function resolverToolNameCli(comandoCli) {
     return `sema_cli_${normalizarComandoCli(comandoCli).replace(/[^a-z0-9_]+/g, "_")}`;
 }
-function hashTokenSha256(token) {
-    return createHash("sha256").update(token, "utf8").digest("hex");
-}
-function tokenPrefixoSeguro(token) {
-    return token.slice(0, Math.min(14, token.length));
-}
-function resultadoPreflightBloqueado(params) {
-    return {
-        comando: "preflight",
-        surface: "local_cli",
-        autorizado: false,
-        decisao: "blocked",
-        creditos: "blocked",
-        filesystem: "local_available",
-        origemCobranca: "control_plane",
-        operationCode: params.operationCode,
-        toolName: params.toolName,
-        requestedSemas: null,
-        chargedSemas: null,
-        remainingSemas: null,
-        infiniteSemas: false,
-        tokenPrefix: params.tokenPrefix,
-        tokenExposto: false,
-        mcpSyncPermitido: false,
-        erro: params.erro,
-    };
-}
-function numeroOuNulo(valor) {
-    return typeof valor === "number" && Number.isFinite(valor) ? valor : null;
-}
 export async function executarPreflightCli(params) {
     const args = params.args ?? [];
     const comandoCli = params.comandoCli || "default";
     const operationCode = resolverOperationCodeCli(comandoCli, args);
     const toolName = resolverToolNameCli(comandoCli);
-    const token = (params.token ?? process.env[CLI_TOKEN_ENV_VAR] ?? process.env[MCP_TOKEN_ENV_VAR] ?? "").trim();
-    const tokenPrefix = tokenPrefixoSeguro(token);
-    if (!token) {
-        return resultadoPreflightBloqueado({
-            comandoCli,
-            operationCode,
-            toolName,
-            tokenPrefix,
-            erro: `Instale a chave Sema local com sema mcp-instalar-chave --stdin. Env vars aceitas: ${CLI_TOKEN_ENV_VAR} ou ${MCP_TOKEN_ENV_VAR}.`,
-        });
-    }
-    if (!/^sema_(?:mcp|cli)_[A-Za-z0-9_-]{16,}$/.test(token)) {
-        return resultadoPreflightBloqueado({
-            comandoCli,
-            operationCode,
-            toolName,
-            tokenPrefix,
-            erro: "Chave Sema local invalida.",
-        });
-    }
-    const controlPlaneUrl = (params.controlPlaneUrl ?? process.env[CLI_CONTROL_PLANE_ENV_VAR] ?? CLI_CONTROL_PLANE_PADRAO).replace(/\/+$/, "");
-    const supabaseAnonKey = params.supabaseAnonKey ?? process.env[CLI_SUPABASE_ANON_KEY_ENV_VAR] ?? CLI_SUPABASE_ANON_KEY_PADRAO;
-    const tokenHash = hashTokenSha256(token);
-    const idempotencyKey = `cli:${normalizarComandoCli(comandoCli)}:${Date.now()}:${randomUUID()}`;
-    try {
-        const resposta = await fetch(`${controlPlaneUrl}/rest/v1/rpc/sema_consume_mcp_token_operation`, {
-            method: "POST",
-            headers: {
-                apikey: supabaseAnonKey,
-                authorization: `Bearer ${supabaseAnonKey}`,
-                "content-type": "application/json",
-            },
-            body: JSON.stringify({
-                p_token_hash: tokenHash,
-                p_organization_id: null,
-                p_project_id: params.projectId ?? null,
-                p_operation_code: operationCode,
-                p_tool_name: toolName,
-                p_request_summary: `CLI local preflight: ${comandoCli}`,
-                p_idempotency_key: idempotencyKey,
-                p_metadata: {
-                    source: "sema_cli_local",
-                    surface: "local_cli",
-                    command: comandoCli,
-                    mcpSyncPermitido: false,
-                },
-            }),
-        });
-        if (!resposta.ok) {
-            const texto = await resposta.text();
-            return resultadoPreflightBloqueado({
-                comandoCli,
-                operationCode,
-                toolName,
-                tokenPrefix,
-                erro: texto || `Control plane retornou HTTP ${resposta.status}.`,
-            });
-        }
-        const payload = await resposta.json();
-        const autorizado = payload?.authorized === true;
-        return {
-            comando: "preflight",
-            surface: "local_cli",
-            autorizado,
-            decisao: autorizado ? "use_cli_local" : "blocked",
-            creditos: autorizado ? "ok" : "blocked",
-            filesystem: "local_available",
-            origemCobranca: "control_plane",
-            operationCode,
-            toolName,
-            requestedSemas: numeroOuNulo(payload?.requestedSemas),
-            chargedSemas: numeroOuNulo(payload?.chargedSemas),
-            remainingSemas: numeroOuNulo(payload?.remainingSemas ?? payload?.remainingBalance),
-            infiniteSemas: payload?.infiniteSemas === true,
-            tokenPrefix,
-            tokenExposto: false,
-            mcpSyncPermitido: false,
-            erro: autorizado ? undefined : "Control plane nao autorizou o uso da CLI.",
-        };
-    }
-    catch (erro) {
-        return resultadoPreflightBloqueado({
-            comandoCli,
-            operationCode,
-            toolName,
-            tokenPrefix,
-            erro: erro instanceof Error ? erro.message : String(erro),
-        });
-    }
+    void params.projectId;
+    return {
+        comando: "preflight",
+        surface: "local_cli",
+        autorizado: true,
+        decisao: "use_cli_local",
+        filesystem: "local_available",
+        origemCobranca: "local_only",
+        operationCode,
+        toolName,
+    };
 }
 export async function comandoPreflightCli(args, json) {
     if (possuiFlag(args, "--help") || possuiFlag(args, "-h")) {
         console.log([
-            "Uso: sema preflight [comando] [--operation-code <codigo>] [--project-id <uuid>] [--json]",
+            "Usage: sema preflight [command] [--operation-code <code>] [--json]",
             "",
-            "Consulta o control plane de SEMAS antes de a IA usar a CLI local.",
-            "Se retornar decisao=blocked, pare. Nao chame MCP remoto para ler workspace local.",
+            "Checks the local CLI surface. Public Sema is local-only and does not call external services.",
+            "If this command returns decisao=use_cli_local, continue with local CLI commands.",
         ].join("\n"));
         return 0;
     }
@@ -179,157 +59,16 @@ export async function comandoPreflightCli(args, json) {
         comandoCli,
         args,
         projectId: obterOpcao(args, "--project-id") ?? null,
-        controlPlaneUrl: obterOpcao(args, "--control-plane-url"),
-        supabaseAnonKey: obterOpcao(args, "--supabase-anon-key"),
     });
     if (json) {
         console.log(JSON.stringify(resultado, null, 2));
     }
     else if (resultado.autorizado) {
-        console.log(`Sema CLI autorizada: ${resultado.operationCode}. Decisao: ${resultado.decisao}.`);
+        console.log(`Sema CLI authorized: ${resultado.operationCode}. Decision: ${resultado.decisao}.`);
     }
     else {
-        console.error(`Sema CLI bloqueada: ${resultado.erro}`);
+        console.error(`Sema CLI blocked: ${resultado.erro}`);
     }
     return resultado.autorizado ? 0 : 1;
 }
-// Calcula consumo real baseado nas operações realizadas
-export function calcularConsumoReal(operacoes, linhasContrato, complexidade) {
-    const custoBase = {
-        parse: 1,
-        lexer: 1,
-        validar: 2,
-        semantico: 3,
-        gerar_ir: 2,
-        inspecionar: 2,
-        drift: 5,
-        impacto: 5,
-        sync: 5,
-        verificar: 10,
-    };
-    let total = 0;
-    for (const op of operacoes) {
-        total += custoBase[op] || 1;
-    }
-    // Multiplicador por complexidade
-    const multiplicador = {
-        baixa: 1,
-        media: 1.5,
-        alta: 2,
-        critica: 3,
-    };
-    // Fator de tamanho
-    const fatorTamanho = Math.max(1, Math.log10(linhasContrato + 1));
-    return Math.ceil(total * multiplicador[complexidade] * fatorTamanho);
-}
-// Determina complexidade baseada no contrato
-export function determinarComplexidade(linhas, aninhamento) {
-    if (linhas > 500 || aninhamento > 5)
-        return "critica";
-    if (linhas > 200 || aninhamento > 3)
-        return "alta";
-    if (linhas > 50 || aninhamento > 1)
-        return "media";
-    return "baixa";
-}
-// Gera relatório de consumo para ser retornado ao MCP
-export function gerarRelatorioConsumo(input, operacoesRealizadas, linhasContrato, sucesso) {
-    const timestampFim = new Date().toISOString();
-    const complexidade = determinarComplexidade(linhasContrato, 0);
-    const semasReal = calcularConsumoReal(operacoesRealizadas, linhasContrato, complexidade);
-    const consumo = {
-        id: randomUUID(),
-        sessao_mcp: input.sessao_mcp,
-        ferramenta: input.ferramenta,
-        comando_cli: input.comando_cli,
-        semas_estimado: input.semas_real, // valor que MCP estimou
-        semas_real: semasReal,
-        complexidade,
-        linhas_contrato: linhasContrato,
-        operacoes_realizadas: operacoesRealizadas,
-        timestamp_inicio: input.timestamp_inicio,
-        timestamp_fim: timestampFim,
-        status: sucesso ? "sucesso" : "erro",
-    };
-    return {
-        consumo,
-        ajuste_billing: semasReal !== input.semas_real,
-    };
-}
-// Wrapper para executar comando com reporte de consumo
-export async function executarComReporte(sessaoMcp, ferramenta, comando, operacoes, fn) {
-    const timestampInicio = new Date().toISOString();
-    const linhasEstimadas = 100; // estimativa default
-    try {
-        const resultado = await fn();
-        // Se não tem sessão MCP, não reporta
-        if (!sessaoMcp) {
-            return { resultado, relatorio: null };
-        }
-        const complexidade = determinarComplexidade(linhasEstimadas, 0);
-        const relatorio = gerarRelatorioConsumo({
-            sessao_mcp: sessaoMcp,
-            ferramenta,
-            comando_cli: comando,
-            semas_real: 2, // estimativa MCP default
-            complexidade,
-            linhas_contrato: linhasEstimadas,
-            operacoes_realizadas: operacoes,
-            status: "sucesso",
-            timestamp_inicio: timestampInicio,
-        }, operacoes, linhasEstimadas, true);
-        return { resultado, relatorio };
-    }
-    catch (erro) {
-        const complexidadeErro = determinarComplexidade(linhasEstimadas, 0);
-        const relatorio = sessaoMcp
-            ? gerarRelatorioConsumo({
-                sessao_mcp: sessaoMcp,
-                ferramenta,
-                comando_cli: comando,
-                semas_real: 2,
-                complexidade: complexidadeErro,
-                linhas_contrato: linhasEstimadas,
-                operacoes_realizadas: operacoes,
-                status: "erro",
-                timestamp_inicio: timestampInicio,
-            }, operacoes, linhasEstimadas, false)
-            : null;
-        throw { erro, relatorio };
-    }
-}
-// Exporta consumo no formato JSON para stdout (MCP lê)
-export function exportarConsumoJson(relatorio) {
-    return JSON.stringify({
-        __sema_consumo: true,
-        ...relatorio,
-    });
-}
-// Funcao principal reportarConsumo (vinculo contrato: cli.src.billing.reportarConsumo)
-export function reportarConsumo(input) {
-    const complexidade = determinarComplexidade(input.linhas_contrato, 0);
-    const semasReal = calcularConsumoReal(input.operacoes_realizadas, input.linhas_contrato, complexidade);
-    const consumo = {
-        id: randomUUID(),
-        sessao_mcp: input.sessao_mcp,
-        ferramenta: input.ferramenta,
-        comando_cli: input.comando_cli,
-        semas_estimado: input.semas_real,
-        semas_real: semasReal,
-        complexidade,
-        linhas_contrato: input.linhas_contrato,
-        operacoes_realizadas: input.operacoes_realizadas,
-        timestamp_inicio: input.timestamp_inicio,
-        timestamp_fim: input.timestamp_fim,
-        status: input.status,
-    };
-    return {
-        consumo,
-        ajuste_billing: semasReal !== input.semas_real,
-    };
-}
-// Alias publico para vinculo do contrato: cli.src.billing.reportarConsumoCli
-export function reportarConsumoCli(input) {
-    return reportarConsumo(input);
-}
 //# sourceMappingURL=index.js.map

package/dist/cliArgs.js

@@ -40,9 +40,6 @@ export const OPCOES_COM_VALOR = new Set([
     "--doc-lida",
     "--texto",
     "--texto-arquivo",
-    "--endpoint",
-    "--control-plane-url",
-    "--supabase-anon-key",
     "--operation-code",
     "--project-id",
     "--comando",

package/dist/comandos.js

@@ -1,107 +1,9 @@
-// SEMA-GOVERNED: sema.produto.mcp_client_bridge
-// Descricao: dispatcher de comandos da CLI; consulte contratos/sema/mcp_client_bridge.sema antes de editar.
-/**
- * Registro de comandos da CLI Sema.
- *
- * Cada comando é um módulo separado com seu contrato .sema.
- * Este arquivo é o dispatcher — o index.ts só importa daqui.
- *
- * NOVOS COMANDOS: adicione aqui, nunca no index.ts.
- * O index.ts é só `principal()` com um switch fino que delega pra cá.
- */
-import { configurarBridgeLocal, obterTokenMcpAmbiente, } from "./bridge.js";
-import { gerarPacoteContextoChat, } from "./contexto.js";
-import { comandoInit } from "./init/index.js";
+// SEMA-GOVERNED: sema.governanca_ia_contexto
+// Descricao: dispatcher de comandos publicos da CLI local; consulte contratos/sema/governanca_ia_contexto.sema antes de editar.
 import { comandoDev } from "./dev/index.js";
+import { comandoInit } from "./init/index.js";
 import { comandoSyncPrisma } from "./sync/index.js";
-import { comandoSemaChat } from "./semaChatCommand.js";
-// ---------------------------------------------------------------------------
-// Handlers dos novos comandos (modulares, com contrato .sema)
-// ---------------------------------------------------------------------------
-async function comandoMcpClient(_posicionais, _args, emJson) {
-    const resultado = {
-        comando: "mcp-client",
-        status: "BLOQUEADO",
-        sessao: { status: "BLOQUEADO" },
-        perfisAplicaveis: [],
-        proximoPasso: "sema --version; se existir, sema preflight resumo --json; se decisao=use_cli_local, usar comandos locais da CLI",
-        erro: "mcp_client_desativado_cli_local: CLI local nao envia workspace ao MCP remoto. Se sema --version falhar, pare. A IA nao acessa o painel Sema: peca ao humano para instalar a CLI pelo painel. Use sema resumo, docs-impacto, inspecionar, drift, impacto, validar e finalizar-mudanca pela CLI local. Web/chat sem workspace usa MCP remoto e sema_sync inline.",
-    };
-    if (emJson) {
-        console.log(JSON.stringify(resultado, null, 2));
-        return resultado.erro ? 1 : 0;
-    }
-    console.log(`mcp-client local: ${resultado.sessao.status}`);
-    console.log(`Perfis: ${resultado.perfisAplicaveis.join(", ") || "nenhum"}`);
-    console.log(`Próximo passo: ${resultado.proximoPasso}`);
-    if (resultado.erro) {
-        console.error(`Erro: ${resultado.erro}`);
-    }
-    return resultado.erro ? 1 : 0;
-}
-async function comandoBridgeConfig(_posicionais, args, emJson) {
-    const { token, endpoint } = obterTokenMcpAmbiente();
-    if (!token) {
-        console.error("Token MCP nao configurado. Use 'sema mcp-instalar-chave --stdin' primeiro.");
-        return 1;
-    }
-    const resultado = await configurarBridgeLocal({
-        endpointMcp: endpoint,
-        token,
-        persistir: true,
-    });
-    if (emJson) {
-        console.log(JSON.stringify(resultado, null, 2));
-        return resultado.configurado ? 0 : 1;
-    }
-    if (resultado.configurado) {
-        console.log(`Bridge configurada: ${resultado.status}`);
-        console.log(`Endpoint: ${endpoint}`);
-    }
-    else {
-        console.error(`Falha: ${resultado.erro ?? "desconhecido"}`);
-    }
-    return resultado.configurado ? 0 : 1;
-}
-async function comandoContextoChat(posicionais, args, emJson) {
-    const contratos = posicionais;
-    const formato = emJson ? "inline" : "ambos";
-    if (contratos.length === 0) {
-        console.error("Uso: sema contexto-chat <contrato1.sema> [contrato2.sema] ...");
-        return 1;
-    }
-    const entrada = {
-        contratos,
-        formatoSaida: formato,
-    };
-    const resultado = await gerarPacoteContextoChat(entrada);
-    if (emJson) {
-        console.log(JSON.stringify({
-            comando: "contexto-chat",
-            pacote: resultado.pacote,
-            prontoParaChat: resultado.prontoParaChat,
-            tamanhoBytes: resultado.tamanhoBytes,
-            arquivosGerados: resultado.arquivosGerados,
-        }, null, 2));
-        return resultado.prontoParaChat ? 0 : 1;
-    }
-    if (resultado.inlineTexto) {
-        console.log(resultado.inlineTexto);
-    }
-    if (resultado.arquivosGerados.length > 0) {
-        console.error(`\nArquivos gerados: ${resultado.arquivosGerados.join(", ")}`);
-    }
-    if (!resultado.prontoParaChat) {
-        console.error(`\n⚠️ Pacote excede o limite de ${resultado.tamanhoBytes} bytes para chat inline.`);
-        console.error("Use --json e copie o arquivo gerado.");
-        return 1;
-    }
-    return 0;
-}
-// ---------------------------------------------------------------------------
-// Guarda de governança
-// ---------------------------------------------------------------------------
-async function comandoInitHandler(posicionais, args, emJson) {
+async function comandoInitHandler(posicionais, args, _emJson) {
     try {
         await comandoInit([...posicionais, ...args]);
         return 0;
@@ -110,7 +12,7 @@ async function comandoInitHandler(posicionais, args, emJson) {
         return 1;
     }
 }
-async function comandoDevHandler(posicionais, args, emJson) {
+async function comandoDevHandler(posicionais, args, _emJson) {
     try {
         await comandoDev([...posicionais, ...args]);
         return 0;
@@ -119,7 +21,7 @@ async function comandoDevHandler(posicionais, args, emJson) {
         return 1;
     }
 }
-async function comandoSyncPrismaHandler(posicionais, args, emJson) {
+async function comandoSyncPrismaHandler(posicionais, args, _emJson) {
     try {
         await comandoSyncPrisma([...posicionais, ...args]);
         return 0;
@@ -128,26 +30,15 @@ async function comandoSyncPrismaHandler(posicionais, args, emJson) {
         return 1;
     }
 }
-async function comandoSemaChatHandler(posicionais, args, emJson) {
-    return comandoSemaChat(posicionais, args, emJson);
-}
 async function comandoGuard(posicionais, _args, emJson) {
     const { ativarGuarda, desativarGuarda, statusGuarda } = await import("./guard.js");
     const baseProjeto = process.cwd();
     const subcomando = posicionais[0] ?? "status";
-    let resultado;
-    switch (subcomando) {
-        case "on":
-            resultado = await ativarGuarda(baseProjeto);
-            break;
-        case "off":
-            resultado = await desativarGuarda(baseProjeto);
-            break;
-        case "status":
-        default:
-            resultado = await statusGuarda(baseProjeto);
-            break;
-    }
+    const resultado = subcomando === "on"
+        ? await ativarGuarda(baseProjeto)
+        : subcomando === "off"
+            ? await desativarGuarda(baseProjeto)
+            : await statusGuarda(baseProjeto);
     if (emJson) {
         console.log(JSON.stringify(resultado, null, 2));
     }
@@ -163,17 +54,10 @@ async function comandoGuard(posicionais, _args, emJson) {
     }
     return resultado.sucesso ? 0 : 1;
 }
-// ---------------------------------------------------------------------------
-// Registro
-// ---------------------------------------------------------------------------
 export const REGISTRO_COMANDOS = {
-    "mcp-client": comandoMcpClient,
-    "bridge-config": comandoBridgeConfig,
-    "contexto-chat": comandoContextoChat,
-    "guard": comandoGuard,
-    "init": comandoInitHandler,
-    "dev": comandoDevHandler,
-    "sync": comandoSyncPrismaHandler,
-    "chat": comandoSemaChatHandler,
+    guard: comandoGuard,
+    init: comandoInitHandler,
+    dev: comandoDevHandler,
+    sync: comandoSyncPrismaHandler,
 };
 //# sourceMappingURL=comandos.js.map

package/dist/contexto.d.ts

@@ -1,12 +1,3 @@
-/**
- * Gerador de pacote de contexto para chats web (ChatGPT, Lovable, etc.).
- *
- * A CLI lê contratos e código selecionado do disco local e gera um pacote
- * compacto que o usuário cola no chat. Isso elimina o sync manual — a CLI
- * faz o trabalho pesado de I/O local e entrega um payload pronto.
- *
- * Contrato: contratos/sema/mcp_client_bridge.sema — task gerar_pacote_contexto_para_chat
- */
 export type FormatoSaidaContexto = "inline" | "arquivo" | "ambos";
 export interface PacoteContextoChat {
     contratos: string[];