@adrive/cli 1.0.0 → 1.1.0

package/dist/lib/transcripts/codex.js

@@ -1,168 +1,130 @@
 import { promises as fs } from 'node:fs';
 import { join } from 'node:path';
-// OpenAI Codex CLI session format:
-//   ~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-<ISO-date>-<session-id>.jsonl
-//
-// The first line is a `session_meta` record carrying the session id, cli
-// version, cwd, and base instructions. Subsequent lines carry the turn
-// stream as `{ timestamp, type, payload }`. We extract user + assistant
-// text from `type: 'turn'` records (with `payload.role` + `payload.content`)
-// and from `type: 'response_item'` records (with `payload.type: 'message'`
-// and `payload.content[*].text`). Older Codex versions vary slightly; we
-// only require that text fields exist where we expect them and drop the
-// rest. Tool calls / reasoning / system events are skipped — agents only
-// need the natural-language turns.
-//
-// Per Codex finding #11, the on-disk format may shift between CLI versions.
-// The parser stays permissive: unknown record types are silently ignored
-// rather than crashing the ingest.
-const SESSION_ID_RE = /^rollout-.+-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i;
-async function walkRolloutFiles(root) {
-    // Walks the YYYY/MM/DD tree depth-first. Tolerant of missing dirs.
-    const acc = [];
-    let years;
+import { DocBuilder, asObj, asStr, jsonLines, mtimeOf, patchPaths, readText, toolSummary } from './util.js';
+// Codex CLI: ~/.codex/sessions/YYYY/MM/DD/rollout-<ts>-<uuid>.jsonl, with
+// older rollouts zstd-compressed to .jsonl.zst. Lines are
+// `{ timestamp, type, payload }`: session_meta (id, cwd), response_item
+// (message | function_call | custom_tool_call), and event_msg
+// item_completed whose FileChange item is the 0.160 file-edit signal. The
+// format shifts between CLI versions, so unknown records are ignored.
+const ROLLOUT_RE = /^rollout-.+-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl(?:\.zst)?$/i;
+// Codex injects environment/instruction dumps as user messages; a part that
+// is one whole <tag>...</tag> block is harness boilerplate, not the user.
+const BOILERPLATE_RE = /^\s*(?:<([a-z][\w-]*)[\s>][\s\S]*<\/\1>\s*$|# AGENTS\.md instructions)/i;
+async function readdirSafe(dir) {
     try {
-        years = await fs.readdir(root);
+        return await fs.readdir(dir);
     }
     catch {
         return [];
     }
-    for (const y of years) {
-        const ydir = join(root, y);
-        let months;
-        try {
-            months = await fs.readdir(ydir);
-        }
-        catch {
-            continue;
-        }
-        for (const m of months) {
-            const mdir = join(ydir, m);
-            let days;
-            try {
-                days = await fs.readdir(mdir);
-            }
-            catch {
-                continue;
-            }
-            for (const d of days) {
-                const ddir = join(mdir, d);
-                let files;
-                try {
-                    files = await fs.readdir(ddir);
-                }
-                catch {
-                    continue;
-                }
-                for (const f of files) {
-                    if (f.startsWith('rollout-') && f.endsWith('.jsonl')) {
-                        acc.push(join(ddir, f));
-                    }
+}
+async function walkRollouts(root) {
+    const acc = [];
+    for (const y of await readdirSafe(root)) {
+        for (const m of await readdirSafe(join(root, y))) {
+            for (const d of await readdirSafe(join(root, y, m))) {
+                const dir = join(root, y, m, d);
+                for (const f of await readdirSafe(dir)) {
+                    if (ROLLOUT_RE.test(f))
+                        acc.push(join(dir, f));
                 }
             }
         }
     }
     return acc;
 }
+function parseArgs(raw) {
+    if (typeof raw !== 'string')
+        return raw;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
 export const codexSource = {
     platform: 'codex',
     async enumerate({ home, since }) {
-        const root = join(home, '.codex', 'sessions');
-        const files = await walkRolloutFiles(root);
-        const out = [];
-        for (const full of files) {
-            let stat;
-            try {
-                stat = await fs.stat(full);
-            }
-            catch {
+        const byId = new Map();
+        for (const path of await walkRollouts(join(home, '.codex', 'sessions'))) {
+            const mtime = await mtimeOf(path);
+            if (!mtime || (since && mtime <= since))
                 continue;
-            }
-            if (since && stat.mtime <= since)
-                continue;
-            const base = full.split('/').pop() ?? full;
-            const idMatch = base.match(SESSION_ID_RE);
-            const sessionId = idMatch ? idMatch[1] : base.replace(/\.jsonl$/, '');
-            // `label` is best-effort — fill from the cwd in session_meta on parse.
-            out.push({
-                manifestKey: `codex:${sessionId}`,
-                sessionId,
-                path: full,
-                mtime: stat.mtime,
-                label: 'codex session',
-            });
+            const sessionId = ROLLOUT_RE.exec(path.split('/').pop())[1];
+            const prev = byId.get(sessionId);
+            if (!prev || prev.mtime < mtime)
+                byId.set(sessionId, { sessionId, path, mtime });
         }
-        return out.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+        return [...byId.values()].sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
     },
     async parseSession(entry) {
-        let raw;
-        try {
-            raw = await fs.readFile(entry.path, 'utf8');
-        }
-        catch {
+        const raw = await readText(entry.path);
+        if (raw === null)
             return null;
-        }
-        const turns = [];
+        const doc = new DocBuilder();
         let cwd;
-        for (const line of raw.split(/\r?\n/)) {
-            if (!line.trim())
+        let metaId;
+        for (const obj of jsonLines(raw)) {
+            const ts = asStr(obj.timestamp);
+            const payload = asObj(obj.payload) ?? {};
+            // Forked rollouts repeat their parents' session_meta after their own.
+            if (obj.type === 'session_meta') {
+                cwd ??= asStr(payload.cwd);
+                metaId ??= asStr(payload.id);
                 continue;
-            let obj;
-            try {
-                obj = JSON.parse(line);
             }
-            catch {
+            if (obj.type === 'event_msg' && payload.type === 'item_completed') {
+                const item = asObj(payload.item);
+                const changes = item?.type === 'FileChange' ? asObj(item.changes) : undefined;
+                if (changes) {
+                    const tools = Object.keys(changes).map((path) => {
+                        doc.touch(path);
+                        return { name: `file_${asStr(asObj(changes[path])?.type) ?? 'change'}`, path };
+                    });
+                    doc.addTurn('assistant', '', ts, tools);
+                }
                 continue;
             }
-            const type = obj.type ?? '';
-            const ts = obj.timestamp ?? undefined;
-            const payload = (obj.payload ?? {});
-            if (type === 'session_meta') {
-                const c = payload.cwd;
-                if (typeof c === 'string')
-                    cwd = c;
+            if (obj.type !== 'response_item' && obj.type !== 'turn')
+                continue;
+            if (payload.type === 'function_call') {
+                doc.addTurn('assistant', '', ts, [{ name: asStr(payload.name) ?? 'tool', summary: toolSummary(parseArgs(payload.arguments)) }]);
                 continue;
             }
-            // Two known shapes for natural-language turns:
-            //   1. payload.role + payload.content (string or array)
-            //   2. payload.type === 'message' with payload.content[*].text
-            let role;
-            let text = '';
-            if (typeof payload.role === 'string' && payload.content !== undefined) {
-                role = payload.role;
-                const c = payload.content;
-                if (typeof c === 'string')
-                    text = c;
-                else if (Array.isArray(c)) {
-                    for (const part of c) {
-                        if (typeof part === 'string')
-                            text += part;
-                        else if (part && typeof part === 'object' && 'text' in part) {
-                            text += String(part.text);
-                        }
-                    }
+            if (payload.type === 'custom_tool_call') {
+                const name = asStr(payload.name) ?? 'tool';
+                const input = asStr(payload.input) ?? '';
+                if (name === 'apply_patch') {
+                    const paths = patchPaths(input);
+                    for (const p of paths)
+                        doc.touch(p);
+                    doc.addTurn('assistant', '', ts, paths.map((path) => ({ name, path })));
                 }
-            }
-            else if (payload.type === 'message') {
-                const innerRole = payload.role;
-                if (typeof innerRole === 'string')
-                    role = innerRole;
-                const c = payload.content;
-                if (Array.isArray(c)) {
-                    for (const part of c) {
-                        if (part && typeof part === 'object' && 'text' in part) {
-                            text += String(part.text);
-                        }
-                    }
+                else {
+                    doc.addTurn('assistant', '', ts, [{ name, summary: toolSummary(input) }]);
                 }
+                continue;
             }
-            if (role && text.trim()) {
-                turns.push({ role, text, ts });
+            const role = asStr(payload.role);
+            if (role !== 'user' && role !== 'assistant')
+                continue;
+            if (payload.type !== 'message' && obj.type !== 'turn')
+                continue;
+            let text = '';
+            if (typeof payload.content === 'string') {
+                text = BOILERPLATE_RE.test(payload.content) ? '' : payload.content;
             }
+            else if (Array.isArray(payload.content)) {
+                for (const part of payload.content) {
+                    const t = asStr(asObj(part)?.text);
+                    if (t && !BOILERPLATE_RE.test(t))
+                        text += t;
+                }
+            }
+            doc.addTurn(role, text, ts);
         }
-        if (turns.length === 0)
-            return null;
-        const labeled = cwd ? { ...entry, label: cwd } : entry;
-        return { entry: labeled, turns };
+        return doc.build(metaId ? { ...entry, sessionId: metaId } : entry, cwd);
     },
 };

package/dist/lib/transcripts/cursor.js

@@ -1,23 +1,73 @@
-// Cursor stores chat history in a per-workspace SQLite database at
-//   ~/Library/Application Support/Cursor/User/workspaceStorage/<hash>/state.vscdb
-// (macOS) or the analogous path on Linux. Reading it requires `node:sqlite`
-// (Node 22.5+) or `better-sqlite3`. The CLI's `engines.node` is currently
-// `>=20` so neither is available out of the box.
-//
-// Per CEO plan D3 + Codex tension T3 + finding #11, this surface is brittle
-// reverse-engineering and intentionally kept narrow. The full implementation
-// lands in Phase 2.5 (tracked in TODOS.md). For now this source exposes a
-// clear error so users hit explicit "not yet" rather than silent zero hits.
-const CURSOR_NOT_IMPLEMENTED_MESSAGE = 'Cursor transcript ingestion is not yet available. Reading Cursor SQLite ' +
-    "history requires Node 22.5+ (node:sqlite) or a native dependency. " +
-    'Tracking under Phase 2.5 of the v1 plan.';
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+import { DocBuilder, asObj, asStr, jsonLines, mtimeOf, patchPaths, readText, toolSummary } from './util.js';
+// Cursor agent: ~/.cursor/projects/<path-slug>/agent-transcripts/<conv>/<conv>.jsonl
+// (or flat <conv>.jsonl). Lines are `{ role, message: { content: [...] } }`
+// with no timestamps and no cwd; sync falls back to the cwd the hook recorded
+// (see session-cwd.ts).
+const PATH_TOOLS = new Set(['Write', 'StrReplace', 'Delete']);
+const USER_QUERY_RE = /^\s*<user_query>\s*([\s\S]*?)\s*<\/user_query>\s*$/;
+async function readdirSafe(dir) {
+    try {
+        return await fs.readdir(dir);
+    }
+    catch {
+        return [];
+    }
+}
 export const cursorSource = {
     platform: 'cursor',
-    async enumerate(_opts) {
-        throw new Error(CURSOR_NOT_IMPLEMENTED_MESSAGE);
+    async enumerate({ home, since }) {
+        const root = join(home, '.cursor', 'projects');
+        const out = [];
+        for (const slug of await readdirSafe(root)) {
+            const dir = join(root, slug, 'agent-transcripts');
+            for (const name of await readdirSafe(dir)) {
+                const sessionId = name.replace(/\.jsonl$/, '');
+                const path = name.endsWith('.jsonl') ? join(dir, name) : join(dir, name, `${name}.jsonl`);
+                const mtime = await mtimeOf(path);
+                if (!mtime || (since && mtime <= since))
+                    continue;
+                out.push({ sessionId, path, mtime });
+            }
+        }
+        return out.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
     },
-    async parseSession(_entry) {
-        throw new Error(CURSOR_NOT_IMPLEMENTED_MESSAGE);
+    async parseSession(entry) {
+        const raw = await readText(entry.path);
+        if (raw === null)
+            return null;
+        const doc = new DocBuilder();
+        for (const obj of jsonLines(raw)) {
+            const role = asStr(obj.role);
+            if (role !== 'user' && role !== 'assistant')
+                continue;
+            const content = asObj(obj.message)?.content;
+            let text = typeof content === 'string' ? content : '';
+            const tools = [];
+            for (const part of Array.isArray(content) ? content : []) {
+                const p = asObj(part);
+                if (p?.type === 'text') {
+                    text += asStr(p.text) ?? '';
+                }
+                else if (p?.type === 'tool_use') {
+                    const name = asStr(p.name) ?? 'tool';
+                    if (name === 'ApplyPatch') {
+                        const input = typeof p.input === 'string' ? p.input : Object.values(asObj(p.input) ?? {}).filter((v) => typeof v === 'string').join('\n');
+                        const paths = patchPaths(input);
+                        for (const path of paths)
+                            doc.touch(path);
+                        tools.push(...(paths.length > 0 ? paths.map((path) => ({ name, path })) : [{ name }]));
+                    }
+                    else {
+                        const path = PATH_TOOLS.has(name) ? asStr(asObj(p.input)?.path) : undefined;
+                        doc.touch(path);
+                        tools.push(path ? { name, path } : { name, summary: toolSummary(p.input) });
+                    }
+                }
+            }
+            doc.addTurn(role, text.replace(USER_QUERY_RE, '$1'), undefined, tools);
+        }
+        return doc.build(entry);
     },
 };
-export { CURSOR_NOT_IMPLEMENTED_MESSAGE };

package/dist/lib/transcripts/gemini.js

@@ -0,0 +1,116 @@
+import { createHash } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+import { readSessionCwds } from '../session-cwd.js';
+import { DocBuilder, asObj, asStr, jsonLines, mtimeOf, readText, toolSummary } from './util.js';
+// Gemini CLI: ~/.gemini/tmp/<project_hash>/chats/session-*.jsonl, one message
+// record per line plus `$set`/`$patch`/`$rewindTo` meta lines; legacy chats
+// are a single .json `{ sessionId, messages }`. The project hash is sha256 of
+// the project root, so cwd is recovered by hashing cwds the hook recorded.
+const CHAT_RE = /^session-.+\.jsonl?$/;
+// Both formats put the session id first, so the head is enough to name a chat
+// without parsing it; enumerate, parse and the hook must agree on this id.
+const HEAD_BYTES = 16 * 1024;
+const SESSION_ID_RE = /"sessionId"\s*:\s*"([^"\\]+)"/;
+function sessionIdOf(head, path) {
+    return SESSION_ID_RE.exec(head)?.[1] ?? (path.split(/[\\/]/).pop() ?? path).replace(/^session-/, '').replace(/\.jsonl?$/, '');
+}
+async function readHead(path) {
+    const handle = await fs.open(path, 'r');
+    try {
+        const buf = Buffer.alloc(HEAD_BYTES);
+        const { bytesRead } = await handle.read(buf, 0, HEAD_BYTES, 0);
+        return buf.subarray(0, bytesRead).toString('utf8');
+    }
+    finally {
+        await handle.close();
+    }
+}
+const FILE_TOOLS = new Set(['write_file', 'replace']);
+function messageText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content.map((p) => (typeof p === 'string' ? p : asStr(asObj(p)?.text) ?? '')).join('');
+}
+function addMessage(doc, msg) {
+    if (msg.type !== 'user' && msg.type !== 'gemini')
+        return;
+    const tools = [];
+    for (const raw of Array.isArray(msg.toolCalls) ? msg.toolCalls : []) {
+        const call = asObj(raw);
+        const name = asStr(call?.name) ?? 'tool';
+        const args = asObj(call?.args);
+        const path = FILE_TOOLS.has(name) ? asStr(args?.file_path) : undefined;
+        doc.touch(path);
+        tools.push(path ? { name, path } : { name, summary: toolSummary(args) });
+    }
+    doc.addTurn(msg.type === 'user' ? 'user' : 'assistant', messageText(msg.content), asStr(msg.timestamp), tools);
+}
+export const geminiSource = {
+    platform: 'gemini-cli',
+    async enumerate({ home, since, configDir }) {
+        const tmp = join(home, '.gemini', 'tmp');
+        let hashes;
+        try {
+            hashes = await fs.readdir(tmp);
+        }
+        catch {
+            return [];
+        }
+        const cwdByHash = new Map();
+        for (const cwd of Object.values(configDir ? await readSessionCwds(configDir) : {})) {
+            cwdByHash.set(createHash('sha256').update(cwd).digest('hex'), cwd);
+        }
+        const out = [];
+        for (const h of hashes) {
+            let files;
+            try {
+                files = await fs.readdir(join(tmp, h, 'chats'));
+            }
+            catch {
+                continue;
+            }
+            for (const f of files) {
+                if (!CHAT_RE.test(f))
+                    continue;
+                const path = join(tmp, h, 'chats', f);
+                const mtime = await mtimeOf(path);
+                if (!mtime || (since && mtime <= since))
+                    continue;
+                const head = await readHead(path).catch(() => '');
+                out.push({ sessionId: sessionIdOf(head, path), path, mtime, cwd: cwdByHash.get(h) });
+            }
+        }
+        return out.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    },
+    async parseSession(entry) {
+        const raw = await readText(entry.path);
+        if (raw === null)
+            return null;
+        const doc = new DocBuilder();
+        if (entry.path.endsWith('.json')) {
+            let legacy;
+            try {
+                legacy = asObj(JSON.parse(raw));
+            }
+            catch {
+                return null;
+            }
+            for (const m of Array.isArray(legacy?.messages) ? legacy.messages : []) {
+                const msg = asObj(m);
+                if (msg)
+                    addMessage(doc, msg);
+            }
+        }
+        else {
+            for (const line of jsonLines(raw)) {
+                if ('$set' in line || '$patch' in line || '$rewindTo' in line)
+                    continue;
+                addMessage(doc, line);
+            }
+        }
+        return doc.build({ ...entry, sessionId: sessionIdOf(Buffer.from(raw).subarray(0, HEAD_BYTES).toString('utf8'), entry.path) });
+    },
+};

package/dist/lib/transcripts/opencode.js

@@ -0,0 +1,95 @@
+import { execFile } from 'node:child_process';
+import { DocBuilder, asObj, asStr, patchPaths, toolSummary } from './util.js';
+const EXEC_TIMEOUT_MS = 15_000;
+const defaultExec = (args, cwd) => new Promise((resolve, reject) => {
+    execFile('opencode', [...args, '--pure'], { cwd, timeout: EXEC_TIMEOUT_MS, maxBuffer: 256 * 1024 * 1024, encoding: 'utf8' }, (err, stdout) => (err ? reject(err) : resolve(stdout)));
+});
+function parseJson(out) {
+    const start = out.search(/[[{]/);
+    return start < 0 ? null : JSON.parse(out.slice(start));
+}
+function isoFromMs(ms) {
+    return typeof ms === 'number' ? new Date(ms).toISOString() : undefined;
+}
+function toolEntry(doc, name, input) {
+    if (name === 'write' || name === 'edit') {
+        const path = asStr(input?.filePath);
+        doc.touch(path);
+        return [path ? { name, path } : { name }];
+    }
+    if (name === 'patch' || name === 'apply_patch') {
+        const patch = Object.values(input ?? {}).filter((v) => typeof v === 'string').join('\n');
+        const paths = patchPaths(patch);
+        for (const p of paths)
+            doc.touch(p);
+        return paths.length > 0 ? paths.map((path) => ({ name, path })) : [{ name }];
+    }
+    return [{ name, summary: toolSummary(input) }];
+}
+export function createOpencodeSource(exec = defaultExec) {
+    return {
+        platform: 'opencode',
+        // shortcut: `opencode session list` only lists the project of `cwd`, so a
+        // sweep sees the sessions of the directory the hook fired in; reading
+        // OpenCode's storage directly would cover all projects.
+        async enumerate({ since, cwd }) {
+            let list;
+            try {
+                list = parseJson(await exec(['session', 'list', '--format', 'json'], cwd));
+            }
+            catch {
+                return [];
+            }
+            if (!Array.isArray(list))
+                return [];
+            const out = [];
+            for (const raw of list) {
+                const s = asObj(raw);
+                const id = asStr(s?.id);
+                const updated = s?.updated;
+                if (!id || typeof updated !== 'number')
+                    continue;
+                const mtime = new Date(updated);
+                if (since && mtime <= since)
+                    continue;
+                out.push({ sessionId: id, path: id, mtime, cwd: asStr(s?.directory) });
+            }
+            return out.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+        },
+        async parseSession(entry) {
+            let data;
+            try {
+                data = asObj(parseJson(await exec(['export', entry.sessionId], entry.cwd)));
+            }
+            catch {
+                return null;
+            }
+            if (!data)
+                return null;
+            const info = asObj(data.info);
+            const doc = new DocBuilder();
+            for (const rawMsg of Array.isArray(data.messages) ? data.messages : []) {
+                const msg = asObj(rawMsg);
+                const mInfo = asObj(msg?.info);
+                const role = asStr(mInfo?.role) ?? 'assistant';
+                const ts = isoFromMs(asObj(mInfo?.time)?.created);
+                let text = '';
+                const tools = [];
+                for (const rawPart of Array.isArray(msg?.parts) ? msg.parts : []) {
+                    const part = asObj(rawPart);
+                    if (!part || part.synthetic)
+                        continue;
+                    if (part.type === 'text')
+                        text += asStr(part.text) ?? '';
+                    else if (part.type === 'tool')
+                        tools.push(...toolEntry(doc, asStr(part.tool) ?? 'tool', asObj(asObj(part.state)?.input)));
+                }
+                doc.addTurn(role, text, ts, tools);
+            }
+            const updated = isoFromMs(asObj(info?.time)?.updated);
+            const entryOut = updated ? { ...entry, mtime: new Date(updated) } : entry;
+            return doc.build(entryOut, asStr(info?.directory), asStr(info?.title));
+        },
+    };
+}
+export const opencodeSource = createOpencodeSource();

package/dist/lib/transcripts/types.js

@@ -1,10 +1,10 @@
 // Functional TranscriptSource interface — per eng-review decision E4.
 //
 // A source knows two things:
-// 1. `enumerate(home, opts)` — find candidate session files on disk
-// 2. `parseSession(entry)` — turn one session file into a TranscriptDoc
+// 1. `enumerate(opts)` — find candidate sessions on disk
+// 2. `parseSession(entry)` — turn one session into a TranscriptDoc
 //
-// Everything else (redact, encrypt, manifest, upload) is centralized in
-// lib/transcripts/ingest.ts so each source stays small and the cross-cutting
-// concerns can't drift between platforms.
+// Everything else (redact, encrypt, manifest, upload, run upsert) is
+// centralized in lib/sync.ts so the cross-cutting concerns can't drift
+// between harnesses.
 export {};