reconvo 0.1.0

package/dist/cli.js

@@ -0,0 +1,1818 @@
+#!/usr/bin/env node
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/db/index.ts
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { existsSync, mkdirSync } from "node:fs";
+import duckdb from "duckdb";
+function ensureDir() {
+  const dir = dirname(INDEX_PATH);
+  if (!existsSync(dir))
+    mkdirSync(dir, { recursive: true });
+}
+function getDb() {
+  if (!_db) {
+    ensureDir();
+    _db = new duckdb.Database(INDEX_PATH);
+  }
+  return _db;
+}
+function getConn() {
+  if (!_conn) {
+    _conn = getDb().connect();
+  }
+  return _conn;
+}
+function query(sql, ...params) {
+  return new Promise((resolve, reject) => {
+    const conn = getConn();
+    const cb = (err, rows) => {
+      if (err)
+        reject(err);
+      else
+        resolve(rows ?? []);
+    };
+    if (params.length > 0) {
+      conn.all(sql, ...params, cb);
+    } else {
+      conn.all(sql, cb);
+    }
+  });
+}
+function exec(sql) {
+  return new Promise((resolve, reject) => {
+    const conn = getConn();
+    conn.exec(sql, (err) => {
+      if (err)
+        reject(err);
+      else
+        resolve();
+    });
+  });
+}
+async function ensureSchema() {
+  await exec(`
+    CREATE TABLE IF NOT EXISTS source_file (
+      path VARCHAR PRIMARY KEY,
+      source VARCHAR NOT NULL,       -- 'claude-code' or 'opencode'
+      mtime_ms BIGINT NOT NULL,
+      indexed_at TIMESTAMP DEFAULT current_timestamp
+    )
+  `);
+  await exec(`
+    CREATE TABLE IF NOT EXISTS session (
+      id VARCHAR PRIMARY KEY,
+      source VARCHAR NOT NULL,
+      directory VARCHAR NOT NULL,
+      branch VARCHAR,
+      title VARCHAR,
+      parent_id VARCHAR,
+      started_at BIGINT,
+      last_at BIGINT,
+      message_count INTEGER DEFAULT 0
+    )
+  `);
+  await exec(`
+    CREATE TABLE IF NOT EXISTS message (
+      session_id VARCHAR NOT NULL,
+      role VARCHAR NOT NULL,
+      content VARCHAR NOT NULL,
+      timestamp_ms BIGINT,
+      position INTEGER NOT NULL,
+      model VARCHAR,
+      output_tokens BIGINT DEFAULT 0,
+      cache_read BIGINT DEFAULT 0,
+      cache_write BIGINT DEFAULT 0
+    )
+  `);
+  await exec(`CREATE INDEX IF NOT EXISTS idx_message_session ON message(session_id)`);
+  await exec(`CREATE INDEX IF NOT EXISTS idx_session_directory ON session(directory)`);
+  await exec(`CREATE INDEX IF NOT EXISTS idx_session_last ON session(last_at DESC)`);
+}
+async function getFileMtime(path) {
+  const rows = await query(`SELECT mtime_ms FROM source_file WHERE path = ?`, path);
+  return rows.length > 0 ? Number(rows[0].mtime_ms) : null;
+}
+async function setFileMtime(path, source, mtimeMs) {
+  const escaped = path.replace(/'/g, "''");
+  await exec(`DELETE FROM source_file WHERE path = '${escaped}'`);
+  await exec(`INSERT INTO source_file (path, source, mtime_ms, indexed_at) VALUES ('${escaped}', '${source}', ${mtimeMs}, current_timestamp)`);
+}
+async function upsertSession(s) {
+  await exec(`DELETE FROM session WHERE id = '${s.id}'`);
+  await exec(`
+    INSERT INTO session (id, source, directory, branch, title, parent_id, started_at, last_at, message_count)
+    VALUES (
+      '${s.id}',
+      '${s.source}',
+      '${s.directory.replace(/'/g, "''")}',
+      ${s.branch ? `'${s.branch.replace(/'/g, "''")}'` : "NULL"},
+      '${(s.title ?? "").replace(/\x00/g, "").replace(/'/g, "''")}',
+      ${s.parentId ? `'${s.parentId}'` : "NULL"},
+      ${s.startedAt},
+      ${s.lastAt},
+      ${s.messageCount}
+    )
+  `);
+}
+async function replaceMessages(sessionId, messages) {
+  await exec(`DELETE FROM message WHERE session_id = '${sessionId}'`);
+  for (const m of messages) {
+    const content = m.content.replace(/\x00/g, "").replace(/'/g, "''");
+    const title = m.model ? `'${m.model}'` : "NULL";
+    try {
+      await exec(`INSERT INTO message (session_id, role, content, timestamp_ms, position, model, output_tokens, cache_read, cache_write) ` + `VALUES ('${sessionId}', '${m.role}', '${content}', ${m.timestampMs}, ${m.position}, ${title}, ${m.outputTokens ?? 0}, ${m.cacheRead ?? 0}, ${m.cacheWrite ?? 0})`);
+    } catch {}
+  }
+}
+var INDEX_DIR, INDEX_PATH, _db = null, _conn = null;
+var init_db = __esm(() => {
+  INDEX_DIR = join(homedir(), ".local", "share", "reconvo");
+  INDEX_PATH = process.env.RECONVO_INDEX ?? join(INDEX_DIR, "index.duckdb");
+});
+
+// src/util/ansi.ts
+function write(s) {
+  process.stdout.write(s);
+}
+var ESC2 = "\x1B", CSI2, ansi2, TREE;
+var init_ansi = __esm(() => {
+  CSI2 = `${ESC2}[`;
+  ansi2 = {
+    clear: `${CSI2}2J${CSI2}H`,
+    cursorHide: `${CSI2}?25l`,
+    cursorShow: `${CSI2}?25h`,
+    altScreen: `${CSI2}?1049h`,
+    mainScreen: `${CSI2}?1049l`,
+    moveTo: (row, col) => `${CSI2}${row};${col}H`,
+    eraseLine: `${CSI2}2K`,
+    bold: `${CSI2}1m`,
+    dim: `${CSI2}2m`,
+    italic: `${CSI2}3m`,
+    inverse: `${CSI2}7m`,
+    reset: `${CSI2}0m`,
+    faint: `${CSI2}90m`,
+    cyan: `${CSI2}36m`,
+    yellow: `${CSI2}33m`
+  };
+  TREE = { pipe: "│", tee: "├", corner: "└", dash: "─", bullet: "●", dot: "○" };
+});
+
+// src/db/queries.ts
+function esc2(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "''").replace(/\x00/g, "");
+}
+async function listSessions2(opts) {
+  const limit = opts?.limit ?? 50;
+  const conditions = [];
+  if (opts?.source) {
+    conditions.push(`source = '${esc2(opts.source)}'`);
+  }
+  if (opts?.scopePaths?.length) {
+    const conds = opts.scopePaths.map((p) => `directory LIKE '${esc2(p)}%'`).join(" OR ");
+    conditions.push(`(${conds})`);
+  }
+  if (opts?.sinceMs) {
+    conditions.push(`last_at >= ${opts.sinceMs}`);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = await query(`
+    SELECT id, source, directory, branch, title, parent_id, started_at, last_at, message_count
+    FROM session
+    ${where}
+    ORDER BY last_at DESC
+    LIMIT ${limit}
+  `);
+  return rows.map((r) => ({
+    id: r.id,
+    source: r.source,
+    directory: r.directory,
+    branch: r.branch,
+    title: r.title ?? "(no title)",
+    parentId: r.parent_id ?? null,
+    startedAt: Number(r.started_at),
+    lastAt: Number(r.last_at),
+    messageCount: Number(r.message_count)
+  }));
+}
+async function readMessages2(sessionPrefix, opts) {
+  let from = opts?.from;
+  let to = opts?.to;
+  if (opts?.around !== undefined) {
+    const radius = opts?.radius ?? 3;
+    from = Math.max(0, opts.around - radius);
+    to = opts.around + radius + 1;
+  }
+  const conditions = [`session_id LIKE '${esc2(sessionPrefix)}%'`];
+  if (from !== undefined)
+    conditions.push(`position >= ${from}`);
+  if (to !== undefined)
+    conditions.push(`position < ${to}`);
+  if (opts?.role === "user" || opts?.role === "assistant") {
+    conditions.push(`role = '${opts.role}'`);
+  }
+  const rows = await query(`
+    SELECT session_id, role, content, timestamp_ms, position
+    FROM message
+    WHERE ${conditions.join(" AND ")}
+    ORDER BY position ASC
+  `);
+  return rows.map((r) => ({
+    sessionId: r.session_id,
+    role: r.role,
+    content: r.content,
+    timestamp: Number(r.timestamp_ms),
+    position: Number(r.position)
+  }));
+}
+var init_queries = __esm(() => {
+  init_db();
+});
+
+// src/browse/tree.ts
+function makeSessionNode(s, depth = 0) {
+  return { kind: "session", session: s, children: [], depth };
+}
+async function loadTree(scopePaths) {
+  const allSessions = await listSessions2({ scopePaths, limit: 500 });
+  const byDir = new Map;
+  for (const s of allSessions) {
+    const existing = byDir.get(s.directory);
+    if (existing)
+      existing.push(s);
+    else
+      byDir.set(s.directory, [s]);
+  }
+  const projects = [];
+  for (const [dir, sessions] of byDir) {
+    const name = dir.split("/").pop() ?? dir;
+    const branch = sessions.find((s) => s.branch)?.branch ?? null;
+    const sessionNodes = sessions.map((s) => makeSessionNode(s));
+    projects.push({
+      kind: "project",
+      directory: dir,
+      name,
+      branch,
+      sessions: sessionNodes
+    });
+  }
+  projects.sort((a, b) => {
+    const aLast = Math.max(...a.sessions.map((s) => s.session.lastAt));
+    const bLast = Math.max(...b.sessions.map((s) => s.session.lastAt));
+    return bLast - aLast;
+  });
+  const treeRows = buildRows(projects);
+  const lineageProjects = buildLineageProjects(byDir);
+  const lineageRows = buildRows(lineageProjects);
+  const flatRows = treeRows.filter((r) => r.node.kind === "session").sort((a, b) => {
+    const aTime = a.node.session.lastAt;
+    const bTime = b.node.session.lastAt;
+    return bTime - aTime;
+  });
+  return { projects, treeRows, lineageRows, flatRows };
+}
+function buildLineageProjects(byDir) {
+  const projects = [];
+  for (const [dir, sessions] of byDir) {
+    let buildNode = function(s, depth) {
+      const node = makeSessionNode(s, depth);
+      const kids = childrenOf.get(s.id) ?? [];
+      node.children = kids.sort((a, b) => a.startedAt - b.startedAt).map((k) => buildNode(k, depth + 1));
+      return node;
+    };
+    const name = dir.split("/").pop() ?? dir;
+    const branch = sessions.find((s) => s.branch)?.branch ?? null;
+    const byId = new Map;
+    const childrenOf = new Map;
+    for (const s of sessions) {
+      byId.set(s.id, s);
+      if (s.parentId) {
+        const siblings = childrenOf.get(s.parentId);
+        if (siblings)
+          siblings.push(s);
+        else
+          childrenOf.set(s.parentId, [s]);
+      }
+    }
+    const roots = sessions.filter((s) => !s.parentId || !byId.has(s.parentId));
+    const rootNodes = roots.sort((a, b) => b.lastAt - a.lastAt).map((s) => buildNode(s, 0));
+    projects.push({
+      kind: "project",
+      directory: dir,
+      name,
+      branch,
+      sessions: rootNodes
+    });
+  }
+  projects.sort((a, b) => {
+    const aLast = Math.max(...a.sessions.map((s) => s.session.lastAt));
+    const bLast = Math.max(...b.sessions.map((s) => s.session.lastAt));
+    return bLast - aLast;
+  });
+  return projects;
+}
+function buildRows(projects) {
+  const rows = [];
+  for (let pi = 0;pi < projects.length; pi++) {
+    let addSessions = function(nodes, isLastProj) {
+      for (let si = 0;si < nodes.length; si++) {
+        const node = nodes[si];
+        const isLastSibling = si === nodes.length - 1 && node.children.length === 0;
+        rows.push({
+          node,
+          projectIdx: pi,
+          isLast: isLastSibling,
+          isLastProject: isLastProj
+        });
+        if (node.children.length > 0) {
+          addSessions(node.children, isLastProj);
+        }
+      }
+    };
+    const proj = projects[pi];
+    const isLastProject = pi === projects.length - 1;
+    rows.push({
+      node: proj,
+      projectIdx: pi,
+      isLast: false,
+      isLastProject
+    });
+    addSessions(proj.sessions, isLastProject);
+  }
+  return rows;
+}
+var init_tree = __esm(() => {
+  init_queries();
+});
+
+// src/util/fmt.ts
+function ago(ms) {
+  if (!ms)
+    return "";
+  const diff = Date.now() - ms;
+  const mins = Math.floor(diff / 60000);
+  if (mins < 60)
+    return `${mins}m`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24)
+    return `${hours}h`;
+  return `${Math.floor(hours / 24)}d`;
+}
+function clockTime(ms) {
+  if (!ms)
+    return "";
+  const d = new Date(ms);
+  const now = new Date;
+  const time = timeFmt2.format(d);
+  if (d.toDateString() === now.toDateString())
+    return time;
+  if (d.getFullYear() === now.getFullYear())
+    return `${dateFmt2.format(d)} ${time}`;
+  return `${yearFmt2.format(d)} ${time}`;
+}
+function visibleLength(s) {
+  return s.replace(ANSI_RE, "").length;
+}
+function truncate(s, max) {
+  if (max <= 0)
+    return "";
+  if (visibleLength(s) <= max)
+    return s;
+  let visible = 0;
+  let i = 0;
+  while (i < s.length && visible < max - 1) {
+    if (s[i] === "\x1B") {
+      const end = s.indexOf("m", i);
+      i = end >= 0 ? end + 1 : i + 1;
+    } else {
+      visible++;
+      i++;
+    }
+  }
+  return `${s.slice(0, i)}${ansi2.reset}…`;
+}
+var ANSI_RE, timeFmt2, dateFmt2, yearFmt2;
+var init_fmt = __esm(() => {
+  init_ansi();
+  ANSI_RE = /\x1b\[[0-9;]*m/g;
+  timeFmt2 = new Intl.DateTimeFormat(undefined, { hour: "numeric", minute: "2-digit" });
+  dateFmt2 = new Intl.DateTimeFormat(undefined, { month: "short", day: "numeric" });
+  yearFmt2 = new Intl.DateTimeFormat(undefined, { month: "short", day: "numeric", year: "2-digit" });
+});
+
+// src/util/clipboard.ts
+async function copyToClipboard(text) {
+  const candidates = process.platform === "darwin" ? [["pbcopy"]] : process.platform === "win32" ? [["clip"]] : [["xclip", "-selection", "clipboard"], ["xsel", "--clipboard", "--input"]];
+  for (const [cmd, ...args] of candidates) {
+    if (!Bun.which(cmd))
+      continue;
+    const proc = Bun.spawn([cmd, ...args], {
+      stdin: new Response(text),
+      stdout: "ignore",
+      stderr: "ignore"
+    });
+    const code = await proc.exited;
+    return code === 0;
+  }
+  return false;
+}
+
+// src/browse/tui.ts
+var exports_tui = {};
+__export(exports_tui, {
+  browse: () => browse
+});
+function renderTree(state) {
+  const { rows, cursor, scroll, termWidth, termHeight } = state;
+  const treeWidth = Math.min(Math.floor(termWidth * 0.5), 60);
+  const previewWidth = termWidth - treeWidth - 3;
+  const visibleRows = termHeight - 2;
+  write(ansi2.cursorHide);
+  write(ansi2.moveTo(1, 1));
+  write(ansi2.eraseLine);
+  const modeLabel = state.viewMode;
+  write(`${ansi2.bold}reconvo${ansi2.reset}${ansi2.dim}  browse  ${modeLabel}  ${rows.length} items${ansi2.reset}`);
+  for (let vi = 0;vi < visibleRows; vi++) {
+    const ri = vi + scroll;
+    const row = rows[ri];
+    write(ansi2.moveTo(vi + 2, 1));
+    write(ansi2.eraseLine);
+    if (!row)
+      continue;
+    const isSelected = ri === cursor;
+    if (state.viewMode === "recent") {
+      const s = row.node.session;
+      const ageStr = ago(s.lastAt).padStart(4);
+      const projName = state.sessionProject.get(s.id) ?? "";
+      const srcTag = s.source === "opencode" ? `${ansi2.dim}oc${ansi2.reset} ` : "";
+      const contentWidth = treeWidth - 5 - (s.source === "opencode" ? 3 : 0);
+      const projMax = Math.min(projName.length, Math.max(8, contentWidth - s.title.length - 1));
+      const projStr = projName.length > projMax ? projName.slice(0, projMax - 1) + "…" : projName;
+      const titleWidth = contentWidth - projStr.length - 1;
+      const title = truncate(s.title, titleWidth);
+      const gap = " ".repeat(Math.max(1, contentWidth - visibleLength(title) - projStr.length));
+      write(`${srcTag}${isSelected ? ansi2.inverse : ""}${title}${isSelected ? ansi2.reset : ""} ${ansi2.dim}${gap}${projStr} ${ageStr}${ansi2.reset}`);
+    } else if (row.node.kind === "project") {
+      const proj = row.node;
+      const collapsed = state.collapsed.has(row.projectIdx);
+      const icon = collapsed ? TREE.dot : TREE.bullet;
+      const count = proj.sessions.length;
+      const branchLabel = proj.branch ? ` ${ansi2.dim}${proj.branch}${ansi2.reset}` : "";
+      const countStr = ` (${count})`;
+      write(`${ansi2.bold}${icon} ${isSelected ? ansi2.inverse : ""}${proj.name}${isSelected ? ansi2.reset : ""}${ansi2.reset}${branchLabel}${ansi2.dim}${countStr}${ansi2.reset}`);
+    } else {
+      const sn = row.node;
+      const s = sn.session;
+      const isLastProj = row.isLastProject;
+      const treePipe = isLastProj ? " " : TREE.pipe;
+      const branch = row.isLast ? TREE.corner : TREE.tee;
+      const ageStr = ago(s.lastAt);
+      const srcTag = s.source === "opencode" ? "oc " : "";
+      const forkIndent = sn.depth > 0 ? "  ".repeat(sn.depth) : "";
+      const forkPrefix = sn.depth > 0 ? `${ansi2.dim}${TREE.corner}${TREE.dash}${ansi2.reset}` : "";
+      const prefixWidth = 6 + forkIndent.length + (sn.depth > 0 ? 2 : 0);
+      const ageWidth = ageStr.length + 1;
+      const titleWidth = treeWidth - prefixWidth - ageWidth - srcTag.length;
+      const title = truncate(s.title, titleWidth);
+      const pad = " ".repeat(Math.max(1, titleWidth - visibleLength(title)));
+      write(` ${ansi2.dim}${treePipe}${ansi2.reset} ${forkIndent}${ansi2.dim}${forkPrefix || `${branch}${TREE.dash}`}${ansi2.reset} ${srcTag}${isSelected ? ansi2.inverse : ""}${title}${isSelected ? ansi2.reset : ""}${ansi2.dim}${pad}${ageStr}${ansi2.reset}`);
+    }
+  }
+  for (let vi = 0;vi < visibleRows; vi++) {
+    write(ansi2.moveTo(vi + 2, treeWidth + 1));
+    write(`${ansi2.dim}│${ansi2.reset}`);
+  }
+  for (let vi = 0;vi < visibleRows; vi++) {
+    write(ansi2.moveTo(vi + 2, treeWidth + 3));
+    const line = state.previewLines[vi] ?? "";
+    write(truncate(line, previewWidth));
+  }
+  write(ansi2.moveTo(termHeight, 1));
+  write(ansi2.eraseLine);
+  if (state.filterMode) {
+    write(`${ansi2.inverse} / ${ansi2.reset} ${state.filter}█`);
+  } else if (state.statusMessage) {
+    write(`${ansi2.dim}${state.statusMessage}${ansi2.reset}`);
+  } else if (state.filter) {
+    write(`${ansi2.dim}filter: ${state.filter}  (esc to clear)${ansi2.reset}`);
+  } else {
+    write(`${ansi2.dim}j/k navigate  tab view  c copy id  / filter  q quit${ansi2.reset}`);
+  }
+}
+async function updatePreview(state) {
+  const row = state.rows[state.cursor];
+  if (!row) {
+    state.previewLines = [];
+    state.previewSessionId = null;
+    return;
+  }
+  const previewWidth = state.termWidth - Math.min(Math.floor(state.termWidth * 0.5), 60) - 5;
+  const rule = `${ansi2.faint}${"─".repeat(previewWidth)}${ansi2.reset}`;
+  if (row.node.kind === "project") {
+    const proj = row.node;
+    state.previewSessionId = null;
+    const lbl2 = (s2) => `${ansi2.dim}${s2.padEnd(10)}${ansi2.reset}`;
+    state.previewLines = [
+      `${ansi2.bold}${proj.name}${ansi2.reset}`,
+      "",
+      `${lbl2("path")}${proj.directory}`,
+      ...proj.branch ? [`${lbl2("branch")}${proj.branch}`] : [],
+      `${lbl2("sessions")}${proj.sessions.length}`,
+      "",
+      rule,
+      "",
+      ...proj.sessions.map((s2) => `  ${ansi2.dim}${TREE.tee}${TREE.dash}${ansi2.reset} ${s2.session.title}`)
+    ];
+    return;
+  }
+  const s = row.node.session;
+  if (state.previewSessionId === s.id)
+    return;
+  state.previewSessionId = s.id;
+  const lbl = (label) => `${ansi2.dim}${label.padEnd(10)}${ansi2.reset}`;
+  const header = [
+    `${ansi2.bold}${s.title}${ansi2.reset}`,
+    "",
+    `${lbl("id")}${s.id}`,
+    `${lbl("source")}${s.source}`,
+    `${lbl("dir")}${s.directory}`,
+    ...s.branch ? [`${lbl("branch")}${s.branch}`] : [],
+    `${lbl("messages")}${s.messageCount}`,
+    `${lbl("time")}${clockTime(s.startedAt)} → ${clockTime(s.lastAt)}`,
+    "",
+    rule,
+    ""
+  ];
+  try {
+    const messages = await readMessages2(s.id);
+    const HEAD = 2;
+    const TAIL = 5;
+    const renderMsg = (m) => {
+      const label = m.role === "user" ? `${ansi2.bold}user${ansi2.reset}` : `${ansi2.bold}${ansi2.dim}assistant${ansi2.reset}`;
+      const ts = clockTime(m.timestamp);
+      const out = [`${label}  ${ansi2.dim}${ts}${ansi2.reset}`];
+      const lines = m.content.split(`
+`);
+      for (const line of lines.slice(0, 8)) {
+        out.push(truncate(line, previewWidth));
+      }
+      if (lines.length > 8) {
+        out.push(`${ansi2.dim}  ... (${lines.length - 8} more lines)${ansi2.reset}`);
+      }
+      out.push("");
+      return out;
+    };
+    const chunks = [];
+    if (messages.length <= HEAD + TAIL) {
+      for (const m of messages)
+        chunks.push(...renderMsg(m));
+    } else {
+      for (const m of messages.slice(0, HEAD))
+        chunks.push(...renderMsg(m));
+      chunks.push(`${ansi2.dim}  ... ${messages.length - HEAD - TAIL} more messages${ansi2.reset}`);
+      chunks.push("");
+      for (const m of messages.slice(-TAIL))
+        chunks.push(...renderMsg(m));
+    }
+    state.previewLines = [...header, ...chunks];
+  } catch {
+    state.previewLines = [...header, "(failed to load messages)"];
+  }
+}
+function applyFilter(state) {
+  if (state.viewMode === "recent") {
+    if (!state.filter) {
+      state.rows = state.flatRows;
+    } else {
+      const q2 = state.filter.toLowerCase();
+      state.rows = state.flatRows.filter((row) => {
+        const s = row.node.session;
+        const proj = state.sessionProject.get(s.id) ?? "";
+        return s.title.toLowerCase().includes(q2) || s.directory.toLowerCase().includes(q2) || proj.toLowerCase().includes(q2);
+      });
+    }
+    state.cursor = Math.min(state.cursor, Math.max(0, state.rows.length - 1));
+    return;
+  }
+  const baseRows = state.viewMode === "lineage" ? state.lineageRows : state.allRows;
+  if (!state.filter) {
+    state.rows = baseRows;
+    rebuildVisibleRows(state);
+    return;
+  }
+  const q = state.filter.toLowerCase();
+  const matchedProjIndices = new Set;
+  for (const row of baseRows) {
+    if (row.node.kind === "session") {
+      const s = row.node.session;
+      if (s.title.toLowerCase().includes(q) || s.directory.toLowerCase().includes(q)) {
+        matchedProjIndices.add(row.projectIdx);
+      }
+    } else {
+      const proj = row.node;
+      if (proj.name.toLowerCase().includes(q) || proj.directory.toLowerCase().includes(q)) {
+        matchedProjIndices.add(row.projectIdx);
+      }
+    }
+  }
+  state.rows = baseRows.filter((row) => matchedProjIndices.has(row.projectIdx));
+  state.cursor = Math.min(state.cursor, Math.max(0, state.rows.length - 1));
+}
+function rebuildVisibleRows(state) {
+  const baseForMode = state.viewMode === "lineage" ? state.lineageRows : state.allRows;
+  const base = state.filter ? state.rows : baseForMode;
+  state.rows = base.filter((row) => {
+    if (row.node.kind === "project")
+      return true;
+    return !state.collapsed.has(row.projectIdx);
+  });
+  state.cursor = Math.min(state.cursor, Math.max(0, state.rows.length - 1));
+}
+function handleKey(key, state) {
+  const str = key.toString();
+  if (state.filterMode) {
+    if (str === "\r" || str === `
+`) {
+      state.filterMode = false;
+      return "continue";
+    }
+    if (str === "\x1B") {
+      state.filter = "";
+      state.filterMode = false;
+      applyFilter(state);
+      rebuildVisibleRows(state);
+      return "continue";
+    }
+    if (str === "" || str === "\b") {
+      state.filter = state.filter.slice(0, -1);
+      applyFilter(state);
+      rebuildVisibleRows(state);
+      return "continue";
+    }
+    if (str.length === 1 && str >= " ") {
+      state.filter += str;
+      applyFilter(state);
+      rebuildVisibleRows(state);
+      return "continue";
+    }
+    return "continue";
+  }
+  const visibleRows = state.termHeight - 2;
+  switch (str) {
+    case "q":
+    case "\x03":
+      return "quit";
+    case "j":
+    case `${CSI2}B`:
+      if (state.cursor < state.rows.length - 1) {
+        state.cursor++;
+        if (state.cursor >= state.scroll + visibleRows) {
+          state.scroll = state.cursor - visibleRows + 1;
+        }
+      }
+      return "continue";
+    case "k":
+    case `${CSI2}A`:
+      if (state.cursor > 0) {
+        state.cursor--;
+        if (state.cursor < state.scroll) {
+          state.scroll = state.cursor;
+        }
+      }
+      return "continue";
+    case "l":
+    case `${CSI2}C`: {
+      const row = state.rows[state.cursor];
+      if (row?.node.kind === "project") {
+        state.collapsed.delete(row.projectIdx);
+        rebuildVisibleRows(state);
+      }
+      return "continue";
+    }
+    case "h":
+    case `${CSI2}D`: {
+      const row = state.rows[state.cursor];
+      if (row?.node.kind === "project") {
+        state.collapsed.add(row.projectIdx);
+        rebuildVisibleRows(state);
+      } else if (row?.node.kind === "session") {
+        const projRow = state.rows.findIndex((r) => r.node.kind === "project" && r.projectIdx === row.projectIdx);
+        if (projRow >= 0) {
+          state.cursor = projRow;
+          if (state.cursor < state.scroll)
+            state.scroll = state.cursor;
+        }
+      }
+      return "continue";
+    }
+    case "\t": {
+      const idx = VIEW_MODES.indexOf(state.viewMode);
+      state.viewMode = VIEW_MODES[(idx + 1) % VIEW_MODES.length];
+      state.cursor = 0;
+      state.scroll = 0;
+      state.previewSessionId = null;
+      if (state.viewMode === "recent") {
+        state.rows = state.flatRows;
+      } else if (state.viewMode === "lineage") {
+        state.rows = state.lineageRows;
+        rebuildVisibleRows(state);
+      } else {
+        state.rows = state.allRows;
+        applyFilter(state);
+        rebuildVisibleRows(state);
+      }
+      return "continue";
+    }
+    case "/":
+      state.filterMode = true;
+      return "continue";
+    case "\x1B":
+      if (state.filter) {
+        state.filter = "";
+        state.filterMode = false;
+        applyFilter(state);
+        rebuildVisibleRows(state);
+        return "continue";
+      }
+      return "quit";
+    case "g":
+      state.cursor = 0;
+      state.scroll = 0;
+      return "continue";
+    case "G":
+      state.cursor = state.rows.length - 1;
+      state.scroll = Math.max(0, state.cursor - visibleRows + 1);
+      return "continue";
+    case "c":
+    case "\r":
+    case `
+`: {
+      const row = state.rows[state.cursor];
+      if (row?.node.kind === "session")
+        return "copy";
+      return "continue";
+    }
+    default:
+      return "continue";
+  }
+}
+async function browse(scopePaths) {
+  const { projects, treeRows: allRows, lineageRows, flatRows } = await loadTree(scopePaths);
+  if (allRows.length === 0) {
+    console.log("No sessions found.");
+    return;
+  }
+  const sessionProject = new Map;
+  for (const proj of projects) {
+    for (const s of proj.sessions) {
+      sessionProject.set(s.session.id, proj.name);
+    }
+  }
+  const [width, height] = process.stdout.getWindowSize?.() ?? [80, 24];
+  const state = {
+    rows: flatRows,
+    allRows,
+    lineageRows,
+    flatRows,
+    viewMode: "recent",
+    cursor: 0,
+    scroll: 0,
+    filter: "",
+    filterMode: false,
+    previewSessionId: null,
+    previewLines: [],
+    termWidth: width,
+    termHeight: height,
+    collapsed: new Set,
+    sessionProject,
+    statusMessage: null
+  };
+  await updatePreview(state);
+  if (!process.stdin.isTTY) {
+    console.error("browse requires an interactive terminal");
+    process.exit(1);
+  }
+  write(ansi2.altScreen);
+  write(ansi2.clear);
+  process.stdin.setRawMode(true);
+  const cleanup = () => {
+    write(ansi2.cursorShow);
+    write(ansi2.mainScreen);
+    process.stdin.setRawMode(false);
+  };
+  process.stdout.on("resize", () => {
+    const [w, h] = process.stdout.getWindowSize?.() ?? [80, 24];
+    state.termWidth = w;
+    state.termHeight = h;
+    write(ansi2.clear);
+    renderTree(state);
+  });
+  renderTree(state);
+  for await (const chunk of process.stdin) {
+    const action = handleKey(chunk, state);
+    if (action === "quit") {
+      cleanup();
+      return;
+    }
+    if (action === "copy") {
+      const row = state.rows[state.cursor];
+      if (row?.node.kind === "session") {
+        const sessionId = row.node.session.id;
+        const ok = await copyToClipboard(sessionId);
+        state.statusMessage = ok ? `copied: ${sessionId}` : "clipboard unavailable";
+        renderTree(state);
+        setTimeout(() => {
+          state.statusMessage = null;
+          renderTree(state);
+        }, 2000);
+      }
+      continue;
+    }
+    await updatePreview(state);
+    renderTree(state);
+  }
+  cleanup();
+}
+var VIEW_MODES;
+var init_tui = __esm(() => {
+  init_queries();
+  init_tree();
+  init_ansi();
+  init_fmt();
+  VIEW_MODES = ["recent", "tree", "lineage"];
+});
+
+// src/db/indexer.ts
+init_db();
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+import { existsSync as existsSync2, statSync as statSync2, readdirSync as readdirSync2 } from "node:fs";
+import duckdb2 from "duckdb";
+var CLAUDE_DIR = join2(homedir2(), ".claude", "projects");
+var OPENCODE_DB = process.env.OPENCODE_DB ?? join2(homedir2(), ".local", "share", "opencode", "opencode.db");
+function discoverJsonlFiles() {
+  if (!existsSync2(CLAUDE_DIR))
+    return [];
+  const results = [];
+  for (const entry of readdirSync2(CLAUDE_DIR, { withFileTypes: true })) {
+    if (!entry.isDirectory())
+      continue;
+    const dir = join2(CLAUDE_DIR, entry.name);
+    for (const file of readdirSync2(dir)) {
+      if (!file.endsWith(".jsonl"))
+        continue;
+      const filePath = join2(dir, file);
+      const stat = statSync2(filePath);
+      results.push({ path: filePath, slug: entry.name, mtimeMs: stat.mtimeMs });
+    }
+  }
+  return results;
+}
+function slugToPath(slug) {
+  return slug.replace(/-/g, "/");
+}
+async function indexJsonlFile(filePath, slug) {
+  const directory = slugToPath(slug);
+  const escapedPath = filePath.replace(/'/g, "''");
+  let tempDb = null;
+  let tempConn = null;
+  try {
+    tempDb = new duckdb2.Database(":memory:");
+    tempConn = tempDb.connect();
+    const rows = await new Promise((resolve, reject) => {
+      tempConn.all(`
+        WITH raw AS (
+          SELECT
+            json_extract_string(column0, '$.type') as msg_type,
+            json_extract_string(column0, '$.sessionId') as session_id,
+            json_extract_string(column0, '$.timestamp') as ts,
+            json_extract_string(column0, '$.gitBranch') as branch,
+            json_extract_string(column0, '$.message.role') as role,
+            json_extract_string(column0, '$.message.content') as content,
+            json_extract_string(column0, '$.message.model') as model,
+            CAST(json_extract(column0, '$.message.usage.output_tokens') AS BIGINT) as output_tokens,
+            CAST(json_extract(column0, '$.message.usage.cache_read_input_tokens') AS BIGINT) as cache_read,
+            CAST(json_extract(column0, '$.message.usage.cache_creation_input_tokens') AS BIGINT) as cache_write
+          FROM read_csv('${escapedPath}',
+            delim=chr(0), header=false, ignore_errors=true, max_line_size=10000000)
+        )
+        SELECT * FROM raw
+        WHERE msg_type IN ('user', 'assistant')
+          AND content IS NOT NULL
+          AND length(content) > 2
+          AND left(content, 1) != '['
+          AND left(content, 1) != '{'
+        ORDER BY ts ASC
+      `, (err, rows2) => {
+        if (err)
+          reject(err);
+        else
+          resolve(rows2 ?? []);
+      });
+    });
+    if (rows.length === 0)
+      return 0;
+    const sessionMap = new Map;
+    for (const r of rows) {
+      const sid = r.session_id;
+      if (!sid)
+        continue;
+      const existing = sessionMap.get(sid);
+      if (existing)
+        existing.push(r);
+      else
+        sessionMap.set(sid, [r]);
+    }
+    for (const [sessionId, msgs] of sessionMap) {
+      const firstUser = msgs.find((m) => m.role === "user");
+      const branch = msgs.find((m) => m.branch)?.branch ?? null;
+      const timestamps = msgs.map((m) => new Date(m.ts).getTime()).filter((t) => !isNaN(t));
+      const startedAt = Math.min(...timestamps);
+      const lastAt = Math.max(...timestamps);
+      const userMsgCount = msgs.filter((m) => m.role === "user").length;
+      await upsertSession({
+        id: sessionId,
+        source: "claude-code",
+        directory,
+        branch,
+        title: firstUser ? firstUser.content.replace(/\n/g, " ").replace(/\s+/g, " ").trim().slice(0, 200) : "(no title)",
+        startedAt,
+        lastAt,
+        messageCount: userMsgCount
+      });
+      const indexedMsgs = msgs.map((m, i) => ({
+        role: m.role,
+        content: m.content,
+        timestampMs: new Date(m.ts).getTime(),
+        position: i,
+        model: m.model,
+        outputTokens: Number(m.output_tokens ?? 0),
+        cacheRead: Number(m.cache_read ?? 0),
+        cacheWrite: Number(m.cache_write ?? 0)
+      }));
+      await replaceMessages(sessionId, indexedMsgs);
+    }
+    return sessionMap.size;
+  } finally {
+    if (tempDb)
+      tempDb.close();
+  }
+}
+async function indexOpenCode() {
+  if (!existsSync2(OPENCODE_DB))
+    return 0;
+  const stat = statSync2(OPENCODE_DB);
+  const currentMtime = stat.mtimeMs;
+  const trackedMtime = await getFileMtime(OPENCODE_DB);
+  if (trackedMtime !== null && Math.abs(currentMtime - trackedMtime) < 1000) {
+    return 0;
+  }
+  let tempDb = null;
+  let tempConn = null;
+  try {
+    tempDb = new duckdb2.Database(":memory:");
+    tempConn = tempDb.connect();
+    await new Promise((resolve, reject) => {
+      tempConn.exec("INSTALL sqlite_scanner; LOAD sqlite_scanner", (err) => {
+        if (err)
+          reject(err);
+        else
+          resolve();
+      });
+    });
+    const escapedPath = OPENCODE_DB.replace(/'/g, "''");
+    await new Promise((resolve, reject) => {
+      tempConn.exec(`ATTACH '${escapedPath}' AS oc (TYPE sqlite, READ_ONLY)`, (err) => {
+        if (err)
+          reject(err);
+        else
+          resolve();
+      });
+    });
+    const sessions = await new Promise((resolve, reject) => {
+      tempConn.all(`
+        SELECT id, parent_id, directory, COALESCE(title, slug) as title, slug,
+               time_created, time_updated
+        FROM oc.session
+        WHERE time_archived IS NULL
+        ORDER BY time_updated DESC
+      `, (err, rows) => {
+        if (err)
+          reject(err);
+        else
+          resolve(rows ?? []);
+      });
+    });
+    let count = 0;
+    for (const s of sessions) {
+      const parts = await new Promise((resolve, reject) => {
+        tempConn.all(`
+          SELECT
+            json_extract_string(p.data, '$.text') as text,
+            json_extract_string(m.data, '$.role') as role,
+            m.time_created as mtime
+          FROM oc.part p
+          JOIN oc.message m ON p.message_id = m.id
+          WHERE p.session_id = '${s.id}'
+            AND json_extract_string(p.data, '$.type') = 'text'
+            AND json_extract_string(p.data, '$.text') IS NOT NULL
+            AND length(json_extract_string(p.data, '$.text')) > 0
+          ORDER BY m.time_created ASC, p.time_created ASC
+        `, (err, rows) => {
+          if (err)
+            reject(err);
+          else
+            resolve(rows ?? []);
+        });
+      });
+      if (parts.length === 0)
+        continue;
+      const userCount = parts.filter((p) => p.role === "user").length;
+      await upsertSession({
+        id: s.id,
+        source: "opencode",
+        directory: s.directory,
+        branch: null,
+        title: s.title || s.slug || "(no title)",
+        parentId: s.parent_id ?? null,
+        startedAt: Number(s.time_created),
+        lastAt: Number(s.time_updated),
+        messageCount: userCount
+      });
+      const messages = parts.map((p, i) => ({
+        role: p.role,
+        content: p.text,
+        timestampMs: Number(p.mtime),
+        position: i
+      }));
+      await replaceMessages(s.id, messages);
+      count++;
+    }
+    await setFileMtime(OPENCODE_DB, "opencode", currentMtime);
+    return count;
+  } catch (e) {
+    return 0;
+  } finally {
+    if (tempDb)
+      tempDb.close();
+  }
+}
+async function runIndex(opts) {
+  const start = Date.now();
+  await ensureSchema();
+  const force = opts?.force ?? false;
+  const verbose = opts?.verbose ?? false;
+  const jsonlFiles = discoverJsonlFiles();
+  let filesChecked = jsonlFiles.length;
+  let filesIndexed = 0;
+  let sessionsIndexed = 0;
+  for (const file of jsonlFiles) {
+    const trackedMtime = await getFileMtime(file.path);
+    if (!force && trackedMtime !== null && Math.abs(file.mtimeMs - trackedMtime) < 1000) {
+      continue;
+    }
+    if (verbose) {
+      const name = file.path.split("/").pop();
+      process.stderr.write(`indexing ${name}...
+`);
+    }
+    try {
+      const count = await indexJsonlFile(file.path, file.slug);
+      await setFileMtime(file.path, "claude-code", file.mtimeMs);
+      filesIndexed++;
+      sessionsIndexed += count;
+    } catch (e) {
+      if (verbose) {
+        process.stderr.write(`  error: ${e}
+`);
+      }
+    }
+  }
+  const trackedFiles = await query(`SELECT path, source FROM source_file WHERE source = 'claude-code'`);
+  const currentPaths = new Set(jsonlFiles.map((f) => f.path));
+  for (const tracked of trackedFiles) {
+    if (!currentPaths.has(tracked.path)) {
+      if (verbose)
+        process.stderr.write(`removing stale: ${tracked.path}
+`);
+      await exec(`DELETE FROM source_file WHERE path = '${tracked.path.replace(/'/g, "''")}'`);
+    }
+  }
+  filesChecked++;
+  try {
+    const ocCount = await indexOpenCode();
+    if (ocCount > 0) {
+      filesIndexed++;
+      sessionsIndexed += ocCount;
+      if (verbose)
+        process.stderr.write(`indexed ${ocCount} opencode sessions
+`);
+    }
+  } catch (e) {
+    if (verbose)
+      process.stderr.write(`opencode error: ${e}
+`);
+  }
+  return {
+    filesChecked,
+    filesIndexed,
+    sessionsIndexed,
+    elapsed: Date.now() - start
+  };
+}
+async function needsIndex() {
+  try {
+    await ensureSchema();
+  } catch {
+    return true;
+  }
+  const rows = await query(`SELECT count(*) as cnt FROM session`);
+  if (Number(rows[0]?.cnt ?? 0) === 0)
+    return true;
+  const jsonlFiles = discoverJsonlFiles();
+  for (const file of jsonlFiles.slice(0, 5)) {
+    const tracked = await getFileMtime(file.path);
+    if (tracked === null || Math.abs(file.mtimeMs - tracked) >= 1000)
+      return true;
+  }
+  return false;
+}
+
+// src/db/index.ts
+import { homedir as homedir3 } from "node:os";
+import { join as join3, dirname as dirname2 } from "node:path";
+import duckdb3 from "duckdb";
+var INDEX_DIR2 = join3(homedir3(), ".local", "share", "reconvo");
+var INDEX_PATH2 = process.env.RECONVO_INDEX ?? join3(INDEX_DIR2, "index.duckdb");
+function getIndexPath() {
+  return INDEX_PATH2;
+}
+
+// src/db/queries.ts
+init_db();
+function esc(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "''").replace(/\x00/g, "");
+}
+async function listSessions(opts) {
+  const limit = opts?.limit ?? 50;
+  const conditions = [];
+  if (opts?.source) {
+    conditions.push(`source = '${esc(opts.source)}'`);
+  }
+  if (opts?.scopePaths?.length) {
+    const conds = opts.scopePaths.map((p) => `directory LIKE '${esc(p)}%'`).join(" OR ");
+    conditions.push(`(${conds})`);
+  }
+  if (opts?.sinceMs) {
+    conditions.push(`last_at >= ${opts.sinceMs}`);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = await query(`
+    SELECT id, source, directory, branch, title, parent_id, started_at, last_at, message_count
+    FROM session
+    ${where}
+    ORDER BY last_at DESC
+    LIMIT ${limit}
+  `);
+  return rows.map((r) => ({
+    id: r.id,
+    source: r.source,
+    directory: r.directory,
+    branch: r.branch,
+    title: r.title ?? "(no title)",
+    parentId: r.parent_id ?? null,
+    startedAt: Number(r.started_at),
+    lastAt: Number(r.last_at),
+    messageCount: Number(r.message_count)
+  }));
+}
+async function searchSessions(keywords, opts) {
+  const limit = opts?.limit ?? 20;
+  const kwConds = keywords.map((w) => `m.content ILIKE '%${esc(w)}%'`).join(" OR ");
+  const conditions = [`(${kwConds})`];
+  if (opts?.source) {
+    conditions.push(`s.source = '${esc(opts.source)}'`);
+  }
+  if (opts?.scopePaths?.length) {
+    const conds = opts.scopePaths.map((p) => `s.directory LIKE '${esc(p)}%'`).join(" OR ");
+    conditions.push(`(${conds})`);
+  }
+  if (opts?.sinceMs) {
+    conditions.push(`s.last_at >= ${opts.sinceMs}`);
+  }
+  const where = conditions.join(" AND ");
+  const rows = await query(`
+    WITH hits AS (
+      SELECT
+        m.session_id, m.content, m.role, m.timestamp_ms, m.position,
+        ROW_NUMBER() OVER (PARTITION BY m.session_id ORDER BY m.timestamp_ms) as rn,
+        COUNT(*) OVER (PARTITION BY m.session_id) as total_hits
+      FROM message m
+      JOIN session s ON m.session_id = s.id
+      WHERE ${where}
+    )
+    SELECT
+      s.id as session_id, s.source, s.directory, s.branch, s.title,
+      s.started_at, s.last_at, s.message_count,
+      h.content as hit_content, h.role as hit_role,
+      h.timestamp_ms as hit_ts, h.position as hit_position,
+      h.total_hits
+    FROM hits h
+    JOIN session s ON h.session_id = s.id
+    WHERE h.rn = 1
+    ORDER BY h.total_hits DESC, s.last_at DESC
+    LIMIT ${limit}
+  `);
+  return rows.map((r) => ({
+    session: {
+      id: r.session_id,
+      source: r.source,
+      directory: r.directory,
+      branch: r.branch,
+      title: r.title ?? "(no title)",
+      parentId: null,
+      startedAt: Number(r.started_at),
+      lastAt: Number(r.last_at),
+      messageCount: Number(r.message_count)
+    },
+    snippet: (r.hit_content ?? "").slice(0, 300),
+    position: Number(r.hit_position),
+    role: r.hit_role ?? "user",
+    timestamp: Number(r.hit_ts)
+  }));
+}
+async function readMessages(sessionPrefix, opts) {
+  let from = opts?.from;
+  let to = opts?.to;
+  if (opts?.around !== undefined) {
+    const radius = opts?.radius ?? 3;
+    from = Math.max(0, opts.around - radius);
+    to = opts.around + radius + 1;
+  }
+  const conditions = [`session_id LIKE '${esc(sessionPrefix)}%'`];
+  if (from !== undefined)
+    conditions.push(`position >= ${from}`);
+  if (to !== undefined)
+    conditions.push(`position < ${to}`);
+  if (opts?.role === "user" || opts?.role === "assistant") {
+    conditions.push(`role = '${opts.role}'`);
+  }
+  const rows = await query(`
+    SELECT session_id, role, content, timestamp_ms, position
+    FROM message
+    WHERE ${conditions.join(" AND ")}
+    ORDER BY position ASC
+  `);
+  return rows.map((r) => ({
+    sessionId: r.session_id,
+    role: r.role,
+    content: r.content,
+    timestamp: Number(r.timestamp_ms),
+    position: Number(r.position)
+  }));
+}
+async function skimSession(sessionPrefix, head = 3, tail = 3, role) {
+  const all = await readMessages(sessionPrefix, { role });
+  if (all.length <= head + tail) {
+    return { head: all, tail: [], skipped: 0, total: all.length };
+  }
+  return {
+    head: all.slice(0, head),
+    tail: all.slice(-tail),
+    skipped: all.length - head - tail,
+    total: all.length
+  };
+}
+async function getStats(scopePaths) {
+  let scopeWhere = "";
+  if (scopePaths?.length) {
+    const conds = scopePaths.map((p) => `s.directory LIKE '${esc(p)}%'`).join(" OR ");
+    scopeWhere = `AND (${conds})`;
+  }
+  const models = await query(`
+    SELECT
+      m.model,
+      count(*) as turns,
+      COALESCE(sum(m.output_tokens), 0) as output_tokens,
+      COALESCE(sum(m.cache_read), 0) as cache_read,
+      COALESCE(sum(m.cache_write), 0) as cache_write
+    FROM message m
+    JOIN session s ON m.session_id = s.id
+    WHERE m.model IS NOT NULL
+      AND m.role = 'assistant'
+      ${scopeWhere}
+    GROUP BY m.model
+    ORDER BY count(*) DESC
+  `);
+  const daily = await query(`
+    SELECT
+      strftime(to_timestamp(m.timestamp_ms / 1000), '%Y-%m-%d') as day,
+      count(DISTINCT m.session_id) as sessions,
+      count(*) FILTER (WHERE m.role = 'user') as user_msgs,
+      count(*) FILTER (WHERE m.role = 'assistant') as asst_turns
+    FROM message m
+    JOIN session s ON m.session_id = s.id
+    WHERE 1=1 ${scopeWhere}
+    GROUP BY day
+    ORDER BY day
+  `);
+  return {
+    models: models.map((m) => ({
+      model: m.model,
+      turns: Number(m.turns),
+      outputTokens: Number(m.output_tokens),
+      cacheRead: Number(m.cache_read),
+      cacheWrite: Number(m.cache_write)
+    })),
+    daily: daily.map((d) => ({
+      day: d.day,
+      sessions: Number(d.sessions),
+      userMsgs: Number(d.user_msgs),
+      assistantTurns: Number(d.asst_turns)
+    }))
+  };
+}
+async function searchByFile(filePath, opts) {
+  const limit = opts?.limit ?? 20;
+  const conditions = [`m.content ILIKE '%${esc(filePath)}%'`];
+  if (opts?.source)
+    conditions.push(`s.source = '${esc(opts.source)}'`);
+  if (opts?.scopePaths?.length) {
+    const conds = opts.scopePaths.map((p) => `s.directory LIKE '${esc(p)}%'`).join(" OR ");
+    conditions.push(`(${conds})`);
+  }
+  if (opts?.sinceMs)
+    conditions.push(`s.last_at >= ${opts.sinceMs}`);
+  const rows = await query(`
+    SELECT DISTINCT s.id, s.source, s.directory, s.branch, s.title, s.parent_id,
+           s.started_at, s.last_at, s.message_count
+    FROM session s
+    JOIN message m ON m.session_id = s.id
+    WHERE ${conditions.join(" AND ")}
+    ORDER BY s.last_at DESC
+    LIMIT ${limit}
+  `);
+  return rows.map((r) => ({
+    id: r.id,
+    source: r.source,
+    directory: r.directory,
+    branch: r.branch,
+    title: r.title ?? "(no title)",
+    parentId: r.parent_id ?? null,
+    startedAt: Number(r.started_at),
+    lastAt: Number(r.last_at),
+    messageCount: Number(r.message_count)
+  }));
+}
+
+// src/context/git.ts
+import { dirname as dirname3, resolve } from "node:path";
+async function run(cmd) {
+  try {
+    const proc = Bun.spawn(cmd, { stdout: "pipe", stderr: "ignore" });
+    const text = await new Response(proc.stdout).text();
+    return await proc.exited === 0 ? text.trim() : null;
+  } catch {
+    return null;
+  }
+}
+async function detect(cwd = process.cwd()) {
+  const root = await run(["git", "-C", cwd, "rev-parse", "--show-toplevel"]);
+  if (!root)
+    return null;
+  const branch = await run(["git", "-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"]);
+  let commonDir = await run(["git", "-C", cwd, "rev-parse", "--git-common-dir"]);
+  if (commonDir && !commonDir.startsWith("/"))
+    commonDir = resolve(root, commonDir);
+  if (!commonDir)
+    commonDir = root;
+  const raw = await run(["git", "-C", cwd, "worktree", "list", "--porcelain"]);
+  const siblings = raw ? raw.split(`
+`).filter((l) => l.startsWith("worktree ")).map((l) => l.slice("worktree ".length)) : [root];
+  return {
+    root,
+    branch: branch === "HEAD" ? null : branch,
+    commonDir,
+    familyDir: dirname3(siblings[0] ?? root),
+    siblings: siblings.length > 0 ? siblings : [root]
+  };
+}
+function scope(ctx) {
+  return [...new Set([...ctx.siblings, ctx.familyDir])];
+}
+
+// src/util/ansi.ts
+var ESC = "\x1B";
+var CSI = `${ESC}[`;
+var ansi = {
+  clear: `${CSI}2J${CSI}H`,
+  cursorHide: `${CSI}?25l`,
+  cursorShow: `${CSI}?25h`,
+  altScreen: `${CSI}?1049h`,
+  mainScreen: `${CSI}?1049l`,
+  moveTo: (row, col) => `${CSI}${row};${col}H`,
+  eraseLine: `${CSI}2K`,
+  bold: `${CSI}1m`,
+  dim: `${CSI}2m`,
+  italic: `${CSI}3m`,
+  inverse: `${CSI}7m`,
+  reset: `${CSI}0m`,
+  faint: `${CSI}90m`,
+  cyan: `${CSI}36m`,
+  yellow: `${CSI}33m`
+};
+
+// src/util/fmt.ts
+init_ansi();
+function agoLong(ms) {
+  const diff = Date.now() - ms;
+  const mins = Math.floor(diff / 60000);
+  if (mins < 60)
+    return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24)
+    return `${hours}h ago`;
+  return `${Math.floor(hours / 24)}d ago`;
+}
+var timeFmt = new Intl.DateTimeFormat(undefined, { hour: "numeric", minute: "2-digit" });
+var dateFmt = new Intl.DateTimeFormat(undefined, { month: "short", day: "numeric" });
+var yearFmt = new Intl.DateTimeFormat(undefined, { month: "short", day: "numeric", year: "2-digit" });
+function truncatePlain(s, max) {
+  if (max <= 0)
+    return "";
+  return s.length <= max ? s : `${s.slice(0, max - 3)}...`;
+}
+function col(s, width) {
+  const t = truncatePlain(s, width);
+  return t + " ".repeat(Math.max(0, width - t.length));
+}
+function parseSince(val) {
+  const now = Date.now();
+  const lower = val.toLowerCase().trim();
+  if (lower === "today") {
+    const d2 = new Date;
+    d2.setHours(0, 0, 0, 0);
+    return d2.getTime();
+  }
+  if (lower === "yesterday") {
+    const d2 = new Date;
+    d2.setHours(0, 0, 0, 0);
+    d2.setDate(d2.getDate() - 1);
+    return d2.getTime();
+  }
+  const rel = lower.match(/^(\d+)([mhdw])$/);
+  if (rel) {
+    const n = parseInt(rel[1], 10);
+    const unit = rel[2];
+    const ms = unit === "m" ? n * 60000 : unit === "h" ? n * 3600000 : unit === "d" ? n * 86400000 : n * 604800000;
+    return now - ms;
+  }
+  const d = new Date(lower);
+  if (!isNaN(d.getTime()))
+    return d.getTime();
+  return;
+}
+
+// src/cli.ts
+var DIM = ansi.dim;
+var BOLD = ansi.bold;
+var RESET = ansi.reset;
+var CYAN = ansi.cyan;
+
+class UsageError extends Error {
+}
+function fail(msg) {
+  throw new UsageError(msg);
+}
+async function getScope(allFlag) {
+  if (allFlag)
+    return;
+  const ctx = await detect();
+  if (!ctx)
+    return;
+  return scope(ctx);
+}
+function parseSource(args) {
+  const idx = args.indexOf("--source");
+  if (idx === -1 || idx + 1 >= args.length)
+    return;
+  const val = args[idx + 1];
+  if (val === "claude" || val === "claude-code")
+    return "claude-code";
+  if (val === "opencode" || val === "oc")
+    return "opencode";
+  return;
+}
+function stripFlags(args) {
+  const result = [];
+  let skip = false;
+  for (const arg of args) {
+    if (skip) {
+      skip = false;
+      continue;
+    }
+    if (arg === "--source" || arg === "--from" || arg === "--to" || arg === "--around" || arg === "--radius" || arg === "--head" || arg === "--tail" || arg === "--since" || arg === "--role") {
+      skip = true;
+      continue;
+    }
+    if (!arg.startsWith("--"))
+      result.push(arg);
+  }
+  return result;
+}
+function flagStr(args, name) {
+  const idx = args.indexOf(name);
+  if (idx === -1 || idx + 1 >= args.length)
+    return;
+  return args[idx + 1];
+}
+function flagVal(args, name) {
+  const idx = args.indexOf(name);
+  if (idx === -1 || idx + 1 >= args.length)
+    return;
+  const n = parseInt(args[idx + 1], 10);
+  return Number.isNaN(n) ? undefined : n;
+}
+async function ensureIndexed(verbose = false) {
+  const needs = await needsIndex();
+  if (needs) {
+    if (verbose)
+      process.stderr.write(`Updating index...
+`);
+    const stats = await runIndex({ verbose });
+    if (verbose || stats.filesIndexed > 0) {
+      process.stderr.write(`Indexed ${stats.sessionsIndexed} sessions from ${stats.filesIndexed} files in ${(stats.elapsed / 1000).toFixed(1)}s
+`);
+    }
+  }
+}
+async function cmdIndex(args) {
+  const force = args.includes("--force");
+  const verbose = args.includes("--verbose") || args.includes("-v");
+  const stats = await runIndex({ force, verbose });
+  console.log(`Indexed ${stats.sessionsIndexed} sessions from ${stats.filesIndexed} files ` + `(${stats.filesChecked} checked) in ${(stats.elapsed / 1000).toFixed(1)}s`);
+  console.log(`Index: ${getIndexPath()}`);
+}
+function getSince(args) {
+  const raw = flagStr(args, "--since");
+  if (!raw)
+    return;
+  const ms = parseSince(raw);
+  if (ms === undefined) {
+    fail(`Invalid --since value: ${raw}
+Examples: 2h, 3d, 1w, today, yesterday, 2026-03-10`);
+  }
+  return ms;
+}
+async function cmdSessions(args) {
+  const jsonOut = args.includes("--json");
+  const allFlag = args.includes("--all");
+  const source = parseSource(args);
+  const sinceMs = getSince(args);
+  const scopePaths = await getScope(allFlag);
+  const results = await listSessions({ source, scopePaths, sinceMs });
+  if (jsonOut) {
+    console.log(JSON.stringify(results, null, 2));
+    return;
+  }
+  if (results.length === 0) {
+    console.log("No sessions found.");
+    if (!allFlag)
+      console.log(`${DIM}(try --all to search all projects)${RESET}`);
+    return;
+  }
+  for (const s of results) {
+    const age = agoLong(s.lastAt);
+    const dirName = s.directory.split("/").pop() ?? s.directory;
+    const src = s.source === "opencode" ? `${DIM}oc${RESET} ` : "";
+    const branch = s.branch ? `${DIM}${s.branch}${RESET} ` : "";
+    console.log(`${src}${col(dirName, 18)} ${branch}${col(s.title, 40)} ${DIM}${col(age, 8)} ${s.messageCount} msgs${RESET}  ${DIM}${s.id.slice(0, 8)}${RESET}`);
+  }
+}
+async function cmdSearch(args) {
+  const jsonOut = args.includes("--json");
+  const allFlag = args.includes("--all");
+  const source = parseSource(args);
+  const keywords = stripFlags(args);
+  if (keywords.length === 0) {
+    fail("Usage: reconvo search <query> [--all] [--source claude|opencode] [--json]");
+  }
+  const sinceMs = getSince(args);
+  const scopePaths = await getScope(allFlag);
+  const results = await searchSessions(keywords, { source, scopePaths, sinceMs });
+  if (jsonOut) {
+    console.log(JSON.stringify(results, null, 2));
+    return;
+  }
+  if (results.length === 0) {
+    console.log(`No results for "${keywords.join(" ")}"`);
+    if (!allFlag)
+      console.log(`${DIM}(try --all to search all projects)${RESET}`);
+    return;
+  }
+  for (const hit of results) {
+    const s = hit.session;
+    const dirName = s.directory.split("/").pop() ?? s.directory;
+    const age = agoLong(s.lastAt);
+    const src = s.source === "opencode" ? `${DIM}oc${RESET} ` : "";
+    const roleColor = hit.role === "user" ? CYAN : DIM;
+    console.log(`${src}${BOLD}${dirName}${RESET}  ${DIM}${age}  ${s.id.slice(0, 8)}${RESET}`);
+    console.log(`  ${roleColor}${hit.role}${RESET}: ${truncatePlain(hit.snippet.replace(/\s+/g, " "), 120)}`);
+    console.log();
+  }
+}
+async function cmdRead(args) {
+  const jsonOut = args.includes("--json");
+  const positional = stripFlags(args);
+  const sessionId = positional[0];
+  if (!sessionId) {
+    fail("Usage: reconvo read <session-id> [--from N] [--to M] [--around N] [--radius R] [--role user|assistant] [--json]");
+  }
+  const messages = await readMessages(sessionId, {
+    from: flagVal(args, "--from"),
+    to: flagVal(args, "--to"),
+    around: flagVal(args, "--around"),
+    radius: flagVal(args, "--radius"),
+    role: flagStr(args, "--role")
+  });
+  if (jsonOut) {
+    console.log(JSON.stringify(messages, null, 2));
+    return;
+  }
+  if (messages.length === 0) {
+    fail(`No messages found for session: ${sessionId}`);
+  }
+  for (const m of messages) {
+    const roleColor = m.role === "user" ? CYAN : DIM;
+    const age = agoLong(m.timestamp);
+    console.log(`${DIM}[${m.position}]${RESET} ${roleColor}${m.role}${RESET}  ${DIM}${age}${RESET}`);
+    console.log(m.content);
+    console.log();
+  }
+}
+async function cmdSkim(args) {
+  const jsonOut = args.includes("--json");
+  const positional = stripFlags(args);
+  const sessionId = positional[0];
+  if (!sessionId) {
+    fail("Usage: reconvo skim <session-id> [--head N] [--tail N] [--role user|assistant] [--json]");
+  }
+  const result = await skimSession(sessionId, flagVal(args, "--head"), flagVal(args, "--tail"), flagStr(args, "--role"));
+  if (jsonOut) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  for (const m of result.head) {
+    const roleColor = m.role === "user" ? CYAN : DIM;
+    console.log(`${DIM}[${m.position}]${RESET} ${roleColor}${m.role}${RESET}`);
+    console.log(m.content);
+    console.log();
+  }
+  if (result.skipped > 0) {
+    console.log(`${DIM}... ${result.skipped} messages skipped ...${RESET}`);
+    console.log();
+  }
+  for (const m of result.tail) {
+    const roleColor = m.role === "user" ? CYAN : DIM;
+    console.log(`${DIM}[${m.position}]${RESET} ${roleColor}${m.role}${RESET}`);
+    console.log(m.content);
+    console.log();
+  }
+  console.log(`${DIM}${result.total} total messages${RESET}`);
+}
+async function cmdStats(args) {
+  const allFlag = args.includes("--all");
+  const scopePaths = await getScope(allFlag);
+  const result = await getStats(scopePaths);
+  console.log(`${BOLD}Model Usage${RESET}`);
+  for (const m of result.models) {
+    console.log(`  ${col(m.model, 30)} ${col(String(m.turns) + " turns", 12)} ${DIM}out: ${(m.outputTokens / 1e6).toFixed(1)}M  cache_r: ${(m.cacheRead / 1e9).toFixed(1)}B  cache_w: ${(m.cacheWrite / 1e6).toFixed(1)}M${RESET}`);
+  }
+  console.log();
+  console.log(`${BOLD}Daily Activity${RESET}`);
+  for (const d of result.daily.slice(-14)) {
+    console.log(`  ${col(d.day, 12)} ${col(d.sessions + " sessions", 14)} ${DIM}${d.userMsgs} user  ${d.assistantTurns} asst${RESET}`);
+  }
+}
+async function cmdFiles(args) {
+  const allFlag = args.includes("--all");
+  const source = parseSource(args);
+  const positional = stripFlags(args);
+  const filePath = positional[0];
+  if (!filePath) {
+    fail("Usage: reconvo files <path> [--all] [--source claude|opencode]");
+  }
+  const sinceMs = getSince(args);
+  const scopePaths = await getScope(allFlag);
+  const results = await searchByFile(filePath, { source, scopePaths, sinceMs });
+  if (results.length === 0) {
+    console.log(`No sessions found touching "${filePath}"`);
+    return;
+  }
+  for (const s of results) {
+    const age = agoLong(s.lastAt);
+    const dirName = s.directory.split("/").pop() ?? s.directory;
+    console.log(`${col(dirName, 18)} ${col(s.title, 40)} ${DIM}${age}  ${s.id.slice(0, 8)}${RESET}`);
+  }
+}
+function cmdHelp() {
+  console.log(`${BOLD}reconvo${RESET} \u2014 recall conversation across Claude Code and OpenCode
+
+${BOLD}Commands:${RESET}
+  index              Build/update search index (incremental)
+  sessions           List sessions (most recent first)
+  search <query>     Search conversations by keyword
+  read <id>          Read messages from a session
+  skim <id>          Head + tail preview of a session
+  stats              Usage dashboard
+  files <path>       Find sessions that touched a file
+  browse             Interactive TUI navigator
+  help               Show this help
+
+${BOLD}Index flags:${RESET}
+  --force            Force full re-index
+  --verbose, -v      Show progress
+
+${BOLD}Read/skim flags:${RESET}
+  --from N           Start at message position N
+  --to M             End at message position M
+  --around N         Center on position N
+  --radius R         Context radius (default: 3)
+  --role <role>      Filter: user, assistant
+
+${BOLD}General flags:${RESET}
+  --all              Search all projects (ignore git context)
+  --source <src>     Filter: claude, opencode
+  --since <expr>     Time filter: 2h, 3d, 1w, today, yesterday, 2026-03-10
+  --json             JSON output
+
+${BOLD}Context:${RESET}
+  Inside a git repo, results are scoped to that project.
+  Use --all to search everything.
+  Index auto-updates on first query if source files changed.
+`);
+}
+var exitCode = 0;
+var args = process.argv.slice(2);
+var cmd = args[0];
+var cmdArgs = args.slice(1);
+try {
+  if (cmd === "help" || cmd === "--help" || cmd === "-h") {
+    cmdHelp();
+  } else if (cmd === "index") {
+    await cmdIndex(cmdArgs);
+  } else {
+    await ensureIndexed(cmdArgs.includes("--verbose") || cmdArgs.includes("-v"));
+    if (!cmd || cmd === "browse") {
+      const allFlag = cmdArgs.includes("--all");
+      const scopePaths = await getScope(allFlag);
+      const { browse: browse2 } = await Promise.resolve().then(() => (init_tui(), exports_tui));
+      await browse2(scopePaths);
+    } else if (cmd === "sessions") {
+      await cmdSessions(cmdArgs);
+    } else if (cmd === "search") {
+      await cmdSearch(cmdArgs);
+    } else if (cmd === "read") {
+      await cmdRead(cmdArgs);
+    } else if (cmd === "skim") {
+      await cmdSkim(cmdArgs);
+    } else if (cmd === "stats") {
+      await cmdStats(cmdArgs);
+    } else if (cmd === "files") {
+      await cmdFiles(cmdArgs);
+    } else {
+      fail(`Unknown command: ${cmd}
+Run 'reconvo help' for usage.`);
+    }
+  }
+} catch (e) {
+  exitCode = 1;
+  if (e instanceof UsageError) {
+    console.error(e.message);
+  } else {
+    console.error(`reconvo: ${e?.message ?? String(e)}`);
+    if (process.env.DEBUG)
+      console.error(e?.stack);
+  }
+}
+if (process.stdout.writableNeedDrain) {
+  process.stdout.once("drain", () => process.exit(exitCode));
+} else {
+  process.exit(exitCode);
+}