brito-cli 0.5.0 → 0.5.1

package/dist/graph/indexer.js

@@ -38,7 +38,13 @@ function extract(root, lang, file) {
     const bindings = [];
     const isPy = lang === "python";
     const mk = (name, kind, n) => {
-        const s = { id: `${file}::${name}:${n.startPosition.row + 1}`, name, kind, file, startLine: n.startPosition.row + 1, endLine: n.endPosition.row + 1 };
+        const id = `${file}::${name}:${n.startPosition.row + 1}`;
+        const dup = syms.find((x) => x.id === id); // getter+setter (ou overloads) na mesma linha: id único
+        if (dup) {
+            dup.endLine = Math.max(dup.endLine, n.endPosition.row + 1);
+            return dup;
+        }
+        const s = { id, name, kind, file, startLine: n.startPosition.row + 1, endLine: n.endPosition.row + 1 };
         syms.push(s);
         return s;
     };

package/dist/graph/langs.js

@@ -373,7 +373,13 @@ export function extractLang(root, lang, file) {
     const syms = [], calls = [];
     const acc = { imports: [], bindings: [] };
     const mk = (name, kind, n) => {
-        const s = { id: `${file}::${name}:${n.startPosition.row + 1}`, name, kind, file, startLine: n.startPosition.row + 1, endLine: n.endPosition.row + 1 };
+        const id = `${file}::${name}:${n.startPosition.row + 1}`;
+        const dup = syms.find((x) => x.id === id); // getter+setter (ou overloads) na mesma linha: id único
+        if (dup) {
+            dup.endLine = Math.max(dup.endLine, n.endPosition.row + 1);
+            return dup;
+        }
+        const s = { id, name, kind, file, startLine: n.startPosition.row + 1, endLine: n.endPosition.row + 1 };
         syms.push(s);
         return s;
     };

package/dist/graph/store.js

@@ -15,9 +15,8 @@ async function drain(r, read = true) {
 /** 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.");
+        super(`Outro processo do Brito está gravando no grafo deste projeto (${file}) há mais tempo que o esperado.\n` +
+            "As sessões soltam o banco quando ficam ociosas; uma indexação longa em outro terminal pode segurá-lo. Espere ela terminar e tente de novo.");
         this.name = "GraphLockedError";
     }
 }
@@ -25,35 +24,82 @@ 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;
+/** Tempo ocioso até soltar o banco: o lock só existe enquanto há consultas em andamento. */
+const IDLE_MS = 300;
+/** 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 {
-    db;
-    conn;
+    db = null;
+    conn = null;
+    mode = null;
+    idle = null;
+    migrated = false;
     queue = Promise.resolve();
-    constructor(db, conn) {
-        this.db = db;
-        this.conn = conn;
+    file;
+    waitMs;
+    constructor(file, waitMs) {
+        this.file = file;
+        this.waitMs = waitMs;
     }
     static async open(root, waitMs = LOCK_WAIT_MS) {
         const dir = path.join(root, ".brito");
         fs.mkdirSync(dir, { recursive: true });
-        const file = path.join(dir, "graph.kuzu");
-        const deadline = Date.now() + waitMs;
+        const store = new GraphStore(path.join(dir, "graph.kuzu"), waitMs);
+        await store.run("RETURN 1 AS ok", {}, true); // cria o banco e migra; solta o lock logo em seguida
+        return store;
+    }
+    /** Abre (ou promove) o banco no modo pedido, esperando o lock de outro processo. Roda dentro da fila. */
+    async acquire(write) {
+        if (this.idle) {
+            clearTimeout(this.idle);
+            this.idle = null;
+        }
+        if (this.db && (this.mode === "w" || !write))
+            return;
+        await this.release(); // leitura -> escrita: fecha antes de reabrir
+        const deadline = Date.now() + this.waitMs;
         for (;;) {
             try {
-                const db = new kuzu.Database(file);
-                const store = new GraphStore(db, new kuzu.Connection(db));
-                await store.migrate();
-                return store;
+                const ro = !write && fs.existsSync(this.file) && this.migrated;
+                const db = ro ? new kuzu.Database(this.file, 0, true, true) : new kuzu.Database(this.file);
+                this.db = db;
+                this.conn = new kuzu.Connection(db);
+                this.mode = ro ? "r" : "w";
+                if (!ro && !this.migrated) {
+                    await this.migrate();
+                    this.migrated = true;
+                }
+                return;
             }
             catch (e) {
+                await this.release();
                 if (!isLockError(e))
                     throw e;
                 if (Date.now() >= deadline)
-                    throw new GraphLockedError(file);
-                await sleep(250);
+                    throw new GraphLockedError(this.file);
+                await sleep(100 + Math.random() * 150);
             }
         }
     }
+    async release() {
+        const { conn, db } = this;
+        this.conn = this.db = null;
+        this.mode = null;
+        try {
+            await conn?.close();
+        }
+        catch { /* já fechado */ }
+        try {
+            await db?.close();
+        }
+        catch { /* já fechado */ }
+    }
+    touch() {
+        if (this.idle)
+            clearTimeout(this.idle);
+        this.idle = setTimeout(() => { this.queue = this.queue.then(() => this.release()).catch(() => undefined); }, IDLE_MS);
+        this.idle.unref();
+    }
     async migrate() {
         const ddl = [
             "CREATE NODE TABLE IF NOT EXISTS File(path STRING, lang STRING, hash STRING, calls STRING[], imports STRING[], bindings STRING[], PRIMARY KEY(path))",
@@ -70,19 +116,28 @@ export class GraphStore {
             await drain(await this.conn.query(`ALTER TABLE File ADD IF NOT EXISTS ${col} STRING[] DEFAULT []`), false);
     }
     /** Serializa as queries: leituras paralelas de subagentes dividem uma única Connection. */
-    run(cypher, params = {}) {
-        const next = this.queue.then(() => this.exec(cypher, params));
+    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();
+            }
+        });
         this.queue = next.catch(() => undefined);
         return next;
     }
     async exec(cypher, params) {
+        const conn = this.conn;
         if (Object.keys(params).length === 0) {
-            return drain(await this.conn.query(cypher));
+            return drain(await conn.query(cypher));
         }
-        const ps = await this.conn.prepare(cypher);
+        const ps = await conn.prepare(cypher);
         if (!ps.isSuccess())
             throw new Error(ps.getErrorMessage());
-        return drain(await this.conn.execute(ps, params));
+        return drain(await conn.execute(ps, params));
     }
     /** Apaga só o grafo de código; notas (memória) são preservadas. */
     async clearCode() {
@@ -90,7 +145,11 @@ export class GraphStore {
         await this.run("MATCH (f:File) DETACH DELETE f");
     }
     async close() {
-        await this.conn.close();
-        await this.db.close();
+        await this.queue.catch(() => undefined);
+        if (this.idle) {
+            clearTimeout(this.idle);
+            this.idle = null;
+        }
+        await this.release();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brito-cli",
-  "version": "0.5.0",
+  "version": "0.5.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": {