brito-cli 0.3.0 → 0.3.2

package/README.md

@@ -133,13 +133,13 @@ Brito has **no database drivers and connects to nothing on its own**. When it ne
 
 ## Configuration
 
-`BRITO_MODEL`, `BRITO_EFFORT`, `BRITO_EXPLORE_MODEL`, `BRITO_LEARN_MODEL`, `BRITO_HOME` (where global skills and history live), `BRITO_CONFIG`, `BRITO_COLOR`, `BRITO_INDEX_IGNORED`, `BRITO_SKILL_MIN_TOOLS` (how long a turn must be to trigger reflection when nothing else does).
+`BRITO_MODEL`, `BRITO_EFFORT`, `BRITO_EXPLORE_MODEL`, `BRITO_LEARN_MODEL`, `BRITO_HOME` (where global skills and history live), `BRITO_CONFIG`, `BRITO_COLOR`, `BRITO_BANNER` (`compact` or `full`; default: full screen on windows of 95+ columns and 28+ rows), `BRITO_INDEX_IGNORED`, `BRITO_SKILL_MIN_TOOLS` (how long a turn must be to trigger reflection when nothing else does).
 
 Project data lives in `.brito/` (graph, project skills, agents) and global data in `~/.brito`. The graph, memory and skills stay on your machine; as with any coding agent, the code the model reads is sent to the model provider you configured.
 
 ## Limitations
 
-- Early software (v0.3.0), one maintainer.
+- Early software (v0.3.1), one maintainer.
 - **The interface and the agent's default language are Brazilian Portuguese.** Translating them is a welcome contribution.
 - Skill learning is a heuristic: it proposes, you decide. Expect some proposals to be rejected.
 

package/README.pt-BR.md

@@ -133,13 +133,13 @@ O Brito **não tem drivers de banco e não se conecta a nada sozinho**. Quando p
 
 ## Configuração
 
-`BRITO_MODEL`, `BRITO_EFFORT`, `BRITO_EXPLORE_MODEL`, `BRITO_LEARN_MODEL`, `BRITO_HOME` (onde ficam skills globais e histórico), `BRITO_CONFIG`, `BRITO_COLOR`, `BRITO_INDEX_IGNORED`, `BRITO_SKILL_MIN_TOOLS` (tamanho mínimo do turno para disparar a reflexão quando nada mais dispara).
+`BRITO_MODEL`, `BRITO_EFFORT`, `BRITO_EXPLORE_MODEL`, `BRITO_LEARN_MODEL`, `BRITO_HOME` (onde ficam skills globais e histórico), `BRITO_CONFIG`, `BRITO_COLOR`, `BRITO_BANNER` (`compact` ou `full`; padrão: tela cheia em janelas de 95+ colunas e 28+ linhas), `BRITO_INDEX_IGNORED`, `BRITO_SKILL_MIN_TOOLS` (tamanho mínimo do turno para disparar a reflexão quando nada mais dispara).
 
 Os dados do projeto ficam em `.brito/` (grafo, skills do projeto, agentes) e os globais em `~/.brito`. O grafo, a memória e as skills ficam na sua máquina; como em qualquer agente de código, o código que o modelo lê é enviado ao provedor de modelo que você configurou.
 
 ## Limitações
 
-- Software em fase inicial (v0.3.0), um mantenedor.
+- Software em fase inicial (v0.3.1), um mantenedor.
 - **A interface e o idioma padrão do agente são português do Brasil.** Traduzi-los é uma contribuição bem-vinda.
 - O aprendizado de skills é heurístico: ele propõe, você decide. Espere rejeitar algumas propostas.
 

package/dist/cli.js

@@ -12,7 +12,7 @@ import os from "node:os";
 import fs from "node:fs";
 import { PLAN_NOTE, perms, describeClaudeTool } from "./permissions.js";
 import { loadProjectAgents, listAgents } from "./agent/agents.js";
-import { GraphStore } from "./graph/store.js";
+import { GraphLockedError, GraphStore } from "./graph/store.js";
 import { indexProject } from "./graph/indexer.js";
 import { Agent, MODEL } from "./agent/loop.js";
 import { EFFORTS, MODEL_ALIASES, MODEL_HELP, effortLabel, initialEffort, isEffort, loadReasoningDisplay, parseModelArgs, saveEffort, saveModel, saveReasoningDisplay } from "./model.js";
@@ -559,4 +559,10 @@ program
         },
     });
 });
-program.parseAsync();
+program.parseAsync().catch((e) => {
+    if (e instanceof GraphLockedError) {
+        console.error(c.err("✗ ") + e.message);
+        process.exit(1);
+    }
+    throw e;
+});

package/dist/graph/store.js

@@ -12,6 +12,19 @@ async function drain(r, read = true) {
             x.close();
     }
 }
+/** Outro processo do Brito está com o banco aberto: o Kùzu só deixa um processo por projeto. */
+export class GraphLockedError extends Error {
+    constructor(file) {
+        super(`O grafo deste projeto está em uso por outro processo do Brito (${file}).\n` +
+            "O banco aceita um processo por vez: provavelmente há outro terminal com o Brito, ou uma sessão do Claude Code usando o Brito, neste mesmo diretório.\n" +
+            "Feche o outro, ou espere o turno em andamento terminar, e tente de novo.");
+        this.name = "GraphLockedError";
+    }
+}
+const isLockError = (e) => /could not set lock/i.test(String(e?.message ?? e));
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Quanto esperar o banco liberar antes de desistir: cobre sobreposições curtas (a reflexão de skills e o turno, por exemplo). */
+const LOCK_WAIT_MS = 4000;
 export class GraphStore {
     db;
     conn;
@@ -20,13 +33,26 @@ export class GraphStore {
         this.db = db;
         this.conn = conn;
     }
-    static async open(root) {
+    static async open(root, waitMs = LOCK_WAIT_MS) {
         const dir = path.join(root, ".brito");
         fs.mkdirSync(dir, { recursive: true });
-        const db = new kuzu.Database(path.join(dir, "graph.kuzu"));
-        const store = new GraphStore(db, new kuzu.Connection(db));
-        await store.migrate();
-        return store;
+        const file = path.join(dir, "graph.kuzu");
+        const deadline = Date.now() + waitMs;
+        for (;;) {
+            try {
+                const db = new kuzu.Database(file);
+                const store = new GraphStore(db, new kuzu.Connection(db));
+                await store.migrate();
+                return store;
+            }
+            catch (e) {
+                if (!isLockError(e))
+                    throw e;
+                if (Date.now() >= deadline)
+                    throw new GraphLockedError(file);
+                await sleep(250);
+            }
+        }
     }
     async migrate() {
         const ddl = [

package/dist/mcp/server.js

@@ -64,7 +64,7 @@ export async function serveMcp(root) {
         ask: async () => true,
         sync: async () => { await indexProject(root, graph); },
     };
-    const server = new Server({ name: MCP_NAME, version: "0.3.0" }, { capabilities: { tools: {} }, instructions: MCP_INSTRUCTIONS });
+    const server = new Server({ name: MCP_NAME, version: "0.3.1" }, { capabilities: { tools: {} }, instructions: MCP_INSTRUCTIONS });
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
         tools: [{
                 name: APPROVE_TOOL,

package/dist/ui/banner.js

@@ -1,21 +1,7 @@
 import fs from "node:fs";
 import stringWidth from "string-width";
-import { c, cols, mix, palette, stripAnsi, truncAnsi } from "./theme.js";
-const LOGO = [
-    "████  ████  █████ █████  ███ ",
-    "█   █ █   █   █     █   █   █",
-    "████  ████    █     █   █   █",
-    "█   █ █  █    █     █   █   █",
-    "████  █   █ █████   █    ███ ",
-];
-/** Arte do lado esquerdo: um pequeno grafo, a identidade do Brito. */
-const HERO = [
-    "   ◉───────◉───────◉   ",
-    "   │ \\   / │ \\   / │   ",
-    "   │  ◉────◉───◉  │   ",
-    "   │ /   \\ │ /   \\ │   ",
-    "   ◉───────◉───────◉   ",
-];
+import { c, cols, stripAnsi, truncAnsi } from "./theme.js";
+import { LOGO, WEB_W, overlayText, serialize, stampLogo, webCanvas, webLogo } from "./web-art.js";
 const GROUPS = [
     ["arquivos", (n) => ["read_file", "write_file", "edit_file", "glob", "grep"].includes(n)],
     ["shell", (n) => n === "bash"],
@@ -49,7 +35,57 @@ function listLine(label, items, width) {
     const rest = items.length - shown.length;
     return head + c.soft(shown.join(", ")) + (rest > 0 ? c.dim(`  +${rest}`) : "");
 }
+/** Linhas livres embaixo da janela: moldura (2) + dock com status e prompt. */
+const BELOW_BANNER = 7;
+const clamp = (n, lo, hi) => Math.max(lo, Math.min(hi, n));
+/** BRITO_BANNER=compact força o banner pequeno; =full força a tela cheia; sem nada, é tela cheia em janela grande. */
+function wantsFull() {
+    const mode = process.env.BRITO_BANNER;
+    if (mode === "compact")
+        return false;
+    if (mode === "full")
+        return true;
+    return (process.stdout.rows ?? 0) >= 28 && cols() >= 95;
+}
+/** Tela cheia: a teia ocupa a janela inteira, com o nome no centro e o painel por cima. */
+function renderFull(i) {
+    const total = cols();
+    const inner = total - 4;
+    const rows = process.stdout.rows || 30;
+    const h = Math.max(20, rows - BELOW_BANNER);
+    const grid = webCanvas(inner, h, { rings: h >= 26 ? 4 : 3, spokes: inner >= 120 ? 16 : 12 });
+    const blockW = Math.min(inner - 4, 72);
+    const home = process.env.HOME ?? "\0";
+    const info = [
+        truncAnsi(`${c.soft(i.model)} ${c.dim("·")} ${c.muted(`${fmtK(i.ctxWindow)} ctx`)} ${c.dim("·")} ${c.muted(i.dir.replace(home, "~"))} ${c.dim("·")} ${c.dim(`sessão ${i.session}`)}`, blockW),
+        "",
+    ];
+    for (const [label, test] of GROUPS) {
+        const names = i.tools.filter(test);
+        if (names.length)
+            info.push(listLine(label, names, blockW));
+    }
+    info.push(c.muted("subagentes: ") + c.soft(i.agents.join(", ") || "—"));
+    const project = i.skills.filter((s) => s.scope === "project").map((s) => s.name);
+    const global = i.skills.filter((s) => s.scope === "global").map((s) => s.name);
+    if (project.length)
+        info.push(listLine("skills do projeto", project, blockW));
+    if (global.length)
+        info.push(listLine("skills globais", global, blockW));
+    if (!i.skills.length)
+        info.push(c.muted("skills: ") + c.dim("nenhuma ainda · nascem sozinhas após tarefas complexas"));
+    info.push("", c.dim(`${i.tools.length} tools · ${i.skills.length} ${i.skills.length === 1 ? "skill" : "skills"} · ${i.symbols} símbolos · ${i.notes} notas · /help`));
+    const top = Math.max(0, Math.floor((h - (LOGO.length + 1 + info.length)) / 2));
+    stampLogo(grid, Math.floor((inner - LOGO[0].length) / 2), top);
+    const x0 = Math.floor((inner - blockW) / 2);
+    info.forEach((l, k) => overlayText(grid, x0, top + LOGO.length + 1 + k, l));
+    const title = ` ${i.name} v${version()} `;
+    const head = c.accent("╭─") + c.bold(c.light(title)) + c.accent("─".repeat(Math.max(1, total - title.length - 3)) + "╮");
+    return [head, ...serialize(grid).map((r) => c.accent("│ ") + r + c.accent(" │")), c.accent("╰" + "─".repeat(total - 2) + "╯")].join("\n");
+}
 export function renderBanner(i) {
+    if (wantsFull())
+        return renderFull(i);
     const total = Math.min(cols(), 110);
     const wide = total >= 95;
     const inner = total - 4;
@@ -59,15 +95,11 @@ export function renderBanner(i) {
         c.muted(i.dir.replace(home, "~")),
         c.dim(`sessão ${i.session}`),
     ];
-    const leftW = wide ? Math.max(LOGO[0].length, HERO[0].length) + 2 : inner;
+    const leftW = wide ? WEB_W + 2 : inner;
     const rightW = wide ? inner - leftW - 3 : inner;
     const left = [];
-    if (wide) {
-        LOGO.forEach((l, k) => left.push(c.rgb(mix(palette.accent, palette.soft, k / (LOGO.length - 1)))(l)));
-        left.push("");
-        HERO.forEach((l) => left.push(l.replace(/[◉]/g, (m) => c.light(m)).replace(/[─│\\/]/g, (m) => c.accent(m))));
-        left.push("");
-    }
+    if (wide)
+        left.push(...webLogo(), "");
     left.push(...context);
     const right = [c.bold(c.light("Ferramentas disponíveis"))];
     for (const [label, test] of GROUPS) {

package/dist/ui/web-art.js

@@ -0,0 +1,131 @@
+import { RESET, c, mix, palette } from "./theme.js";
+/**
+ * A identidade visual do Brito: uma teia (raios + anéis em polígono, com nós nos cruzamentos), meio grafo, com o nome
+ * por cima. É gerada em vez de desenhada à mão para servir a qualquer tamanho de janela e os traços ficarem alinhados.
+ * Só usa tons derivados do roxo da marca (BRITO_COLOR): claro no centro, escurecendo até a borda.
+ */
+export const LOGO = [
+    "████  ████  █████ █████  ███ ",
+    "█   █ █   █   █     █   █   █",
+    "████  ████    █     █   █   █",
+    "█   █ █  █    █     █   █   █",
+    "████  █   █ █████   █    ███ ",
+];
+/** Tamanho da teia do banner compacto. */
+export const WEB_W = 33;
+export const WEB_H = 13;
+const blank = () => ({ ch: " ", kind: "empty" });
+const paintOf = (col) => c.rgb(col);
+/** Caractere de um segmento inteiro, pelo ângulo visual (a célula tem ~2x mais altura que largura): evita ─╱╲ misturados. */
+function strand(x0, y0, x1, y1) {
+    const dx = Math.abs(x1 - x0), dy = Math.abs(y1 - y0) * 2;
+    const angle = (Math.atan2(dy, dx) * 180) / Math.PI;
+    if (angle < 25)
+        return "─";
+    if (angle > 65)
+        return "│";
+    return (x1 - x0) * (y1 - y0) > 0 ? "╲" : "╱";
+}
+/** Traço de a até b (Bresenham) com um caractere só; só preenche célula vazia, então o que veio antes prevalece. */
+function line(grid, x0, y0, x1, y1, ch, paintAt) {
+    const dx = Math.abs(x1 - x0), dy = Math.abs(y1 - y0);
+    const sx = x0 < x1 ? 1 : -1, sy = y0 < y1 ? 1 : -1;
+    let err = dx - dy, x = x0, y = y0;
+    while (x !== x1 || y !== y1) {
+        const e2 = 2 * err;
+        if (e2 > -dy) {
+            err -= dy;
+            x += sx;
+        }
+        if (e2 < dx) {
+            err += dx;
+            y += sy;
+        }
+        if (grid[y]?.[x]?.kind === "empty")
+            grid[y][x] = { ch, kind: "strand", paint: paintAt(x, y) };
+    }
+}
+/** A teia crua de w x h células, centrada: anéis sólidos, raios pontilhados e nós nos cruzamentos. */
+export function webCanvas(w, h, { rings, spokes }) {
+    const grid = Array.from({ length: h }, () => Array.from({ length: w }, blank));
+    const cx = (w - 1) / 2, cy = (h - 1) / 2;
+    const vertex = (k, f) => {
+        const a = (2 * Math.PI * k) / spokes;
+        return [Math.round(cx + cx * f * Math.cos(a)), Math.round(cy + cy * f * Math.sin(a))];
+    };
+    /** 0 no centro, 1 na borda. */
+    const dist = (x, y) => Math.min(1, Math.hypot((x - cx) / Math.max(1, cx), (y - cy) / Math.max(1, cy)));
+    const ringPaint = (x, y) => paintOf(mix(palette.light, palette.accent, Math.pow(dist(x, y), 0.8)));
+    const spokePaint = (x, y) => paintOf(mix(palette.soft, palette.accent, 0.35 + 0.65 * dist(x, y)));
+    for (let i = 1; i <= rings; i++) {
+        const f = i / rings;
+        for (let k = 0; k < spokes; k++) {
+            const [x0, y0] = vertex(k, f), [x1, y1] = vertex((k + 1) % spokes, f);
+            line(grid, x0, y0, x1, y1, strand(x0, y0, x1, y1), ringPaint);
+        }
+    }
+    for (let k = 0; k < spokes; k++) {
+        const [x, y] = vertex(k, 1);
+        line(grid, Math.round(cx), Math.round(cy), x, y, "·", spokePaint);
+    }
+    for (let i = 1; i <= rings; i++) {
+        for (let k = 0; k < spokes; k++) {
+            const [x, y] = vertex(k, i / rings);
+            grid[y][x] = { ch: i === rings ? "◉" : "○", kind: "node", paint: paintOf(mix(palette.soft, palette.accent, 0.15 + 0.7 * dist(x, y))) };
+        }
+    }
+    grid[Math.round(cy)][Math.round(cx)] = { ch: "◉", kind: "node", paint: paintOf(palette.soft) };
+    return grid;
+}
+/** O nome por cima da teia. Na faixa das letras os traços somem (só os nós aparecem pelos vãos): o nome fica nítido. */
+export function stampLogo(grid, left, top) {
+    LOGO.forEach((l, r) => {
+        const row = grid[top + r];
+        if (!row)
+            return;
+        const first = l.search(/\S/), last = l.search(/\s*$/) - 1;
+        for (let x = first - 1; x <= last + 1; x++)
+            if (row[left + x]?.kind === "strand")
+                row[left + x] = blank();
+        for (let x = 0; x < l.length; x++) {
+            if (l[x] !== " " && row[left + x])
+                row[left + x] = { ch: l[x], kind: "text", paint: paintOf(mix(palette.accent, palette.soft, r / (LOGO.length - 1))) };
+        }
+    });
+}
+/** Uma linha já colorida (ANSI) vira células: o que a cor não alcança fica sem pintura. */
+function ansiCells(s) {
+    const out = [];
+    let prefix = "";
+    for (const part of s.split(/(\x1b\[[0-9;]*m)/)) {
+        if (!part)
+            continue;
+        if (part.startsWith("\x1b[")) {
+            prefix = part === RESET ? "" : prefix + part;
+            continue;
+        }
+        const p = prefix;
+        for (const ch of part)
+            out.push({ ch, kind: "text", paint: p ? (t) => p + t + RESET : undefined });
+    }
+    return out;
+}
+/** Escreve texto sobre a teia; a faixa da linha (mais 1 coluna de cada lado) é limpa para o texto ler bem. */
+export function overlayText(grid, x, y, ansi) {
+    const row = grid[y];
+    if (!row)
+        return;
+    const cells = ansiCells(ansi);
+    for (let k = -1; k <= cells.length; k++)
+        if (row[x + k])
+            row[x + k] = blank();
+    cells.forEach((cell, k) => { if (row[x + k])
+        row[x + k] = cell; });
+}
+export const serialize = (grid) => grid.map((row) => row.map((cell) => (cell.paint ? cell.paint(cell.ch) : cell.ch)).join(""));
+/** O logotipo do banner compacto: BRITO sobre uma teia pequena. */
+export function webLogo() {
+    const grid = webCanvas(WEB_W, WEB_H, { rings: 3, spokes: 8 });
+    stampLogo(grid, Math.floor((WEB_W - LOGO[0].length) / 2), Math.round((WEB_H - 1) / 2) - Math.floor(LOGO.length / 2));
+    return serialize(grid);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brito-cli",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Coding-agent CLI with a code knowledge graph, memory and reviewable skills / CLI de agente de código com grafo de conhecimento, memória e skills revisáveis",
   "type": "module",
   "bin": {