lucid-mem 0.3.1 → 0.4.0

package/README.md

@@ -25,6 +25,7 @@ amr add "I prefer concise summaries"          # global memory
 amr add "uses Kokoro-82M for TTS" --project   # this repo's memory
 amr search "tts"
 amr link other-repo       # auto-attach another repo's memory to sessions here
+amr peer add <url>        # compose a teammate's memory repo into your context
 amr discover              # which hot repos still lack memory
 amr dream --fix --compact # dedupe + archive overflow
 ```

package/lib/cli.mjs

@@ -7,6 +7,7 @@ import {
   cmdEnsure,
   cmdIndex,
   cmdLink,
+  cmdPeer,
   cmdPolicy,
   cmdRemote,
   cmdSearch,
@@ -33,6 +34,7 @@ usage: amr <command> [args] [flags]
   link <name...> [--for <p>]    auto-attach other repos' memories to this repo's sessions
   unlink <name...> [--for <p>]  remove auto-attach links
   policy [name key bool]        per-repo policy: noglobal, private (no args = list)
+  peer [add <url>|remove <n>]   attach another memory repo (multiplayer); clones into <AMR_HOME>-peers
   remote [set <url>]            show or set the git remote (private repos only)
   sync                          pull --rebase + push (no-op without a remote)
   doctor                        check repo, PATH, and per-host wiring
@@ -115,6 +117,8 @@ export function main(argv) {
         return cmdUnlink(pos, flags);
       case 'policy':
         return cmdPolicy(pos);
+      case 'peer':
+        return cmdPeer(pos, flags);
       case 'remote':
         return cmdRemote(pos);
       case 'sync':

package/lib/commands.mjs

@@ -27,6 +27,17 @@ import {
 const out = (s = '') => process.stdout.write(s + '\n');
 const err = (s) => process.stderr.write(s + '\n');
 
+// Peer memory repos (amr.json extraRepos): separate memory repos cloned
+// read-only next to AMR_HOME so teammates' memories compose into context
+// without merging repos. Never written to — sync only pulls them.
+const peerRoot = (home) =>
+  path.join(path.dirname(home), `${path.basename(home)}-peers`);
+const peerDir = (home, name) => path.join(peerRoot(home), name);
+const peerNameOf = (url) =>
+  normName(
+    path.basename(String(url).replace(/[\\/]+$/, '')).replace(/\.git$/i, '')
+  ) || 'peer';
+
 function mdFilesUnder(home, absDir) {
   const files = [];
   (function walk(dir) {
@@ -138,6 +149,40 @@ export function cmdContext(flags) {
       '',
       `<!-- ${unknown.length} linked project name(s) unresolved (no memory file): ${unknown.join(', ')} -->`
     );
+  // Peer repos: other memory repos attached via `amr peer add`. Each
+  // contributes its global digest plus its own copy of the current
+  // project's file — the multiplayer case (teammate memory for the
+  // same repo). Bounded: max 3 peers, 10 global + 8 project bullets.
+  const missingPeers = [];
+  for (const p of (cfg.extraRepos || []).slice(0, 3)) {
+    const dir = peerDir(home, p.name);
+    const pm = path.join(dir, 'MEMORY.md');
+    if (!fs.existsSync(pm)) {
+      missingPeers.push(p.name);
+      continue;
+    }
+    const g = cap(
+      bullets(
+        fs.readFileSync(pm, 'utf8').split(/^##\s+Index\s*$/m)[0] || ''
+      ),
+      10
+    );
+    if (g.length)
+      lines.push('', `## Peer: ${p.name} (read-only)`, g.join('\n'));
+    if (proj) {
+      const pf = path.join(dir, 'projects', `${proj.slug}.md`);
+      if (fs.existsSync(pf)) {
+        const pb = cap(bullets(fs.readFileSync(pf, 'utf8')), 8);
+        if (pb.length)
+          lines.push(`### ${p.name} memory for this project`, pb.join('\n'));
+      }
+    }
+  }
+  if (missingPeers.length)
+    lines.push(
+      '',
+      `<!-- configured peer(s) not cloned: ${missingPeers.join(', ')} — run amr peer -->`
+    );
   // Recall pointer: archive/ holds compacted (oldest) entries —
   // searchable but never session-injected.
   const adir = path.join(home, 'archive');
@@ -345,8 +390,80 @@ export function cmdRemote(args) {
   out(r.stdout || 'no remote configured');
 }
 
+export function cmdPeer(args, flags) {
+  const home = ensureRepo();
+  const cfg = loadConfig(home);
+  const peers = (cfg.extraRepos ||= []);
+  const [sub, ...rest] = args;
+
+  if (!sub) {
+    if (!peers.length)
+      return out('no peers configured — amr peer add <url-or-path>');
+    for (const p of peers) {
+      const dir = peerDir(home, p.name);
+      out(
+        `${p.name}: ${p.url} -> ${
+          fs.existsSync(dir) ? `${dir} (cloned)` : 'NOT CLONED'
+        }`
+      );
+    }
+    return;
+  }
+
+  if (sub === 'add') {
+    let url = rest[0];
+    if (!url)
+      throw new Error('usage: amr peer add <url-or-path> [--name x]');
+    // Bare local paths resolve against cwd, not the peer root.
+    if (!/^[a-z]+:\/\/|^git@|^ssh:/i.test(url)) url = path.resolve(url);
+    const name = normName(flags.name || peerNameOf(url));
+    if (peers.some((p) => p.name === name))
+      throw new Error(`peer "${name}" already configured`);
+    const dir = peerDir(home, name);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(peerRoot(home), { recursive: true });
+      const r = git(peerRoot(home), ['clone', '--depth', '50', '--', url, dir], {
+        timeout: 120000,
+      });
+      if (r.code !== 0)
+        throw new Error(`clone failed: ${(r.stderr || '').trim()}`);
+    }
+    if (!fs.existsSync(path.join(dir, 'MEMORY.md')))
+      err('warning: no MEMORY.md in clone — may not be an agent memory repo');
+    peers.push({ name, url });
+    saveConfig(home, cfg);
+    commit(home, ['amr.json'], `Add memory peer: ${name}`);
+    out(`peer ${name} -> ${dir}`);
+    return;
+  }
+
+  if (sub === 'remove') {
+    const name = normName(rest[0] || '');
+    const i = peers.findIndex((p) => p.name === name);
+    if (i < 0) throw new Error(`unknown peer "${rest[0] || ''}"`);
+    peers.splice(i, 1);
+    if (!peers.length) delete cfg.extraRepos;
+    saveConfig(home, cfg);
+    commit(home, ['amr.json'], `Remove memory peer: ${name}`);
+    out(`detached peer ${name}; clone left at ${peerDir(home, name)}`);
+    return;
+  }
+
+  throw new Error('usage: amr peer [add <url> [--name x] | remove <name>]');
+}
+
 export function cmdSync() {
   const home = ensureRepo();
+  // Refresh read-only peer clones first; a stale peer is a warn, not a
+  // blocker for syncing our own memory.
+  const cfg = loadConfig(home);
+  for (const p of cfg.extraRepos || []) {
+    const dir = peerDir(home, p.name);
+    if (!fs.existsSync(dir)) continue;
+    const r = git(dir, ['pull', '--ff-only'], { timeout: 10000 });
+    if (r.code !== 0)
+      err(`peer ${p.name} pull failed: ${(r.stderr || '').trim()}`);
+  }
   if (!hasRemote(home)) return out('no remote configured; local only');
   const hasUpstream =
     git(home, ['rev-parse', '--abbrev-ref', '@{u}']).code === 0;

package/lib/harvest.mjs

@@ -1,3 +1,4 @@
+import { createRequire } from 'node:module';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -75,8 +76,102 @@ const SOURCES = [
     ],
     ext: ['.jsonl', '.json'],
   },
+  {
+    host: 'opencode',
+    roots: [
+      path.join(home, '.local', 'share', 'opencode'),
+      path.join(localappdata, 'opencode'),
+    ],
+    ext: ['.db'],
+    match: /^opencode\.db$/i,
+  },
+  {
+    host: 'antigravity',
+    roots: [path.join(home, '.gemini', 'antigravity', 'conversations')],
+    ext: ['.db'],
+  },
+  // windsurf: Cascade keeps conversations in protobuf/leveldb under
+  // %APPDATA%/Windsurf and embedding blobs under ~/.codeium/database;
+  // no user-message transcript store to harvest.
 ];
 
+// node:sqlite is built in from Node 22.5; DB sources degrade silently
+// on older runtimes (file-based hosts keep working). Lazy require so
+// the ExperimentalWarning never pollutes non-harvest invocations.
+let DatabaseSync;
+const loadSqlite = () => {
+  if (DatabaseSync !== undefined) return DatabaseSync;
+  try {
+    DatabaseSync = createRequire(import.meta.url)('node:sqlite').DatabaseSync;
+  } catch {
+    DatabaseSync = null;
+  }
+  return DatabaseSync;
+};
+
+const openDb = (p) => {
+  const DS = loadSqlite();
+  if (!DS) return null;
+  try {
+    return new DS(p, { readOnly: true });
+  } catch {
+    return null;
+  }
+};
+
+// Antigravity step payloads are protobuf serialized as {"0":byte,...}.
+// step_type 14 is the user message; pull printable runs out of the
+// bytes and drop ID-shaped strings (uuids, base64url tokens).
+const agyUserText = (payload) => {
+  let buf;
+  if (Buffer.isBuffer(payload) || payload instanceof Uint8Array) {
+    buf = Buffer.from(payload);
+  } else {
+    let obj;
+    try {
+      obj = typeof payload === 'string' ? JSON.parse(payload) : payload;
+    } catch {
+      return '';
+    }
+    if (!obj || typeof obj !== 'object') return '';
+    buf = Buffer.from(Object.values(obj));
+  }
+  const text = buf.toString('utf8');
+  const runs =
+    text.match(/[ -~\u00a0-\u2fff\ue000-\ufffc]{15,}/g) || [];
+  // Keep prose runs: several words, mostly letters, little punctuation
+  // junk, no filename dumps or injected <TAG> blobs. The protobuf echoes
+  // the user string twice inside one payload; collapse the repeat.
+  const JUNK = /[-_$/\\*{}<>="#|~`@^[\]]/g;
+  const seen = new Set();
+  const kept = [];
+  for (const raw of runs) {
+    let t = raw
+      .trim()
+      .replace(/^[^\w<]+/, '')
+      .replace(/^[A-Z](?=[A-Z][a-z])/, '');
+    for (let len = t.length >> 1; len >= 15; len--) {
+      const i = t.indexOf(t.slice(0, len), 1);
+      if (i > 0) {
+        t = t.slice(0, i).replace(/\s+\S{1,4}["']?$/, '').trim();
+        break;
+      }
+    }
+    t = t.replace(/["'\s]+$/, '').trim();
+    if (t.split(/\s+/).filter(Boolean).length < 3) continue;
+    if (!/[a-z]/.test(t)) continue;
+    if (/^<[A-Za-z_][A-Za-z0-9_-]*[\s>]/.test(t)) continue;
+    if (/\.(png|jpe?g|gif|webp|exe|dll|db|md|json|log)\b/i.test(t))
+      continue;
+    if ((t.match(/[A-Za-z]/g) || []).length / t.length < 0.5) continue;
+    if ((t.match(JUNK) || []).length / t.length > 0.3) continue;
+    if (seen.has(t)) continue;
+    seen.add(t);
+    kept.push(t);
+  }
+  return kept.join(' ');
+};
+
 const MAX_PER_HOST = 100;
 
 // ---------- transcript extraction ----------
@@ -188,6 +283,47 @@ const EXTRACT = {
       out.push(clean(meta.prompt.replace(/<[^>]+>/g, ' ')));
     return out;
   },
+  // opencode keeps sessions in drizzle sqlite: message.data.role +
+  // part.data joined on message_id; text parts carry user prose.
+  opencode(p, since = 0) {
+    const db = openDb(p);
+    if (!db) return [];
+    try {
+      return db
+        .prepare(
+          `select p.data d from part p
+           join message m on p.message_id = m.id
+           where json_extract(m.data,'$.role') = 'user'
+             and json_extract(p.data,'$.type') = 'text'
+             and m.time_created >= ?
+           order by m.time_created`
+        )
+        .all(since)
+        .map((r) => clean(JSON.parse(r.d).text))
+        .filter((t) => !isNoise(t));
+    } catch {
+      return [];
+    } finally {
+      db.close();
+    }
+  },
+  // antigravity stores one sqlite trajectory db per conversation;
+  // steps.step_type 14 rows carry the user prompt as protobuf bytes.
+  antigravity(p) {
+    const db = openDb(p);
+    if (!db) return [];
+    try {
+      return db
+        .prepare('select step_payload from steps where step_type = 14')
+        .all()
+        .map((r) => clean(agyUserText(r.step_payload)))
+        .filter((t) => !isNoise(t));
+    } catch {
+      return [];
+    } finally {
+      db.close();
+    }
+  },
   generic(p) {
     if (p.endsWith('.jsonl'))
       return parseJsonl(p)
@@ -228,7 +364,8 @@ export function collectSessions(since) {
           if (e.isDirectory()) walk(p);
           else if (
             e.isFile() &&
-            src.ext.includes(path.extname(e.name).toLowerCase())
+            src.ext.includes(path.extname(e.name).toLowerCase()) &&
+            (!src.match || src.match.test(e.name))
           ) {
             try {
               const st = fs.statSync(p);
@@ -252,14 +389,17 @@ export function collectSessions(since) {
 }
 
 // Normalize found transcript files to their user-message streams.
-export function extractMessages(found, { max = 200, min = 15 } = {}) {
+export function extractMessages(
+  found,
+  { max = 200, min = 15, since = 0 } = {}
+) {
   const msgs = [];
   for (const f of found) {
     if (msgs.length >= max) break;
     const ext = EXTRACT[f.host] || EXTRACT.generic;
     let texts = [];
     try {
-      texts = ext(f.path).slice(0, MAX_PER_FILE);
+      texts = ext(f.path, since).slice(0, MAX_PER_FILE);
     } catch {
       continue;
     }
@@ -287,7 +427,7 @@ export function cmdHarvest(flags) {
   if (flags.extract) {
     const max = numFlag(flags.max || '200', 200);
     const min = numFlag(flags.min || '15', 15);
-    const msgs = extractMessages(found, { max, min });
+    const msgs = extractMessages(found, { max, min, since });
     if (flags.json) return out(JSON.stringify(msgs, null, 2));
     for (const m of msgs)
       out(

package/lib/install.mjs

@@ -737,6 +737,14 @@ export function cmdDoctor() {
     }
     if (dead.length)
       out(`config      : ${dead.length} unresolvable project key(s): ${dead.join(', ')}`);
+    const missingPeers = (cfg.extraRepos || []).filter(
+      (p) =>
+        !fs.existsSync(
+          path.join(path.dirname(homeDir), `${path.basename(homeDir)}-peers`, p.name)
+        )
+    );
+    if (missingPeers.length)
+      out(`peers       : ${missingPeers.map((p) => p.name).join(', ')} configured but not cloned`);
   }
   const onPath =
     sh('where', ['amr']).code === 0 || sh('which', ['amr']).code === 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lucid-mem",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "lucid-mem (amr) - autonomous git-backed agent memory (Agent Memory Repo spec)",
   "type": "module",
   "bin": {

package/test/peer-dbharvest.test.mjs

@@ -0,0 +1,159 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  run,
+  tmpdir,
+  initRepo,
+  git,
+  read,
+} from './helpers.mjs';
+
+const { DatabaseSync } = await import('node:sqlite').catch(() => ({}));
+const hasSqlite = !!DatabaseSync;
+
+function setup() {
+  const amrHome = tmpdir();
+  const fakeHome = tmpdir();
+  const r = run(['ensure'], { amrHome, fakeHome });
+  assert.equal(r.status, 0, r.stderr);
+  return { amrHome, fakeHome };
+}
+
+function initPeerRepo(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+  git(dir, ['init', '-b', 'main']);
+  fs.writeFileSync(
+    path.join(dir, 'MEMORY.md'),
+    '# Memory\n\n- teammate global fact: prefers tabs over spaces [added: 2026-01-01]\n'
+  );
+  git(dir, [
+    '-c', 'user.email=t@t.dev', '-c', 'user.name=t',
+    'add', '-A',
+  ]);
+  git(dir, [
+    '-c', 'user.email=t@t.dev', '-c', 'user.name=t',
+    'commit', '-m', 'mem',
+  ]);
+  return dir;
+}
+
+test('peer add clones and lists; remove detaches', () => {
+  const { amrHome, fakeHome } = setup();
+  const peerSrc = initPeerRepo(path.join(tmpdir(), 'teammate-mem'));
+  let r = run(['peer', 'add', peerSrc], { amrHome, fakeHome });
+  assert.equal(r.status, 0, r.stderr);
+  assert.match(r.stdout, /peer teammate-mem/);
+  assert.ok(
+    fs.existsSync(
+      path.join(path.dirname(amrHome), `${path.basename(amrHome)}-peers`, 'teammate-mem', 'MEMORY.md')
+    )
+  );
+  r = run(['peer'], { amrHome, fakeHome });
+  assert.match(r.stdout, /teammate-mem.*cloned/);
+  r = run(['peer', 'remove', 'teammate-mem'], { amrHome, fakeHome });
+  assert.equal(r.status, 0, r.stderr);
+  r = run(['peer'], { amrHome, fakeHome });
+  assert.match(r.stdout, /no peers configured/);
+});
+
+test('context composes peer global + matching project memory', () => {
+  const { amrHome, fakeHome } = setup();
+  // Seed a project in OUR repo so the slug exists.
+  const repo = initRepo(path.join(tmpdir(), 'projx'));
+  run(['add', 'our project note', '--project'], {
+    amrHome, fakeHome, cwd: repo,
+  });
+  const slug = fs
+    .readdirSync(path.join(amrHome, 'projects'))
+    .find((f) => f.endsWith('.md'))
+    .replace(/\.md$/, '');
+  // Peer carries its own memory file for the same slug.
+  const peerSrc = initPeerRepo(path.join(tmpdir(), 'workmate'));
+  fs.mkdirSync(path.join(peerSrc, 'projects'));
+  fs.writeFileSync(
+    path.join(peerSrc, 'projects', `${slug}.md`),
+    `# Project: projx\n\n- teammate project note: api uses v2 endpoints [added: 2026-01-01]\n`
+  );
+  git(peerSrc, [
+    '-c', 'user.email=t@t.dev', '-c', 'user.name=t',
+    'add', '-A',
+  ]);
+  git(peerSrc, [
+    '-c', 'user.email=t@t.dev', '-c', 'user.name=t',
+    'commit', '-m', 'add proj',
+  ]);
+  const r = run(['peer', 'add', peerSrc], { amrHome, fakeHome });
+  assert.equal(r.status, 0, r.stderr);
+  const ctx = run(['context', repo], { amrHome, fakeHome });
+  assert.equal(ctx.status, 0, ctx.stderr);
+  assert.match(ctx.stdout, /## Peer: workmate \(read-only\)/);
+  assert.match(ctx.stdout, /prefers tabs over spaces/);
+  assert.match(ctx.stdout, /### workmate memory for this project/);
+  assert.match(ctx.stdout, /api uses v2 endpoints/);
+});
+
+test('context flags configured-but-missing peer clones', () => {
+  const { amrHome, fakeHome } = setup();
+  const peerSrc = initPeerRepo(path.join(tmpdir(), 'gonemate'));
+  run(['peer', 'add', peerSrc], { amrHome, fakeHome });
+  fs.rmSync(
+    path.join(path.dirname(amrHome), `${path.basename(amrHome)}-peers`, 'gonemate'),
+    { recursive: true, force: true }
+  );
+  const ctx = run(['context'], { amrHome, fakeHome });
+  assert.match(ctx.stdout, /configured peer\(s\) not cloned: gonemate/);
+});
+
+test('harvest extracts opencode sqlite user messages', { skip: !hasSqlite }, () => {
+  const { amrHome, fakeHome } = setup();
+  const dir = path.join(fakeHome, '.local', 'share', 'opencode');
+  fs.mkdirSync(dir, { recursive: true });
+  const db = new DatabaseSync(path.join(dir, 'opencode.db'));
+  db.exec(
+    'create table message(id text, session_id text, time_created integer, data text);' +
+      'create table part(id text, message_id text, session_id text, time_created integer, data text);'
+  );
+  db.prepare('insert into message values (?,?,?,?)').run(
+    'm1', 's1', Date.now(),
+    JSON.stringify({ role: 'user' })
+  );
+  db.prepare('insert into part values (?,?,?,?,?)').run(
+    'p1', 'm1', 's1', Date.now(),
+    JSON.stringify({ type: 'text', text: 'please fix the flaky login test in CI' })
+  );
+  db.close();
+  const r = run(['harvest', '--days', '7', '--extract'], {
+    amrHome, fakeHome,
+  });
+  assert.equal(r.status, 0, r.stderr);
+  assert.match(r.stdout, /\[opencode\].*flaky login test/);
+});
+
+test('harvest extracts antigravity protobuf user prompts', { skip: !hasSqlite }, () => {
+  const { amrHome, fakeHome } = setup();
+  const dir = path.join(fakeHome, '.gemini', 'antigravity', 'conversations');
+  fs.mkdirSync(dir, { recursive: true });
+  const db = new DatabaseSync(path.join(dir, 'conv1.db'));
+  db.exec('create table steps(idx integer, step_type integer, step_payload blob)');
+  // Protobuf-ish bytes: tag + uuid junk + the user string as a printable run.
+  const payload = Buffer.concat([
+    Buffer.from([0x08, 0x0e, 0x32, 0x03]),
+    Buffer.from('b$85b47905-028a-4ca9-bd54-0a36d1d712fa\x00'),
+    Buffer.from('why does the build cache never invalidate on rename'),
+    Buffer.from([0x00, 0x01, 0x02]),
+  ]);
+  db.prepare('insert into steps values (?,?,?)').run(0, 14, payload);
+  // A tool step should be ignored.
+  db.prepare('insert into steps values (?,?,?)').run(
+    1, 8, Buffer.from('{"AbsolutePath":"d:/x/y.md","EndLine":100,"toolAction":"Listing dir contents here"}')
+  );
+  db.close();
+  const r = run(['harvest', '--days', '7', '--extract'], {
+    amrHome, fakeHome,
+  });
+  assert.equal(r.status, 0, r.stderr);
+  assert.match(r.stdout, /\[antigravity\].*build cache never invalidate/);
+  assert.doesNotMatch(r.stdout, /Listing dir contents/);
+});