brito-cli 0.7.4 → 0.8.0

package/dist/agent/approval.js

@@ -3,11 +3,22 @@ import net from "node:net";
 import os from "node:os";
 import path from "node:path";
 import { describeClaudeTool, perms } from "../permissions.js";
+import { decide, loadRules } from "../rules.js";
 /**
  * Aprovações do claude CLI: o claude chama a tool MCP `approve` (--permission-prompt-tool), que roda no
  * processo do servidor MCP e consulta ESTE processo por um socket unix, onde está o terminal (ou a janela do app).
  */
-export function startApprovalServer(io) {
+/** Traduz uma tool do claude CLI para o nome e o input das tools do Brito e decide pelas regras de permissão. */
+export function claudeDecision(root, tool, input) {
+    const file = typeof input?.file_path === "string" ? input.file_path : undefined;
+    const mapped = tool === "Bash" ? { name: "bash", input: { command: input?.command } } :
+        (tool === "Edit" || tool === "MultiEdit") && file ? { name: "edit_file", input: { path: file } } :
+            tool === "Write" && file ? { name: "write_file", input: { path: file } } :
+                { name: tool, input };
+    return decide(loadRules(root), mapped.name, mapped.input, root);
+}
+/** `root` liga as regras de permissão do projeto; sem ele, toda chamada é perguntada como antes. */
+export function startApprovalServer(io, root) {
     // No Windows um socket unix em %TEMP% não é aceito por net.listen: o endereço tem que ser um named pipe.
     const sock = process.platform === "win32" ? `\\\\.\\pipe\\brito-approve-${process.pid}` : path.join(os.tmpdir(), `brito-approve-${process.pid}.sock`);
     try {
@@ -25,7 +36,13 @@ export function startApprovalServer(io) {
             try {
                 const req = JSON.parse(buf.slice(0, nl));
                 const plan = req.tool_name === "ExitPlanMode";
-                const ok = await io.ask(describeClaudeTool(req.tool_name, req.input), { force: plan });
+                // As regras do Brito valem também para as tools do claude: deny bloqueia, allow dispensa a pergunta.
+                const decision = root && !plan ? claudeDecision(root, req.tool_name, req.input) : "ask";
+                if (decision === "deny") {
+                    conn.end(JSON.stringify({ allow: false, message: "Bloqueado por uma regra deny das permissões do Brito (.brito/settings.json). Não tente contornar." }) + "\n");
+                    return;
+                }
+                const ok = decision === "allow" || await io.ask(describeClaudeTool(req.tool_name, req.input), { force: plan });
                 if (ok && plan)
                     perms.mode = "manual";
                 reply = ok ? { allow: true } : { allow: false, message: plan ? "Plano não aprovado pelo usuário. Pergunte o que ajustar." : "O usuário negou a execução." };

package/dist/agent/claude-cli.js

@@ -212,7 +212,7 @@ export class ClaudeSession {
     args(text, imageDirs = []) {
         const { root, approvalSock, stats, mcpCommand } = this.o;
         const mcp = mcpConfig(mcpCommand, approvalSock, perms.mode, this.o.env);
-        const readOnlyMcp = ["graph_search", "graph_callers", "graph_callees", "graph_impact", "graph_context", "graph_query", "graph_index", "remember", "recall", "skill_load"];
+        const readOnlyMcp = ["graph_search", "graph_callers", "graph_callees", "graph_impact", "graph_context", "graph_query", "graph_index", "remember", "recall", "skill_load", "digest"];
         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).`;

package/dist/agent/loop.js

@@ -5,7 +5,7 @@ import { initialEffort, initialModel } from "../model.js";
 import { providerFor } from "../provider/index.js";
 import { compactAtFor, resolveModel } from "../provider/resolve.js";
 import { fallbackStatus } from "../engine.js";
-import { activateFallback, classifyAnthropicError, fallbackWarning, shortError, triggersFallback } from "../provider/fallback.js";
+import { activateFallback, classifyAnthropicError, fallbackExpired, fallbackUntil, fallbackWarning, returnToPrimary, shortError, triggersFallback } from "../provider/fallback.js";
 import { fmtBytes, findImages, imageBlock, splitOversize } from "../util/images.js";
 export const MODEL = initialModel();
 export class Agent {
@@ -80,6 +80,7 @@ export class Agent {
         }
         else
             push({ role: "user", content: userText });
+        this.retryPrimaryIfExpired();
         await this.compactIfNeeded();
         let finalText = "";
         for (let step = 0; step < this.maxSteps; step++) {
@@ -147,31 +148,53 @@ export class Agent {
         try {
             return await providerFor(this.model).send({
                 model: this.model,
-                maxTokens: target.kind === "openai" && thinking ? 16_384 : 8192,
+                // Na Anthropic a resposta vem por streaming, então o teto pode ser alto sem risco de timeout: um
+                // write_file grande não é mais cortado no meio.
+                maxTokens: target.kind === "openai" ? (thinking ? 16_384 : 8192) : 32_000,
                 system: typeof this.system === "function" ? this.system() : this.system,
                 tools: toApiTools(this.opts.tools),
                 messages: this.messages,
                 thinking,
+                effort: this.effort,
             }, hooks);
         }
         catch (e) {
             const fb = this.opts.fallback;
-            if (!fb || fb.active || hooks.signal?.aborted || target.kind !== "anthropic")
+            if (!fb || hooks.signal?.aborted)
                 throw e;
-            const kind = classifyAnthropicError(e);
+            // Claude → qwen → SLM: com o fallback ativo só desce um degrau (qwen que falha cai no SLM), nunca o SLM.
+            const onQwen = fb.active && target.kind === "openai" && !target.local && target.name === "qwen";
+            if (fb.active ? !onQwen : target.kind !== "anthropic" || target.local)
+                throw e;
+            if (onQwen && target.kind !== "openai")
+                throw e;
+            const kind = onQwen ? "network" : classifyAnthropicError(e);
             if (!triggersFallback(kind))
                 throw e;
-            const status = fallbackStatus(this.model, process.env);
+            const status = fallbackStatus(fb.primary, process.env, onQwen ? ["qwen"] : []);
             if (!status.ready)
                 throw e;
             const why = shortError(e);
-            this.ui.warn(fallbackWarning(kind, why, status.label));
-            activateFallback(fb, `${kind} (${why})`);
+            const until = onQwen ? fb.until : fallbackUntil(kind, why);
+            this.ui.warn(fallbackWarning(kind, why, status.label, until));
+            activateFallback(fb, `${kind} (${why})`, Date.now(), until, status.name);
             this.model = status.name;
             await this.compactIfNeeded();
             return this.callModel(hooks);
         }
     }
+    /**
+     * Fallback temporário: passada a janela, o próximo turno tenta o Claude de novo (se falhar, `callModel` reativa o
+     * fallback com uma janela nova). Só com ANTHROPIC_API_KEY: sem ela o Claude não roda neste loop (volta via /model).
+     */
+    retryPrimaryIfExpired() {
+        const fb = this.opts.fallback;
+        if (!fb || !fallbackExpired(fb) || !process.env.ANTHROPIC_API_KEY?.trim() || resolveModel(fb.primary).kind !== "anthropic")
+            return;
+        returnToPrimary(fb);
+        this.model = fb.primary;
+        this.ui.info(`voltando ao Claude (${fb.primary}) para testar se o limite acabou`);
+    }
     async compactIfNeeded() {
         if (estimateTokens(this.messages) < compactAtFor(this.model))
             return;

package/dist/agent/prompt.js

@@ -23,33 +23,59 @@ export function buildSystemPrompt(root, graphStats, skills = "") {
             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}
+    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.
+- Em tarefas com 3+ passos, mantenha a lista com todo_write: um item in_progress por vez, marcado completed assim que terminar. Leia um arquivo (read_file) antes de editá-lo; se ele mudou desde a leitura, leia de novo.
+- Seja conciso. Não repita conteúdo de arquivos na resposta.
+
+# Ambiente
+Diretório do projeto: ${root}
 Data: ${new Date().toISOString().slice(0, 10)}${shellNote()}${skills ? `\n\n# Skills disponíveis (use skill_load)\n${skills}` : ""}${projectDoc}`;
 }
-import { skillsIndex } from "../skills/store.js";
+import { listSkills, skillsIndex } from "../skills/store.js";
+/**
+ * Repete o system prompt anterior enquanto `key()` não muda. O cache de prompt da API é um prefixo: qualquer byte
+ * diferente no system (a contagem de símbolos após um sync, a ordem das skills por uso) invalidaria o cache da
+ * conversa inteira a cada passo. A chave lista só o que muda o que o modelo deve fazer.
+ */
+export function memoSystem(key, build) {
+    let last;
+    let value = "";
+    return () => {
+        const k = key();
+        if (k !== last) {
+            last = k;
+            value = build();
+        }
+        return value;
+    };
+}
+/**
+ * Chave do `memoSystem` da sessão principal: modo plano, grafo vazio ou não (o aviso de "grafo vazio" muda a
+ * orientação) e o conjunto de skills com o status. Contagens e ordem por uso ficam de fora de propósito.
+ */
+export function systemKey(root, planMode, graphEmpty) {
+    const skills = listSkills(root).map((s) => `${s.name}:${s.scope}:${s.status}`).sort().join(",");
+    return `${planMode}|${graphEmpty}|${skills}`;
+}
 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}
+    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)}` : ""}`;
 }

package/dist/agent/sessions.js

@@ -0,0 +1,98 @@
+import fs from "node:fs";
+import path from "node:path";
+const MAX_SESSIONS = 50;
+const ID = /^[\w-]{1,80}$/;
+export const sessionsDir = (root) => path.join(root, ".brito", "sessions");
+const fileOf = (root, id) => {
+    if (!ID.test(id))
+        throw new Error(`id de sessão inválido: ${id}`);
+    return path.join(sessionsDir(root), `${id}.json`);
+};
+const stripImages = (msgs) => msgs.map((m) => typeof m.content === "string" ? m : {
+    ...m,
+    content: m.content.map((b) => (b.type === "image" || b.type === "document" ? { type: "text", text: "[anexo omitido ao salvar a sessão]" } : b)),
+});
+export function titleOf(msgs, fallback = "") {
+    const first = msgs?.find((m) => m.role === "user");
+    const text = typeof first?.content === "string" ? first.content : first?.content.flatMap((b) => (b.type === "text" ? [b.text] : [])).join(" ") ?? fallback;
+    return (text || fallback).replace(/\s+/g, " ").trim().slice(0, 80);
+}
+/** Grava (ou atualiza) a sessão. Nunca derruba o turno: falha de disco vira aviso de quem chamou. */
+export function saveSession(root, s, now = new Date()) {
+    const dir = sessionsDir(root);
+    fs.mkdirSync(dir, { recursive: true });
+    // Conversas são pessoais e podem citar dados sensíveis: nunca vão para o git por acidente.
+    try {
+        fs.writeFileSync(path.join(dir, ".gitignore"), "*\n", { flag: "wx" });
+    }
+    catch (e) {
+        if (e.code !== "EEXIST")
+            throw e;
+    }
+    const prev = loadSession(root, s.id);
+    const out = {
+        v: 1, ...s,
+        ...(s.messages ? { messages: stripImages(s.messages) } : {}),
+        createdAt: s.createdAt ?? prev?.createdAt ?? now.toISOString(),
+        updatedAt: now.toISOString(),
+    };
+    const file = fileOf(root, s.id);
+    const tmp = `${file}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(out));
+    fs.renameSync(tmp, file); // atômico: um Ctrl+C no meio não deixa JSON cortado
+    prune(root);
+}
+export function loadSession(root, id) {
+    try {
+        const s = JSON.parse(fs.readFileSync(fileOf(root, id), "utf8"));
+        return s?.v === 1 && typeof s.id === "string" ? s : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Mais recentes primeiro. */
+export function listSessions(root) {
+    let names;
+    try {
+        names = fs.readdirSync(sessionsDir(root)).filter((n) => n.endsWith(".json"));
+    }
+    catch {
+        return [];
+    }
+    return names
+        .flatMap((n) => { const s = loadSession(root, n.slice(0, -5)); return s ? [s] : []; })
+        .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+export const latestSession = (root, engine) => listSessions(root).find((s) => !engine || s.engine === engine) ?? null;
+/** Mantém as `MAX_SESSIONS` mais recentes, pela data do arquivo (sem abrir históricos que podem ter megabytes). */
+function prune(root) {
+    const dir = sessionsDir(root);
+    const files = fs.readdirSync(dir).filter((n) => n.endsWith(".json")).map((n) => {
+        try {
+            return { n, t: fs.statSync(path.join(dir, n)).mtimeMs };
+        }
+        catch {
+            return { n, t: 0 };
+        }
+    }).sort((a, b) => b.t - a.t);
+    for (const f of files.slice(MAX_SESSIONS)) {
+        try {
+            fs.unlinkSync(path.join(dir, f.n));
+        }
+        catch { /* já removida */ }
+    }
+}
+/**
+ * Histórico salvo pronto para reenviar: se o processo caiu no meio de um turno, o último `tool_use` pode ter ficado sem
+ * `tool_result`, e a API recusaria a conversa. Fecha cada um com erro, como no Ctrl+C.
+ */
+export function repairHistory(msgs) {
+    const last = msgs[msgs.length - 1];
+    if (last?.role !== "assistant" || typeof last.content === "string")
+        return msgs;
+    const pending = last.content.filter((b) => b.type === "tool_use");
+    if (!pending.length)
+        return msgs;
+    return [...msgs, { role: "user", content: pending.map((u) => ({ type: "tool_result", tool_use_id: u.id, content: "Sessão interrompida antes desta tool terminar.", is_error: true })) }];
+}