combobulator 0.1.0

package/src/sources/claude.js

@@ -0,0 +1,144 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+import { PATHS, MIRROR_MARKER } from '../config.js';
+
+// Walk ~/.claude/projects/*/{sessionId}.jsonl. Return [{path, mtime}] sorted newest first.
+export function listClaudeSessions() {
+  if (!fs.existsSync(PATHS.claudeProjects)) return [];
+  const out = [];
+  for (const projDir of fs.readdirSync(PATHS.claudeProjects)) {
+    const full = path.join(PATHS.claudeProjects, projDir);
+    let stat;
+    try { stat = fs.statSync(full); } catch { continue; }
+    if (!stat.isDirectory()) continue;
+    for (const f of fs.readdirSync(full)) {
+      if (!f.endsWith('.jsonl')) continue;
+      const fp = path.join(full, f);
+      try {
+        const s = fs.statSync(fp);
+        out.push({ path: fp, mtime: s.mtimeMs, projDir });
+      } catch {}
+    }
+  }
+  return out.sort((a, b) => b.mtime - a.mtime);
+}
+
+// Read a Claude session and emit a typed event stream that the codex sink can
+// translate into native function_call / custom_tool_call events.
+//
+// Event kinds:
+//   {kind: 'user', text, ts}         — real human prompt
+//   {kind: 'assistant', text, ts}    — assistant natural-language reply
+//   {kind: 'tool_call', tool, input, callId, ts} — assistant tool invocation
+//   {kind: 'tool_result', callId, output, isError, ts} — paired tool response
+//
+// Tool calls and tool results are matched by Claude's tool_use_id, so the sink
+// can render them as the proper Codex events with matching call_id.
+export async function readClaudeSession(filePath) {
+  const stream = fs.createReadStream(filePath, { encoding: 'utf8' });
+  const rl = readline.createInterface({ input: stream });
+
+  const events = [];
+  let sessionId = path.basename(filePath, '.jsonl');
+  let cwd = null;
+  let createdAt = null;
+  let updatedAt = null;
+  let isMirror = false;
+  let threadName = null;
+
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    let d;
+    try { d = JSON.parse(line); } catch { continue; }
+
+    if (d[MIRROR_MARKER]) { isMirror = true; continue; }
+
+    if (d.sessionId && !sessionId) sessionId = d.sessionId;
+    if (d.cwd && !cwd) cwd = d.cwd;
+    if (d.timestamp) {
+      const t = Date.parse(d.timestamp);
+      if (Number.isFinite(t)) {
+        if (createdAt === null) createdAt = t;
+        updatedAt = t;
+      }
+    }
+
+    if (d.type === 'ai-title' && d.aiTitle) {
+      threadName = d.aiTitle;
+      continue;
+    }
+
+    const ts = Date.parse(d.timestamp) || Date.now();
+
+    if (d.type === 'user' && d.message?.role === 'user') {
+      // Walk content blocks. A Claude user message can be a mix of plain text
+      // (real prompt) and tool_result blocks (responses to prior tool calls).
+      // Emit each as its own event so the sink can interleave them correctly.
+      const content = d.message.content;
+      if (typeof content === 'string') {
+        const t = content.trim();
+        if (t) events.push({ kind: 'user', text: t, ts });
+      } else if (Array.isArray(content)) {
+        for (const c of content) {
+          if (c?.type === 'text' && c.text) {
+            events.push({ kind: 'user', text: c.text, ts });
+          } else if (c?.type === 'tool_result') {
+            const output = typeof c.content === 'string'
+              ? c.content
+              : Array.isArray(c.content)
+                ? c.content.map((x) => (typeof x === 'string' ? x : x?.text || '')).join('\n')
+                : '';
+            events.push({
+              kind: 'tool_result',
+              callId: c.tool_use_id,
+              output,
+              isError: !!c.is_error,
+              ts,
+            });
+          }
+        }
+      }
+    } else if (d.type === 'assistant' && d.message?.role === 'assistant') {
+      const content = d.message.content;
+      if (typeof content === 'string') {
+        const t = content.trim();
+        if (t) events.push({ kind: 'assistant', text: t, ts });
+      } else if (Array.isArray(content)) {
+        for (const c of content) {
+          if (c?.type === 'text' && c.text) {
+            events.push({ kind: 'assistant', text: c.text, ts });
+          } else if (c?.type === 'tool_use') {
+            events.push({
+              kind: 'tool_call',
+              tool: c.name,
+              input: c.input,
+              callId: c.id,
+              ts,
+            });
+          }
+          // Skip 'thinking' blocks — internal monologue, not for rendering.
+        }
+      }
+    }
+  }
+
+  // Back-compat: also derive a flat "messages" list (user text + assistant text)
+  // for any code that still expects the old shape (claude sink, title extraction).
+  const messages = events
+    .filter((e) => e.kind === 'user' || e.kind === 'assistant')
+    .map((e) => ({ role: e.kind, text: e.text, ts: e.ts }));
+
+  return {
+    source: 'claude',
+    sessionId,
+    cwd,
+    threadName,
+    createdAt: createdAt ?? Date.now(),
+    updatedAt: updatedAt ?? Date.now(),
+    events,
+    messages,
+    isMirror,
+    sourcePath: filePath,
+  };
+}

package/src/sources/codex.js

@@ -0,0 +1,93 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+import { PATHS, MIRROR_MARKER } from '../config.js';
+
+// Walk ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl recursively.
+export function listCodexSessions() {
+  const root = PATHS.codexSessions;
+  if (!fs.existsSync(root)) return [];
+  const out = [];
+  walk(root, out);
+  return out.sort((a, b) => b.mtime - a.mtime);
+}
+
+function walk(dir, out) {
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+  for (const e of entries) {
+    const full = path.join(dir, e.name);
+    if (e.isDirectory()) walk(full, out);
+    else if (e.isFile() && e.name.endsWith('.jsonl') && e.name.startsWith('rollout-')) {
+      try {
+        const s = fs.statSync(full);
+        out.push({ path: full, mtime: s.mtimeMs });
+      } catch {}
+    }
+  }
+}
+
+export async function readCodexSession(filePath) {
+  const stream = fs.createReadStream(filePath, { encoding: 'utf8' });
+  const rl = readline.createInterface({ input: stream });
+
+  const messages = [];
+  let sessionId = null;
+  let cwd = null;
+  let createdAt = null;
+  let updatedAt = null;
+  let isMirror = false;
+  let threadName = null;
+
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    let d;
+    try { d = JSON.parse(line); } catch { continue; }
+
+    // Old top-level marker (legacy rollout format) — still detect for cleanup
+    if (d[MIRROR_MARKER]) { isMirror = true; continue; }
+
+    if (d.timestamp) {
+      const t = Date.parse(d.timestamp);
+      if (Number.isFinite(t)) {
+        if (createdAt === null) createdAt = t;
+        updatedAt = t;
+      }
+    }
+
+    if (d.type === 'session_meta') {
+      if (d.payload?.id) sessionId = d.payload.id;
+      if (d.payload?.cwd) cwd = d.payload.cwd;
+      // Detect new and legacy marker locations.
+      if (d.payload?.originator === 'combobulate') isMirror = true;
+      if (d.payload?.combobulate?.[MIRROR_MARKER]) isMirror = true;
+    } else if (d.type === 'event_msg') {
+      const p = d.payload;
+      if (p?.type === 'user_message' && typeof p.message === 'string') {
+        messages.push({ role: 'user', text: p.message.trim(), ts: Date.parse(d.timestamp) || Date.now() });
+      } else if (p?.type === 'agent_message' && typeof p.message === 'string') {
+        messages.push({ role: 'assistant', text: p.message.trim(), ts: Date.parse(d.timestamp) || Date.now() });
+      } else if (p?.type === 'thread_name_updated' && p.thread_name) {
+        threadName = p.thread_name;
+      }
+    }
+  }
+
+  // Filter out the auto-injected <environment_context> prelude — first user message
+  // is almost always the env block. We keep only "real" user text.
+  const filtered = messages.filter(
+    (m, i) => !(i === 0 && m.role === 'user' && m.text.startsWith('<environment_context>'))
+  );
+
+  return {
+    source: 'codex',
+    sessionId: sessionId || path.basename(filePath, '.jsonl'),
+    cwd,
+    threadName,
+    createdAt: createdAt ?? Date.now(),
+    updatedAt: updatedAt ?? Date.now(),
+    messages: filtered,
+    isMirror,
+    sourcePath: filePath,
+  };
+}

package/src/sources/cursor.js

@@ -0,0 +1,102 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs from 'node:fs';
+import { PATHS } from '../config.js';
+
+const execFileP = promisify(execFile);
+
+// Query Cursor's sqlite db read-only. We use the system `sqlite3` CLI with `mode=ro`
+// so we never hold a write lock against Cursor's running process.
+async function sqlite(query) {
+  if (!fs.existsSync(PATHS.cursorDb)) return [];
+  // Use file: URI with mode=ro for read-only opening; immutable=1 avoids touching the journal.
+  const uri = `file:${PATHS.cursorDb}?mode=ro&immutable=1`;
+  const { stdout } = await execFileP('sqlite3', ['-json', uri, query], {
+    maxBuffer: 256 * 1024 * 1024,
+  });
+  if (!stdout.trim()) return [];
+  try { return JSON.parse(stdout); } catch { return []; }
+}
+
+// List Cursor composers (chats) sorted newest-first by lastUpdatedAt.
+export async function listCursorComposers() {
+  const rows = await sqlite(
+    `SELECT key,
+            json_extract(value, '$.composerId') as id,
+            json_extract(value, '$.name') as name,
+            json_extract(value, '$.lastUpdatedAt') as updatedAt,
+            json_extract(value, '$.createdAt') as createdAt
+       FROM cursorDiskKV
+      WHERE key LIKE 'composerData:%'
+      ORDER BY updatedAt DESC NULLS LAST
+      LIMIT 200;`
+  );
+  return rows.map((r) => ({
+    id: r.id,
+    name: r.name,
+    createdAt: Number(r.createdAt) || 0,
+    updatedAt: Number(r.updatedAt) || 0,
+  }));
+}
+
+// Read one composer + all its bubbles, return UnifiedSession.
+export async function readCursorComposer(composerId) {
+  const headerRows = await sqlite(
+    `SELECT value FROM cursorDiskKV WHERE key = 'composerData:${composerId}' LIMIT 1;`
+  );
+  if (!headerRows.length) return null;
+
+  let header;
+  try { header = JSON.parse(headerRows[0].value); } catch { return null; }
+
+  const bubbleOrder = (header.fullConversationHeadersOnly || []).map((h) => h.bubbleId);
+  if (!bubbleOrder.length) {
+    return {
+      source: 'cursor',
+      sessionId: composerId,
+      cwd: null,
+      threadName: header.name || null,
+      createdAt: Number(header.createdAt) || Date.now(),
+      updatedAt: Number(header.lastUpdatedAt) || Date.now(),
+      messages: [],
+      isMirror: false,
+      sourcePath: `cursor:${composerId}`,
+    };
+  }
+
+  // Pull all bubbles for this composer in one query.
+  const bubbleRows = await sqlite(
+    `SELECT substr(key, ${('bubbleId:' + composerId + ':').length + 1}) as bid,
+            json_extract(value, '$.type') as bt,
+            json_extract(value, '$.text') as text,
+            json_extract(value, '$.richText') as richText
+       FROM cursorDiskKV
+      WHERE key LIKE 'bubbleId:${composerId}:%';`
+  );
+
+  const byId = new Map();
+  for (const r of bubbleRows) byId.set(r.bid, r);
+
+  const messages = [];
+  for (const bid of bubbleOrder) {
+    const b = byId.get(bid);
+    if (!b) continue;
+    const role = b.bt === 1 ? 'user' : b.bt === 2 ? 'assistant' : null;
+    if (!role) continue;
+    const text = (b.text || '').trim();
+    if (!text) continue;
+    messages.push({ role, text, ts: Number(header.lastUpdatedAt) || Date.now() });
+  }
+
+  return {
+    source: 'cursor',
+    sessionId: composerId,
+    cwd: null,
+    threadName: header.name || null,
+    createdAt: Number(header.createdAt) || Date.now(),
+    updatedAt: Number(header.lastUpdatedAt) || Date.now(),
+    messages,
+    isMirror: false,
+    sourcePath: `cursor:${composerId}`,
+  };
+}

package/src/state.js

@@ -0,0 +1,70 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { PATHS } from './config.js';
+
+// Persistent state file shape:
+// {
+//   epoch: number,         // unix ms; sessions older than this are "pre-existing" and ignored
+//   mirrors: {
+//     "<source>/<sessionId>": {
+//        sourceFingerprint: "<hash of msg count + last ts>",
+//        targets: {
+//          claude?: { sessionId, filePath },
+//          codex?: { sessionId, filePath }
+//        }
+//     }
+//   }
+// }
+
+let cache = null;
+
+function emptyState() {
+  return { epoch: Date.now(), mirrors: {} };
+}
+
+export function loadState() {
+  if (cache) return cache;
+  try {
+    const raw = fs.readFileSync(PATHS.combobulateState, 'utf8');
+    cache = JSON.parse(raw);
+    if (!cache.mirrors) cache.mirrors = {};
+    if (!cache.epoch) cache.epoch = Date.now();
+  } catch {
+    cache = emptyState();
+  }
+  return cache;
+}
+
+export function saveState() {
+  if (!cache) return;
+  fs.mkdirSync(PATHS.combobulateDir, { recursive: true });
+  const tmp = PATHS.combobulateState + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify(cache, null, 2));
+  fs.renameSync(tmp, PATHS.combobulateState);
+}
+
+export function resetEpoch() {
+  loadState();
+  cache.epoch = Date.now();
+  saveState();
+}
+
+export function getMirror(sourceKey) {
+  loadState();
+  return cache.mirrors[sourceKey];
+}
+
+export function setMirror(sourceKey, value) {
+  loadState();
+  cache.mirrors[sourceKey] = value;
+  saveState();
+}
+
+export function fingerprintMessages(messages) {
+  const h = crypto.createHash('sha1');
+  for (const m of messages) {
+    h.update(`${m.role}|${m.ts || 0}|${(m.text || '').slice(0, 256)}\n`);
+  }
+  return `${messages.length}:${h.digest('hex').slice(0, 16)}`;
+}