brito-cli 0.0.0-stage → 0.3.2

package/dist/agent/claude-cli.js

@@ -0,0 +1,216 @@
+import { spawn, spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { listAgents } from "./agents.js";
+import { buildSystemPrompt } from "./prompt.js";
+import { skillsIndex } from "../skills/store.js";
+import { MCP_NAME, MCP_PREFIX, APPROVE_TOOL } from "../mcp/server.js";
+import { ui } from "../ui/ui.js";
+import { MODE_ENV, perms } from "../permissions.js";
+import { wireEffort } from "../model.js";
+// Backend alternativo: delega ao `claude` oficial, que autentica com o /login do usuário.
+// O brito nunca lê nem envia o token da assinatura. Grafo, memória e skills chegam ao claude via MCP.
+export function hasClaudeCli() {
+    return spawnSync("claude", ["--version"], { stdio: "ignore" }).status === 0;
+}
+/** Nome das tools do Brito → nome que o claude enxerga. */
+const CLAUDE_TOOL = { read_file: "Read", glob: "Glob", grep: "Grep", write_file: "Write", edit_file: "Edit", bash: "Bash" };
+const claudeToolName = (n) => CLAUDE_TOOL[n] ?? MCP_PREFIX + n;
+/** Agentes do Brito viram subagentes do claude (--agents), no lugar do `delegate`. */
+function claudeAgents() {
+    const out = {};
+    for (const a of listAgents()) {
+        out[a.name] = {
+            description: a.description,
+            prompt: a.prompt,
+            ...(a.tools === "all" ? {} : { tools: a.tools.map(claudeToolName) }),
+            ...(a.model?.includes("haiku") ? { model: "haiku" } : {}),
+        };
+    }
+    return out;
+}
+/**
+ * Acumula um evento do stream-json no TurnRecord que alimenta a reflexão de skills.
+ * Só a thread principal entra: mensagens de subagentes (`parent_tool_use_id`) têm contexto próprio.
+ */
+export function recordStreamEvent(turn, ev, loadedSkills) {
+    if (ev?.parent_tool_use_id)
+        return;
+    if (ev?.type === "assistant") {
+        const rec = [];
+        for (const b of ev.message?.content ?? []) {
+            if (b.type === "text" && b.text)
+                rec.push({ type: "text", text: b.text });
+            else if (b.type === "tool_use") {
+                const name = String(b.name).replace(MCP_PREFIX, "");
+                rec.push({ type: "tool_use", id: b.id, name, input: b.input });
+                if (name === "skill_load" && typeof b.input?.name === "string")
+                    loadedSkills.add(b.input.name);
+            }
+        }
+        if (rec.length)
+            turn.messages.push({ role: "assistant", content: rec });
+    }
+    else if (ev?.type === "user") {
+        const results = (ev.message?.content ?? []).filter((b) => b.type === "tool_result")
+            .map((b) => ({ type: "tool_result", tool_use_id: b.tool_use_id, content: b.content, is_error: !!b.is_error }));
+        if (!results.length)
+            return;
+        turn.messages.push({ role: "user", content: results });
+        turn.toolCalls += results.length;
+        turn.errors += results.filter((r) => r.is_error).length;
+    }
+}
+/**
+ * Config do servidor MCP entregue ao claude. O servidor roda em outro processo: o env leva o socket de aprovação
+ * e o modo de permissão do REPL (vale por turno, pois cada turno sobe um claude novo com esta config).
+ */
+export function mcpConfig(cmd, approvalSock, mode) {
+    // alwaysLoad: sem isso o claude adia as tools do Brito atrás do ToolSearch e o modelo raramente chega ao grafo.
+    return { mcpServers: { [MCP_NAME]: { type: "stdio", command: cmd.command, args: cmd.args, alwaysLoad: true, env: { BRITO_APPROVE_SOCK: approvalSock, [MODE_ENV]: mode } } } };
+}
+export class ClaudeSession {
+    o;
+    id = randomUUID();
+    started = false;
+    usage = { input: 0, output: 0, cacheRead: 0 };
+    model = "claude (assinatura)";
+    /** modelo pedido via `/model` (--model do claude); vazio = padrão da assinatura */
+    requestedModel = "";
+    /** esforço pedido via `/effort` (--effort do claude); vazio = padrão */
+    effort = "";
+    /** prompt da última chamada à API da thread principal = tamanho atual do contexto (como o Hermes) */
+    contextTokens = 0;
+    /** janela real do modelo, informada pelo claude no evento `result` */
+    contextWindow;
+    costUsd = 0;
+    /** transcript do último turno (thread principal), montado do stream-json para a reflexão de skills */
+    lastTurn = null;
+    recentTurns = [];
+    /** skills carregadas via skill_load (que roda no servidor MCP, outro processo) */
+    loadedSkills = new Set();
+    /** último turno em andamento, para o Ctrl+C */
+    child = null;
+    constructor(o) {
+        this.o = o;
+    }
+    reset() { this.id = randomUUID(); this.started = false; this.contextTokens = 0; this.recentTurns = []; }
+    abort() { this.child?.kill("SIGINT"); }
+    args(text) {
+        const { root, approvalSock, stats, mcpCommand } = this.o;
+        const mcp = mcpConfig(mcpCommand, approvalSock, perms.mode);
+        const readOnlyMcp = ["graph_search", "graph_callers", "graph_callees", "graph_impact", "graph_context", "graph_query", "graph_index", "remember", "recall", "skill_load"];
+        const system = buildSystemPrompt(root, stats, skillsIndex(root)) +
+            `\n\n# Nesta sessão\nAs tools do Brito chegam com o prefixo \`${MCP_PREFIX}\` (ex.: ${MCP_PREFIX}graph_context). Use-as como descrito acima. ` +
+            `read_file/grep/glob/edit_file/bash correspondem a Read/Grep/Glob/Edit/Bash, e \`delegate\` corresponde à tool Agent/Task com os subagentes configurados (explore, plan, general e os do projeto).`;
+        const args = [
+            "-p", text,
+            this.started ? "--resume" : "--session-id", this.id,
+            "--output-format", "stream-json", "--verbose",
+            "--append-system-prompt", system,
+            "--mcp-config", JSON.stringify(mcp),
+            "--agents", JSON.stringify(claudeAgents()),
+        ];
+        if (this.requestedModel)
+            args.push("--model", this.requestedModel);
+        const wire = wireEffort(this.effort);
+        if (wire.effort)
+            args.push("--effort", wire.effort);
+        // O modo vale por turno: Shift+Tab no REPL muda o próximo turno.
+        const mode = { manual: "default", auto: "acceptEdits", plan: "plan", bypass: "bypassPermissions" }[perms.mode];
+        args.push("--permission-mode", mode);
+        if (perms.mode !== "bypass") {
+            args.push("--allowedTools", ...readOnlyMcp.map((n) => MCP_PREFIX + n), "--permission-prompt-tool", `${MCP_PREFIX}${APPROVE_TOOL}`);
+        }
+        return args;
+    }
+    /** Roda um turno renderizando o stream-json com a UI do Brito. */
+    send(text) {
+        return new Promise((resolve) => {
+            ui.turnStart();
+            const child = (this.child = spawn("claude", this.args(text), {
+                cwd: this.o.root, stdio: ["ignore", "pipe", "pipe"],
+                // `/reasoning none`: o claude desliga o raciocínio com MAX_THINKING_TOKENS=0 (não há `--effort none`)
+                env: wireEffort(this.effort).thinking ? process.env : { ...process.env, MAX_THINKING_TOKENS: "0" },
+            }));
+            let buf = "", stderr = "", ok = true, interrupted = false;
+            const names = new Map();
+            const turn = { messages: [{ role: "user", content: text }], toolCalls: 0, errors: 0, finished: false };
+            this.lastTurn = turn;
+            this.recentTurns = [...this.recentTurns, turn].slice(-3);
+            const handle = (ev) => {
+                recordStreamEvent(turn, ev, this.loadedSkills);
+                if (ev.type === "assistant") {
+                    for (const b of ev.message?.content ?? []) {
+                        if (b.type === "thinking" && b.thinking && !ev.parent_tool_use_id)
+                            ui.thinking(b.thinking);
+                        else if (b.type === "text" && b.text) {
+                            ui.text(b.text);
+                            ui.textEnd();
+                        }
+                        else if (b.type === "tool_use") {
+                            const name = String(b.name).replace(MCP_PREFIX, "");
+                            names.set(b.id, { name, input: b.input });
+                            ui.toolStart(b.id, name, b.input);
+                        }
+                    }
+                    if (ev.message?.model)
+                        this.model = ev.message.model;
+                    const u = ev.message?.usage;
+                    // Mensagens de subagentes (sidechain) têm contexto próprio: não contam para a barra.
+                    if (u && !ev.parent_tool_use_id)
+                        this.contextTokens = (u.input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0);
+                }
+                else if (ev.type === "user") {
+                    for (const b of ev.message?.content ?? [])
+                        if (b.type === "tool_result")
+                            ui.toolEnd(b.tool_use_id, !!b.is_error);
+                }
+                else if (ev.type === "result") {
+                    this.usage.input += (ev.usage?.input_tokens ?? 0) + (ev.usage?.cache_read_input_tokens ?? 0) + (ev.usage?.cache_creation_input_tokens ?? 0);
+                    this.usage.output += ev.usage?.output_tokens ?? 0;
+                    this.usage.cacheRead += ev.usage?.cache_read_input_tokens ?? 0;
+                    this.costUsd += ev.total_cost_usd ?? 0;
+                    const win = Object.values(ev.modelUsage ?? {}).map((m) => m?.contextWindow).filter((w) => w > 0);
+                    if (win.length)
+                        this.contextWindow = Math.min(...win);
+                    if (ev.is_error) {
+                        ok = false;
+                        ui.error(String(ev.result ?? "erro do claude"));
+                    }
+                }
+            };
+            child.stdout.on("data", (d) => {
+                buf += d.toString();
+                let i;
+                while ((i = buf.indexOf("\n")) >= 0) {
+                    const line = buf.slice(0, i).trim();
+                    buf = buf.slice(i + 1);
+                    if (!line)
+                        continue;
+                    try {
+                        handle(JSON.parse(line));
+                    }
+                    catch { /* linha que não é JSON: ignora */ }
+                }
+            });
+            child.stderr.on("data", (d) => { stderr += d.toString(); });
+            child.on("error", (e) => { ok = false; ui.error(`não consegui executar o claude: ${e.message}`); });
+            child.on("close", (code, signal) => {
+                this.child = null;
+                interrupted = signal === "SIGINT" || code === 130;
+                if (code !== 0 && !interrupted) {
+                    ok = false;
+                    if (stderr.trim())
+                        ui.error(stderr.trim().slice(0, 600));
+                }
+                else if (code === 0)
+                    this.started = true;
+                turn.finished = ok && !interrupted && code === 0;
+                if (interrupted)
+                    ui.warn("⏹ interrompido");
+                ui.turnEnd(ok && !interrupted);
+                resolve(ok);
+            });
+        });
+    }
+}

package/dist/agent/context.js

@@ -0,0 +1,40 @@
+export const estimateTokens = (msgs) => Math.ceil(JSON.stringify(msgs).length / 4);
+const MAX_OLD_RESULT = 1500;
+/** Fase 1 (barata): encurta tool_results antigos, preservando as últimas `keep` mensagens. */
+export function trimOldToolResults(msgs, keep = 8) {
+    return msgs.map((m, i) => {
+        if (i >= msgs.length - keep || typeof m.content === "string")
+            return m;
+        return {
+            ...m,
+            content: m.content.map((b) => {
+                if (b.type === "tool_result" && typeof b.content === "string" && b.content.length > MAX_OLD_RESULT) {
+                    return { ...b, content: b.content.slice(0, 700) + `\n…[${b.content.length - 1400} chars omitidos]…\n` + b.content.slice(-700) };
+                }
+                return b;
+            }),
+        };
+    });
+}
+/** Fase 2: resume o meio da conversa via LLM, mantendo o início e os últimos turnos. */
+export async function summarizeMiddle(client, model, msgs, keepTail = 6) {
+    if (msgs.length <= keepTail + 2)
+        return msgs;
+    let cut = msgs.length - keepTail;
+    // O trecho final precisa começar numa mensagem de usuário "pura" (sem tool_result órfão).
+    while (cut < msgs.length && !(msgs[cut].role === "user" && typeof msgs[cut].content === "string"))
+        cut++;
+    if (cut >= msgs.length)
+        return msgs;
+    const head = msgs.slice(0, 1);
+    const middle = msgs.slice(1, cut);
+    const tail = msgs.slice(cut);
+    const res = await client.messages.create({
+        model,
+        max_tokens: 2000,
+        system: "Resuma a conversa de um agente de programação. Preserve: objetivo, decisões, arquivos/símbolos tocados, erros encontrados, estado atual e próximos passos. Seja denso.",
+        messages: [{ role: "user", content: JSON.stringify(middle).slice(0, 150_000) }],
+    });
+    const summary = res.content.map((b) => (b.type === "text" ? b.text : "")).join("");
+    return [...head, { role: "user", content: `[Resumo da conversa anterior]\n${summary}` }, { role: "assistant", content: "Entendido, continuando a partir do resumo." }, ...tail];
+}

package/dist/agent/loop.js

@@ -0,0 +1,125 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { toApiTools, execTool, isConcurrent } from "../tools/registry.js";
+import { estimateTokens, summarizeMiddle, trimOldToolResults } from "./context.js";
+import { ui } from "../ui/ui.js";
+import { initialModel } from "../model.js";
+export const MODEL = initialModel();
+const COMPACT_AT = Number(process.env.BRITO_COMPACT_TOKENS ?? 120_000);
+export class Agent {
+    system;
+    ctx;
+    opts;
+    client = new Anthropic();
+    messages = [];
+    usage = { input: 0, output: 0, cacheRead: 0, steps: 0 };
+    /** tamanho do contexto na última requisição (alimenta a barra de status) */
+    contextTokens = 0;
+    /** troca em runtime via `/model`; vale a partir da próxima requisição */
+    model;
+    lastTurn = null;
+    /** últimos turnos (o mais novo por último): o anterior dá contexto a correções do usuário */
+    recentTurns = [];
+    maxSteps;
+    log;
+    constructor(system, ctx, opts = {}) {
+        this.system = system;
+        this.ctx = ctx;
+        this.opts = opts;
+        this.model = opts.model ?? MODEL;
+        this.maxSteps = opts.maxSteps ?? 40;
+        this.log = opts.log ?? ((s) => ui.info(s));
+    }
+    /** Roda um turno completo (até não haver mais tool_use) e devolve o texto final. */
+    async send(userText, signal) {
+        try {
+            return await this.run(userText, signal);
+        }
+        catch (e) {
+            if (signal?.aborted) {
+                this.repairAfterAbort();
+                throw new Error("interrompido");
+            }
+            throw e;
+        }
+    }
+    /** Após Ctrl+C, evita deixar um tool_use sem tool_result no histórico (a API recusaria o próximo turno). */
+    repairAfterAbort() {
+        const last = this.messages[this.messages.length - 1];
+        if (last?.role !== "assistant" || typeof last.content === "string")
+            return;
+        const pending = last.content.filter((b) => b.type === "tool_use");
+        if (pending.length)
+            this.messages.push({ role: "user", content: pending.map((u) => ({ type: "tool_result", tool_use_id: u.id, content: "Interrompido pelo usuário.", is_error: true })) });
+    }
+    async run(userText, signal) {
+        const turn = { messages: [], toolCalls: 0, errors: 0, finished: false };
+        this.lastTurn = turn;
+        this.recentTurns = [...this.recentTurns, turn].slice(-3);
+        const push = (m) => { this.messages.push(m); turn.messages.push(m); };
+        push({ role: "user", content: userText });
+        await this.compactIfNeeded();
+        let finalText = "";
+        for (let step = 0; step < this.maxSteps; step++) {
+            if (signal?.aborted)
+                throw new Error("abort");
+            const stream = this.client.messages.stream({
+                model: this.model,
+                max_tokens: 8192,
+                system: [{ type: "text", text: typeof this.system === "function" ? this.system() : this.system, cache_control: { type: "ephemeral" } }],
+                tools: toApiTools(this.opts.tools),
+                messages: this.messages,
+            }, { signal });
+            if (!this.opts.quiet)
+                stream.on("text", (t) => ui.text(t));
+            const msg = await stream.finalMessage();
+            this.contextTokens = msg.usage.input_tokens + (msg.usage.cache_read_input_tokens ?? 0) + (msg.usage.cache_creation_input_tokens ?? 0);
+            this.usage.input += msg.usage.input_tokens + (msg.usage.cache_read_input_tokens ?? 0) + (msg.usage.cache_creation_input_tokens ?? 0);
+            this.usage.output += msg.usage.output_tokens;
+            this.usage.cacheRead += msg.usage.cache_read_input_tokens ?? 0;
+            this.usage.steps++;
+            push({ role: "assistant", content: msg.content });
+            const text = msg.content.flatMap((b) => (b.type === "text" ? [b.text] : [])).join("");
+            if (text)
+                finalText = text;
+            if (!this.opts.quiet)
+                ui.textEnd();
+            const uses = msg.content.filter((b) => b.type === "tool_use");
+            if (msg.stop_reason !== "tool_use" || uses.length === 0) {
+                turn.finished = true;
+                return finalText;
+            }
+            const runOne = async (u) => {
+                const t0 = Date.now();
+                if (!this.opts.quiet)
+                    ui.toolStart(u.id, u.name, u.input);
+                const denied = this.opts.tools && !this.opts.tools.has(u.name);
+                const r = denied ? { text: `Tool não permitida para este agente: ${u.name}`, isError: true } : await execTool(u.name, u.input, this.ctx);
+                if (this.opts.quiet)
+                    this.log(ui.toolLine(u.name, u.input, Date.now() - t0, r.isError));
+                else
+                    ui.toolEnd(u.id, r.isError);
+                return { type: "tool_result", tool_use_id: u.id, content: r.text.slice(0, 40_000), is_error: r.isError };
+            };
+            // Leituras puras rodam em paralelo; qualquer escrita/aprovação força execução em série.
+            const results = uses.every((u) => isConcurrent(u.name, u.input))
+                ? await Promise.all(uses.map(runOne))
+                : await uses.reduce(async (acc, u) => [...(await acc), await runOne(u)], Promise.resolve([]));
+            turn.toolCalls += results.length;
+            turn.errors += results.filter((r) => r.is_error).length;
+            push({ role: "user", content: results });
+            await this.compactIfNeeded();
+        }
+        ui.warn("Limite de passos atingido.");
+        return finalText || "(limite de passos atingido sem resposta final)";
+    }
+    async compactIfNeeded() {
+        if (estimateTokens(this.messages) < COMPACT_AT)
+            return;
+        this.messages = trimOldToolResults(this.messages);
+        if (estimateTokens(this.messages) < COMPACT_AT)
+            return;
+        this.log("compactando contexto…");
+        this.messages = await summarizeMiddle(this.client, this.model, this.messages);
+        this.contextTokens = estimateTokens(this.messages); // até a próxima chamada real, a barra não fica com o valor antigo
+    }
+}

package/dist/agent/prompt.js

@@ -0,0 +1,54 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Frase sobre o grafo para o system prompt. "0 símbolos" sem contexto faz o modelo concluir que o grafo é inútil, mas o
+ * projeto pode só estar vazio no início (e o grafo se atualiza sozinho a cada edição). Por isso: rótulo do momento da
+ * contagem e, quando vazio, a orientação de consultar mesmo assim.
+ * `start` = foto tirada na abertura da sessão (backend do claude: o servidor MCP atualiza o índice em outro processo);
+ * `now` = contagem atualizada após cada sincronização.
+ */
+export function graphStatsLine(syms, notes, when = "now") {
+    if (syms === 0 && notes === 0) {
+        return `O grafo estava vazio ${when === "start" ? "na abertura da sessão" : "na última sincronização"} (projeto novo ou sem código suportado). Ele se atualiza sozinho conforme arquivos são criados e editados: consulte-o com graph_search em vez de supor que está vazio.`;
+    }
+    return `${when === "start" ? "Na abertura da sessão" : "Agora"}: ${syms} símbolos e ${notes} notas indexados. O grafo se atualiza sozinho após edições.`;
+}
+export function buildSystemPrompt(root, graphStats, skills = "") {
+    let projectDoc = "";
+    for (const f of ["BRITO.md", "CLAUDE.md", "AGENTS.md"]) {
+        const p = path.join(root, f);
+        if (fs.existsSync(p)) {
+            projectDoc = `\n\n# Instruções do projeto (${f})\n${fs.readFileSync(p, "utf8")}`;
+            break;
+        }
+    }
+    return `Você é Brito, um agente de engenharia de software que trabalha em CLI. Responda em português do Brasil, de forma direta.
+
+# Como trabalhar
+- Você tem um GRAFO DE CONHECIMENTO do projeto (símbolos, chamadas, imports) e uma MEMÓRIA em grafo (notas). ${graphStats}
+- Para entender código: comece por graph_search / graph_context / graph_callers / graph_callees / graph_impact. Só leia arquivos (read_file) nas linhas que o grafo apontou. Use grep apenas para texto que não é símbolo.
+- Antes de alterar uma função ou arquivo, rode graph_callers / graph_impact e considere o que pode quebrar.
+- Após editar muitos arquivos, rode graph_index para atualizar o grafo.
+- Ao tomar uma decisão não óbvia, descobrir um bug ou uma convenção, grave com remember (com refs para arquivos/símbolos). Consulte recall no início de tarefas relevantes.
+- Edições e comandos shell pedem aprovação do usuário. Prefira edit_file a write_file. Verifique seu trabalho (typecheck/testes) via bash quando existir.
+- Para investigações amplas ou sub-tarefas grandes, use delegate: o subagente trabalha em contexto isolado e devolve só o resultado. Vários delegate somente-leitura (explore/plan) no mesmo turno rodam em paralelo. Passe \`focus\` com os símbolos relevantes. Não delegue o que resolve com 1–2 chamadas de graph_*.
+- SKILLS: procedimentos reutilizáveis aprendidos neste projeto. Se alguma se aplica à tarefa, chame skill_load ANTES de começar e siga-a. Se ela estiver errada ou incompleta, corrija com skill_save. Ao terminar tarefas complexas, o sistema pode propor novas skills; não crie skill para fatos de uma tarefa única.
+- Seja conciso. Não repita conteúdo de arquivos na resposta.
+
+# Ambiente
+Diretório do projeto: ${root}
+Data: ${new Date().toISOString().slice(0, 10)}${skills ? `\n\n# Skills disponíveis (use skill_load)\n${skills}` : ""}${projectDoc}`;
+}
+import { skillsIndex } from "../skills/store.js";
+export function buildSubagentPrompt(root, def) {
+    return `${def.prompt}
+
+# Regras de subagente
+- Você foi chamado por outro agente e NÃO vê a conversa dele: tudo que precisa está na tarefa.
+- Use o grafo antes de ler arquivos: graph_search, graph_context, graph_callers, graph_callees, graph_impact. Leia só as linhas que ele apontar.
+- Sua última mensagem é a única coisa que o chamador recebe. Seja objetivo e use caminhos \`arquivo:linha\`; sem preâmbulo.
+
+# Ambiente
+Diretório do projeto: ${root}
+Data: ${new Date().toISOString().slice(0, 10)}${skillsIndex(root) ? `\n\n# Skills disponíveis (use skill_load)\n${skillsIndex(root)}` : ""}`;
+}