brito-cli 0.5.2 → 0.6.1

package/README.md

@@ -12,7 +12,9 @@ Brito is an agent for software development. Use it in the terminal (`brito-cli`
 
 ## Highlights
 
-- **Graph-first exploration.** `graph_search`, `graph_context`, `graph_callers`, `graph_callees` and `graph_impact` answer "where is it, who uses it, what breaks" without reading whole files. The graph is embedded ([Kùzu](https://kuzudb.com)), local and incremental.
+> **Upgrading to 0.6:** the graph engine changed from Kùzu (discontinued) to LadybugDB. The graph is rebuilt automatically on first use; your old `.brito/graph.kuzu` is kept. Brito asks once whether to copy your notes (memory) to the new graph, or run `brito migrar-notas` any time. Tests run in CI on macOS, Linux and Windows (use 0.6.1 or later on Windows/Linux). See the [CHANGELOG](CHANGELOG.md).
+
+- **Graph-first exploration.** `graph_search`, `graph_context`, `graph_callers`, `graph_callees` and `graph_impact` answer "where is it, who uses it, what breaks" without reading whole files. The graph is embedded ([LadybugDB](https://github.com/LadybugDB/ladybug), fork mantido do Kùzu), local and incremental.
 - **Wide coverage.** TypeScript/JavaScript, Python and the script blocks of `.svelte`, `.vue` and `.astro` components. Import aliases (`tsconfig` paths, `package.json` imports, SvelteKit's `$lib`) become real edges. Files ignored by `.gitignore` stay out.
 - **Skills that learn on their own, on probation.** After a task that tripped or was corrected, Brito reflects and creates a skill *in trial* without interrupting you. A skill proves itself by use: 3 clean uses promote it, 2 stumbles archive it (recoverable). Anything risky, or any change to a skill you approved, still waits for your `/skills approve`. `BRITO_SKILLS=ask` restores approval-for-everything; `off` disables learning.
 - **Safety rails for what gets learned.** A lint rejects secrets, credentials embedded in URLs, `curl | sh` and prompt-injection phrasing, and **warns about destructive commands** (see below).
@@ -187,7 +189,7 @@ npm test             # 190+ tests, including a real MCP server and a real REPL
 
 | Path | What |
 |---|---|
-| `src/graph/` | indexer (tree-sitter), `.svelte/.vue/.astro` support, import aliases, Kùzu store |
+| `src/graph/` | indexer (tree-sitter), `.svelte/.vue/.astro` support, import aliases, Ladybug (Kùzu) store |
 | `src/skills/` | store, lint, reflection, journal, consolidation |
 | `src/agent/` | agent loop, prompts, subagents, `claude` CLI backend |
 | `src/tools/` | graph, memory, skills, filesystem and shell tools |

package/README.pt-BR.md

@@ -12,7 +12,9 @@ O Brito é um agente para desenvolvimento de software. Use no terminal (`brito-c
 
 ## Destaques
 
-- **Exploração guiada pelo grafo.** `graph_search`, `graph_context`, `graph_callers`, `graph_callees` e `graph_impact` respondem "onde está, quem usa, o que quebra" sem ler arquivos inteiros. O grafo é embutido ([Kùzu](https://kuzudb.com)), local e incremental.
+> **Atualizando para a 0.6:** o motor do grafo mudou do Kùzu (descontinuado) para o LadybugDB. O grafo é reconstruído sozinho no primeiro uso; o seu `.brito/graph.kuzu` antigo é mantido. O Brito pergunta uma vez se copia as suas notas (memória) para o grafo novo, ou rode `brito migrar-notas` quando quiser. Os testes rodam no CI em macOS, Linux e Windows (use a 0.6.1 ou posterior no Windows/Linux). Veja o [CHANGELOG](CHANGELOG.md).
+
+- **Exploração guiada pelo grafo.** `graph_search`, `graph_context`, `graph_callers`, `graph_callees` e `graph_impact` respondem "onde está, quem usa, o que quebra" sem ler arquivos inteiros. O grafo é embutido ([LadybugDB](https://github.com/LadybugDB/ladybug), fork mantido do Kùzu), local e incremental.
 - **Cobertura ampla.** TypeScript/JavaScript, Python e os blocos de script de componentes `.svelte`, `.vue` e `.astro`. Aliases de import (`paths` do tsconfig, `imports` do package.json, `$lib` do SvelteKit) viram arestas de verdade. O que o `.gitignore` ignora fica de fora.
 - **Skills que aprendem sozinhas, em período de teste.** Depois de uma tarefa em que algo tropeçou ou foi corrigido, o Brito reflete e cria uma skill *em teste* sem te interromper. A skill se prova pelo uso: 3 usos limpos a promovem, 2 tropeços a arquivam (recuperável). O que é arriscado, ou qualquer mudança numa skill que você aprovou, continua esperando o seu `/skills approve`. `BRITO_SKILLS=ask` volta a pedir aprovação para tudo; `off` desliga o aprendizado.
 - **Proteções sobre o que é aprendido.** Um lint rejeita segredos, credenciais embutidas em URL, `curl | sh` e frases de injeção de prompt, e **avisa sobre comandos destrutivos** (veja abaixo).
@@ -183,7 +185,7 @@ npm test             # 190+ testes, incluindo um servidor MCP real e um REPL rea
 
 | Caminho | O quê |
 |---|---|
-| `src/graph/` | indexador (tree-sitter), suporte a `.svelte/.vue/.astro`, aliases de import, store Kùzu |
+| `src/graph/` | indexador (tree-sitter), suporte a `.svelte/.vue/.astro`, aliases de import, store Ladybug (Kùzu) |
 | `src/skills/` | store, lint, reflexão, journal, consolidação |
 | `src/agent/` | loop do agente, prompts, subagentes, backend da CLI `claude` |
 | `src/tools/` | tools de grafo, memória, skills, arquivos e shell |

package/dist/cli.js

@@ -49,6 +49,18 @@ program
     .option("-d, --dir <dir>")
     .option("--resume <id>", "retoma uma conversa do claude")
     .action(async (o) => { const { serveDesktop } = await import("./desktop/serve.js"); await serveDesktop(rootOf(o), o.resume); });
+program
+    .command("migrar-notas")
+    .description("Copia as notas (memória) do grafo antigo do Kùzu para o novo grafo")
+    .option("-d, --dir <dir>", "raiz do projeto")
+    .action(async (o) => {
+    const { migrateNotes } = await import("./graph/migrate.js");
+    const r = await migrateNotes(rootOf(o), (m) => console.log(m));
+    if ("none" in r)
+        console.log(r.none);
+    else
+        console.log(`OK: ${r.found} nota(s) no banco antigo, ${r.added} copiada(s), ${r.skipped} já existiam. O .brito/graph.kuzu foi mantido; apague-o quando quiser.`);
+});
 program
     .command("query <cypher>")
     .description("Executa Cypher no grafo")
@@ -79,6 +91,14 @@ async function plainAsk(q) {
     rl.close();
     return /^(s|y)/i.test(a.trim());
 }
+/** Pergunta de sim/não (padrão: não) fora do REPL; só roda com terminal interativo. */
+async function migrationAsk(q) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    console.log(c.warn("⚠ ") + c.bold(c.soft(q)));
+    const a = await new Promise((r) => rl.question(c.muted("  copiar? [s]im/[N]ão: "), r));
+    rl.close();
+    return /^(s|y)/i.test(a.trim());
+}
 /** Sem API key: o `claude` oficial (login da assinatura) faz o modelo; grafo/memória/skills chegam via MCP. */
 /** Menus ↑↓+Enter do `/model`: modelo e depois escopo. null = cancelado. */
 async function pickModel(current) {
@@ -374,7 +394,11 @@ async function runViaClaude(root, promptParts, yes) {
     // O REPL troca `io.ask`; em prompt único cai na pergunta simples.
     const io = { ask: async (q, _opts) => perms.mode === "bypass" || plainAsk(q) };
     const approval = startApprovalServer({ ask: (q, opts) => io.ask(q, opts) });
-    // O kuzu aceita um único processo com acesso de escrita: indexa, lê as stats e solta o banco para o servidor MCP.
+    // O banco aceita um único processo com acesso de escrita: indexa, lê as stats e solta o banco para o servidor MCP.
+    {
+        const { offerNoteMigration } = await import("./graph/migrate.js");
+        await offerNoteMigration(root, (q) => migrationAsk(q), (m) => ui.info(m));
+    }
     const graph = await GraphStore.open(root);
     ui.info("sincronizando grafo…");
     await indexProject(root, graph);
@@ -465,6 +489,10 @@ program
     }
     const root = rootOf(o);
     const startedAt = Date.now();
+    {
+        const { offerNoteMigration } = await import("./graph/migrate.js");
+        await offerNoteMigration(root, (q) => migrationAsk(q), (m) => ui.info(m));
+    }
     const graph = await GraphStore.open(root);
     // A contagem do prompt acompanha cada sincronização: sem isso o modelo veria "0 símbolos" a sessão inteira
     // em projeto que começou vazio e nasceu código depois.

package/dist/desktop/serve.js

@@ -112,7 +112,7 @@ export async function serveDesktop(root, resumeId) {
     else {
         const approval = startApprovalServer({ ask });
         closeApproval = approval.close;
-        // O kuzu aceita um único processo com escrita: indexa, lê as stats e solta o banco para o servidor MCP.
+        // O banco aceita um único processo com escrita: indexa, lê as stats e solta o banco para o servidor MCP.
         if (!isHome)
             try {
                 const graph = await GraphStore.open(root);

package/dist/graph/indexer.js

@@ -237,6 +237,61 @@ const count = async (store, q) => Number((await store.run(q))[0].n);
  * como diff contra o banco.
  */
 export async function indexProject(root, store, opts = {}) {
+    const release = await acquireIndexLock(root, opts.onProgress);
+    try {
+        return await indexProjectLocked(root, store, opts);
+    }
+    finally {
+        release();
+    }
+}
+/**
+ * Só um indexador por projeto de cada vez (o banco solta o lock entre consultas, então sem isto dois
+ * indexadores se intercalariam e criariam os mesmos arquivos). Quem chega depois espera e, ao entrar,
+ * encontra o trabalho feito: o diff incremental fica vazio.
+ */
+async function acquireIndexLock(root, onProgress) {
+    const dir = path.join(root, ".brito");
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, "index.lock");
+    let warned = false;
+    for (;;) {
+        try {
+            fs.writeFileSync(file, `${process.pid} ${Date.now()}`, { flag: "wx" });
+            return () => { try {
+                fs.rmSync(file, { force: true });
+            }
+            catch { /* já removido */ } };
+        }
+        catch (e) {
+            if (e.code !== "EEXIST")
+                throw e;
+            const [pid, ts] = (() => { try {
+                return fs.readFileSync(file, "utf8").split(" ").map(Number);
+            }
+            catch {
+                return [NaN, NaN];
+            } })();
+            const alive = (() => { try {
+                process.kill(pid, 0);
+                return true;
+            }
+            catch (err) {
+                return err.code === "EPERM";
+            } })();
+            if (!alive || (Number.isFinite(ts) && Date.now() - ts > 30 * 60_000)) {
+                fs.rmSync(file, { force: true });
+                continue;
+            } // dono morreu ou travou
+            if (!warned) {
+                onProgress?.("outro Brito está indexando este projeto; aguardando…");
+                warned = true;
+            }
+            await new Promise((r) => setTimeout(r, 300));
+        }
+    }
+}
+async function indexProjectLocked(root, store, opts = {}) {
     const aliases = new Aliases(root);
     const current = await scan(root, aliases);
     if (opts.full)
@@ -299,6 +354,7 @@ export async function indexProject(root, store, opts = {}) {
             await store.run("MATCH (f:File {path:$f}), (s:Symbol {id:$id}) CREATE (f)-[:DEFINES]->(s)", { f: rel, id: s.id });
         }
         stored.set(rel, { hash, calls, imports: [...new Set(info.imports)], bindings });
+        await store.yieldIfWaited(); // dá a vez a outra sessão que só quer consultar
     }
     // 3. Recalcula arestas desejadas em memória (sem parsear) e aplica diff.
     const known = new Set(stored.keys());

package/dist/graph/migrate.js

@@ -0,0 +1,82 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { GraphStore } from "./store.js";
+const READER = `const k = require("kuzu");
+const db = new k.Database(process.argv[2], 0, true, true);
+const c = new k.Connection(db);
+c.query("MATCH (n:Note) RETURN n.id AS id, n.kind AS kind, n.text AS text, n.refs AS refs, n.ts AS ts").then((r) => r.getAll()).then((rows) => {
+  process.stdout.write(JSON.stringify(rows, (_, v) => (typeof v === "bigint" ? Number(v) : v)));
+  process.exit(0);
+});`;
+/** Copia as notas (memória) do grafo antigo (.brito/graph.kuzu) para o novo (.brito/graph.lbug).
+ *  O Kùzu só é instalado numa pasta temporária, durante esta chamada: o pacote principal não depende mais dele. */
+export async function migrateNotes(root, log = () => { }) {
+    const dir = path.join(root, ".brito");
+    const old = path.join(dir, "graph.kuzu");
+    if (!fs.existsSync(old))
+        return { none: "não há grafo antigo (.brito/graph.kuzu) neste projeto" };
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "brito-migrar-"));
+    try {
+        // cópia: o original fica intocado e o Kùzu não precisa de lock sobre ele
+        fs.copyFileSync(old, path.join(tmp, "g.kuzu"));
+        for (const ext of [".wal", ".shadow"])
+            if (fs.existsSync(old + ext))
+                fs.copyFileSync(old + ext, path.join(tmp, "g.kuzu" + ext));
+        fs.writeFileSync(path.join(tmp, "package.json"), '{"name":"brito-migrar","private":true}');
+        fs.writeFileSync(path.join(tmp, "read.cjs"), READER);
+        log("baixando o Kùzu (só para esta migração)…");
+        const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+        const inst = spawnSync(npm, ["i", "kuzu@0.11.3", "--no-audit", "--no-fund", "--loglevel=error"], { cwd: tmp, encoding: "utf8" });
+        if (inst.status !== 0)
+            throw new Error(`não consegui instalar o kuzu para ler o banco antigo:\n${inst.stderr || inst.error}`);
+        const run = spawnSync(process.execPath, ["read.cjs", "g.kuzu"], { cwd: tmp, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
+        if (run.status !== 0)
+            throw new Error(`falha ao ler as notas do banco antigo:\n${run.stderr}`);
+        const notes = JSON.parse(run.stdout || "[]");
+        const g = await GraphStore.open(root);
+        try {
+            let added = 0;
+            for (const n of notes) {
+                const [{ c }] = await g.run("MATCH (x:Note {id:$id}) RETURN count(x) AS c", { id: n.id });
+                if (Number(c) > 0)
+                    continue; // idempotente: rodar de novo não duplica
+                await g.run("CREATE (:Note {id:$id, kind:$k, text:$t, refs:$r, ts:$ts})", { id: n.id, k: n.kind, t: n.text, r: n.refs ?? [], ts: n.ts ?? 0 });
+                added++;
+            }
+            return { found: notes.length, added, skipped: notes.length - added };
+        }
+        finally {
+            await g.close();
+        }
+    }
+    finally {
+        fs.rmSync(tmp, { recursive: true, force: true });
+    }
+}
+const markerOf = (root) => path.join(root, ".brito", ".notas-migradas");
+/** Só no primeiro uso depois da troca de motor: há grafo antigo, ainda não há grafo novo e a pergunta não foi respondida. */
+export function pendingNoteMigration(root) {
+    const dir = path.join(root, ".brito");
+    return fs.existsSync(path.join(dir, "graph.kuzu")) && !fs.existsSync(path.join(dir, "graph.lbug")) && !fs.existsSync(markerOf(root));
+}
+/** Pergunta (uma vez por projeto) e migra as notas. Qualquer resposta, inclusive "não", encerra a pergunta; `brito migrar-notas` continua disponível. */
+export async function offerNoteMigration(root, ask, log) {
+    if (!process.stdin.isTTY || !pendingNoteMigration(root))
+        return;
+    const yes = await ask("Este projeto tem um grafo antigo (Kùzu), que pode ter notas (memória). Copiar as notas para o grafo novo? Baixa o Kùzu (~100 MB) só desta vez.");
+    fs.writeFileSync(markerOf(root), new Date().toISOString());
+    if (!yes) {
+        log("ok, nada copiado. Quando quiser: brito migrar-notas");
+        return;
+    }
+    try {
+        const r = await migrateNotes(root, log);
+        log("none" in r ? r.none : `${r.added} nota(s) copiada(s) do grafo antigo.`);
+    }
+    catch (e) {
+        fs.rmSync(markerOf(root), { force: true }); // falhou: pergunta de novo na próxima
+        log(`não consegui migrar as notas (${e.message.split("\n")[0]}). Tente: brito migrar-notas`);
+    }
+}

package/dist/graph/store.js

@@ -1,4 +1,4 @@
-import kuzu from "kuzu";
+import kuzu from "@ladybugdb/core";
 import fs from "node:fs";
 import path from "node:path";
 /** Lê as linhas e fecha cada QueryResult na hora: o finalizer do GC depois de db.close() derruba o processo (segfault). */
@@ -21,11 +21,15 @@ export class GraphLockedError extends Error {
     }
 }
 const isLockError = (e) => /could not set lock/i.test(String(e?.message ?? e));
+/** Outro processo está criando o banco ou fazendo checkpoint: o .shadow/.wal aparece, some ou fica negado por instantes (a mensagem muda por SO). Passa sozinho. */
+const isCreatingError = (e) => /shadow file|\.(shadow|wal)\b|checkpoint is in progress/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;
+const LOCK_WAIT_MS = 15_000;
 /** Tempo ocioso até soltar o banco: o lock só existe enquanto há consultas em andamento. */
-const IDLE_MS = 300;
+const IDLE_MS = 150;
+/** Intervalo máximo entre tentativas de quem espera o banco. */
+const RETRY_MAX_MS = 250;
 /** Cypher que altera o banco precisa do modo escrita; o resto abre somente leitura (vários processos em paralelo). */
 const WRITE_RE = /\b(CREATE|MERGE|SET|DELETE|REMOVE|DROP|ALTER|COPY|LOAD|INSTALL|ATTACH|DETACH)\b/i;
 export class GraphStore {
@@ -44,7 +48,12 @@ export class GraphStore {
     static async open(root, waitMs = LOCK_WAIT_MS) {
         const dir = path.join(root, ".brito");
         fs.mkdirSync(dir, { recursive: true });
-        const store = new GraphStore(path.join(dir, "graph.kuzu"), waitMs);
+        // O Ladybug (fork mantido do Kùzu) não lê o formato antigo: usa arquivo novo e deixa o graph.kuzu intocado.
+        const file = path.join(dir, "graph.lbug");
+        if (!fs.existsSync(file) && fs.existsSync(path.join(dir, "graph.kuzu"))) {
+            process.stderr.write("brito: o grafo mudou de motor (Kùzu → Ladybug); o código será reindexado. O banco antigo (.brito/graph.kuzu) foi mantido; para trazer as notas, rode `brito migrar-notas`.\n");
+        }
+        const store = new GraphStore(file, waitMs);
         await store.run("RETURN 1 AS ok", {}, true); // cria o banco e migra; solta o lock logo em seguida
         return store;
     }
@@ -65,6 +74,7 @@ export class GraphStore {
                 this.db = db;
                 this.conn = new kuzu.Connection(db);
                 this.mode = ro ? "r" : "w";
+                this.clearWaiting();
                 if (!ro && !this.migrated) {
                     await this.migrate();
                     this.migrated = true;
@@ -73,14 +83,45 @@ export class GraphStore {
             }
             catch (e) {
                 await this.release();
-                if (!isLockError(e))
+                const locked = isLockError(e);
+                if (!locked && !isCreatingError(e))
                     throw e;
                 if (Date.now() >= deadline)
-                    throw new GraphLockedError(this.file);
-                await sleep(100 + Math.random() * 150);
+                    throw locked ? new GraphLockedError(this.file) : e;
+                this.signalWaiting();
+                await sleep(100 + Math.random() * (RETRY_MAX_MS - 100));
             }
         }
     }
+    /** Sinal de que há processo esperando o banco: o arquivo é renovado a cada tentativa e vale poucos segundos. */
+    get waitingFile() { return path.join(path.dirname(this.file), "graph.waiting"); }
+    signalWaiting() { try {
+        fs.writeFileSync(this.waitingFile, String(process.pid));
+    }
+    catch { /* sem sinal: só perde a cortesia */ } }
+    clearWaiting() { try {
+        fs.rmSync(this.waitingFile, { force: true });
+    }
+    catch { /* idem */ } }
+    /** Para tarefas longas (indexação): se outro processo está esperando o banco, solta e dá a vez a ele. Barato quando ninguém espera. */
+    async yieldIfWaited() {
+        let age = Infinity;
+        try {
+            age = Date.now() - fs.statSync(this.waitingFile).mtimeMs;
+        }
+        catch {
+            return;
+        }
+        if (age > 2000)
+            return;
+        await this.queue.catch(() => undefined);
+        if (this.idle) {
+            clearTimeout(this.idle);
+            this.idle = null;
+        }
+        await this.release();
+        await sleep(RETRY_MAX_MS + 150); // mais que o intervalo de tentativa de quem espera: ele leva o banco
+    }
     async release() {
         const { conn, db } = this;
         this.conn = this.db = null;
@@ -118,12 +159,27 @@ export class GraphStore {
     /** Serializa as queries: leituras paralelas de subagentes dividem uma única Connection. */
     run(cypher, params = {}, forceWrite = false) {
         const next = this.queue.then(async () => {
-            await this.acquire(forceWrite || WRITE_RE.test(cypher));
-            try {
-                return await this.exec(cypher, params);
-            }
-            finally {
-                this.touch();
+            const write = forceWrite || WRITE_RE.test(cypher);
+            const deadline = Date.now() + this.waitMs;
+            for (;;) {
+                await this.acquire(write);
+                try {
+                    return await this.exec(cypher, params);
+                }
+                catch (e) {
+                    // o binding abre o banco de forma preguiçosa: o lock/checkpoint de outro processo pode estourar só aqui, antes de executar a query
+                    const locked = isLockError(e);
+                    if (!locked && !isCreatingError(e))
+                        throw e;
+                    await this.release();
+                    if (Date.now() >= deadline)
+                        throw locked ? new GraphLockedError(this.file) : e;
+                    this.signalWaiting();
+                    await sleep(100 + Math.random() * (RETRY_MAX_MS - 100));
+                }
+                finally {
+                    this.touch();
+                }
             }
         });
         this.queue = next.catch(() => undefined);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brito-cli",
-  "version": "0.5.2",
+  "version": "0.6.1",
   "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": {
@@ -21,9 +21,9 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.131.0",
+    "@ladybugdb/core": "0.21.2",
     "@modelcontextprotocol/sdk": "^1.32.0",
     "commander": "^14.0.3",
-    "kuzu": "^0.11.3",
     "string-width": "^8.3.0",
     "tinyglobby": "^0.2.17",
     "tree-sitter-wasms": "^0.1.13",