backpass 0.1.0

package/src/diff.js

@@ -0,0 +1,305 @@
+/**
+ * Line diff between a file as backpass read it and the copy the synthesis agent edited
+ * natively (design section 3, native-edit revision).
+ *
+ * The synthesis model never hands backpass text to locate in a file; it edits a staging
+ * copy with its own file tools and backpass measures what changed. Each measured hunk is
+ * then turned into a find/replace pair whose `find` is copied out of the original file by
+ * construction - so it always matches, and `applyEdit` can apply it later (at apply time,
+ * against whatever the file is by then) with no fuzzing.
+ *
+ * Two guarantees make the hunks independently reviewable:
+ *   - each `find` is widened with context lines until it occurs exactly once in the file
+ *   - hunks whose context windows touch are merged, so accepting one never moves
+ *     another's anchor
+ */
+
+/** Myers refinement is bounded; past this many edit steps the middle is one hunk. */
+const MAX_EDIT_DISTANCE = 4000;
+
+/**
+ * Shortest edit script between two line arrays (Myers, O(ND)), as a list of ops:
+ * `{ type: "equal" | "delete" | "insert", oldIndex, newIndex }`.
+ */
+export function diffOps(oldLines, newLines) {
+  // Common prefix/suffix first: a real edit touches a tiny fraction of the file.
+  let prefix = 0;
+  const maxPrefix = Math.min(oldLines.length, newLines.length);
+  while (prefix < maxPrefix && oldLines[prefix] === newLines[prefix]) prefix += 1;
+  let suffix = 0;
+  while (
+    suffix < maxPrefix - prefix &&
+    oldLines[oldLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix]
+  ) {
+    suffix += 1;
+  }
+
+  const ops = [];
+  for (let i = 0; i < prefix; i += 1) ops.push({ type: "equal", oldIndex: i, newIndex: i });
+
+  const a = oldLines.slice(prefix, oldLines.length - suffix);
+  const b = newLines.slice(prefix, newLines.length - suffix);
+  for (const op of myers(a, b)) {
+    ops.push({ type: op.type, oldIndex: op.oldIndex + prefix, newIndex: op.newIndex + prefix });
+  }
+
+  for (let i = 0; i < suffix; i += 1) {
+    ops.push({
+      type: "equal",
+      oldIndex: oldLines.length - suffix + i,
+      newIndex: newLines.length - suffix + i,
+    });
+  }
+  return ops;
+}
+
+function myers(a, b) {
+  const n = a.length;
+  const m = b.length;
+  if (!n && !m) return [];
+  if (!n) return b.map((_, j) => ({ type: "insert", oldIndex: 0, newIndex: j }));
+  if (!m) return a.map((_, i) => ({ type: "delete", oldIndex: i, newIndex: 0 }));
+
+  const max = Math.min(n + m, MAX_EDIT_DISTANCE);
+  const offset = max;
+  const trace = [];
+  let v = new Int32Array(2 * max + 2);
+  v[offset + 1] = 0;
+  let found = false;
+
+  for (let d = 0; d <= max && !found; d += 1) {
+    const snapshot = new Int32Array(v);
+    trace.push(snapshot);
+    for (let k = -d; k <= d; k += 2) {
+      let x;
+      if (k === -d || (k !== d && v[offset + k - 1] < v[offset + k + 1])) x = v[offset + k + 1];
+      else x = v[offset + k - 1] + 1;
+      let y = x - k;
+      while (x < n && y < m && a[x] === b[y]) {
+        x += 1;
+        y += 1;
+      }
+      v[offset + k] = x;
+      if (x >= n && y >= m) {
+        found = true;
+        break;
+      }
+    }
+  }
+
+  if (!found) {
+    // Too different to refine within bounds: one hunk replacing the whole middle.
+    return [
+      ...a.map((_, i) => ({ type: "delete", oldIndex: i, newIndex: 0 })),
+      ...b.map((_, j) => ({ type: "insert", oldIndex: n, newIndex: j })),
+    ];
+  }
+
+  // Backtrack through the recorded frontiers.
+  const ops = [];
+  let x = n;
+  let y = m;
+  for (let d = trace.length - 1; d >= 0; d -= 1) {
+    const frontier = trace[d];
+    const k = x - y;
+    let prevK;
+    if (k === -d || (k !== d && frontier[offset + k - 1] < frontier[offset + k + 1])) prevK = k + 1;
+    else prevK = k - 1;
+    const prevX = frontier[offset + prevK];
+    const prevY = prevX - prevK;
+    while (x > prevX && y > prevY) {
+      x -= 1;
+      y -= 1;
+      ops.push({ type: "equal", oldIndex: x, newIndex: y });
+    }
+    if (d > 0) {
+      if (x === prevX) {
+        y -= 1;
+        ops.push({ type: "insert", oldIndex: x, newIndex: y });
+      } else {
+        x -= 1;
+        ops.push({ type: "delete", oldIndex: x, newIndex: y });
+      }
+    }
+  }
+  ops.reverse();
+  return ops;
+}
+
+/**
+ * Raw hunks: maximal runs of non-equal ops, as half-open line ranges into each side.
+ */
+export function rawHunks(ops) {
+  const hunks = [];
+  let current = null;
+  let oldCursor = 0;
+  let newCursor = 0;
+  for (const op of ops) {
+    if (op.type === "equal") {
+      if (current) {
+        hunks.push(current);
+        current = null;
+      }
+      oldCursor = op.oldIndex + 1;
+      newCursor = op.newIndex + 1;
+      continue;
+    }
+    if (!current) current = { oldStart: oldCursor, oldEnd: oldCursor, newStart: newCursor, newEnd: newCursor };
+    if (op.type === "delete") {
+      current.oldEnd = op.oldIndex + 1;
+      oldCursor = op.oldIndex + 1;
+    } else {
+      current.newEnd = op.newIndex + 1;
+      newCursor = op.newIndex + 1;
+    }
+  }
+  if (current) hunks.push(current);
+  return hunks;
+}
+
+/**
+ * Occurrences may overlap (a run of identical lines): counting them non-overlapping
+ * would call a window unique while the first match sits somewhere else entirely.
+ */
+function countOccurrences(haystack, needle) {
+  if (!needle) return 0;
+  let count = 0;
+  let at = haystack.indexOf(needle);
+  while (at !== -1) {
+    count += 1;
+    at = haystack.indexOf(needle, at + 1);
+  }
+  return count;
+}
+
+/**
+ * The text of lines [start, end) together with the separators that make them whole lines
+ * in `lines.join("\n")`: a newline after each line, except that the file's tail carries the
+ * newline *before* it instead. Both sides of a hunk share tail-ness (the suffix after the
+ * change is identical), so `find` and `replace` built this way splice cleanly.
+ */
+function span(lines, start, end) {
+  if (end <= start) return "";
+  const body = lines.slice(start, end).join("\n");
+  if (end === lines.length) return `${start > 0 ? "\n" : ""}${body}`;
+  return `${body}\n`;
+}
+
+/**
+ * Widen a hunk's window symmetrically until its `find` text occurs exactly once in the
+ * original. Terminates because the whole file occurs once.
+ */
+function uniqueWindow(oldLines, oldText, hunk) {
+  let before = 0;
+  let after = 0;
+  for (;;) {
+    const start = hunk.oldStart - before;
+    const end = hunk.oldEnd + after;
+    const find = span(oldLines, start, end);
+    if (find && countOccurrences(oldText, find) === 1) return { before, after };
+    const canBefore = start > 0;
+    const canAfter = end < oldLines.length;
+    if (!canBefore && !canAfter) return { before, after };
+    // Grow the side that still has room, alternating when both do.
+    if (canBefore && (!canAfter || before <= after)) before += 1;
+    else after += 1;
+  }
+}
+
+function mergeTouching(windows) {
+  const merged = [];
+  for (const w of windows) {
+    const last = merged[merged.length - 1];
+    if (last && w.oldStart - w.before <= last.oldEnd + last.after) {
+      last.oldEnd = Math.max(last.oldEnd, w.oldEnd);
+      last.newEnd = Math.max(last.newEnd, w.newEnd);
+      last.touched = true;
+    } else {
+      merged.push({ ...w });
+    }
+  }
+  return merged;
+}
+
+/** Display lines for one window: context, removed, and added lines in file order. */
+function displayLines(oldSlice, newSlice) {
+  const lines = [];
+  for (const op of diffOps(oldSlice, newSlice)) {
+    if (op.type === "equal") lines.push({ type: "ctx", text: oldSlice[op.oldIndex] });
+    else if (op.type === "delete") lines.push({ type: "del", text: oldSlice[op.oldIndex] });
+    else lines.push({ type: "ins", text: newSlice[op.newIndex] });
+  }
+  return lines;
+}
+
+/**
+ * Measure `newText` against `oldText` as anchored hunks:
+ *
+ *   {
+ *     find, replace,        // context-widened; `find` occurs exactly once in oldText
+ *     oldStart, oldEnd,     // 1-based inclusive line range of the changed lines in oldText
+ *                           // (oldEnd === oldStart - 1 for a pure insertion)
+ *     removed, added,       // changed line counts, context excluded
+ *     lines,                // [{ type: "ctx" | "del" | "ins", text }] for display
+ *   }
+ *
+ * Hunks are independent: their context windows never overlap, so any subset applies in
+ * any order via `applyEdit`.
+ */
+export function anchoredHunks(oldText, newText) {
+  if (oldText === newText) return [];
+  if (!oldText) {
+    return [
+      {
+        find: "",
+        replace: newText,
+        oldStart: 1,
+        oldEnd: 0,
+        removed: 0,
+        added: newText.split("\n").length,
+        lines: newText.split("\n").map((text) => ({ type: "ins", text })),
+      },
+    ];
+  }
+
+  const oldLines = oldText.split("\n");
+  const newLines = newText.split("\n");
+  let windows = rawHunks(diffOps(oldLines, newLines)).map((h) => ({ ...h, ...uniqueWindow(oldLines, oldText, h) }));
+
+  // Merging can widen a window past a neighbour; iterate to a fixed point.
+  for (;;) {
+    const merged = mergeTouching(windows);
+    const settled = merged.map((w) =>
+      w.touched ? { ...w, ...uniqueWindow(oldLines, oldText, w), touched: false } : w,
+    );
+    if (settled.length === windows.length) {
+      windows = settled;
+      break;
+    }
+    windows = settled;
+  }
+
+  return windows.map((w) => {
+    const start = w.oldStart - w.before;
+    const end = w.oldEnd + w.after;
+    const newStart = w.newStart - w.before;
+    const newEnd = w.newEnd + w.after;
+    return {
+      find: span(oldLines, start, end),
+      replace: span(newLines, newStart, newEnd),
+      oldStart: w.oldStart + 1,
+      oldEnd: w.oldEnd,
+      removed: w.oldEnd - w.oldStart,
+      added: w.newEnd - w.newStart,
+      lines: displayLines(oldLines.slice(start, end), newLines.slice(newStart, newEnd)),
+    };
+  });
+}
+
+/** Plain-text rendering of a hunk's lines, unified-diff style, for prompts and terminals. */
+export function renderHunkLines(lines, { maxLines = 400 } = {}) {
+  const marks = { ctx: " ", del: "-", ins: "+" };
+  const shown = lines.slice(0, maxLines).map((l) => `${marks[l.type]} ${l.text}`);
+  if (lines.length > maxLines) shown.push(`  ... ${lines.length - maxLines} more line(s)`);
+  return shown.join("\n");
+}

package/src/discovery/adapters/claude.js

@@ -0,0 +1,77 @@
+import path from "node:path";
+
+import {
+  attachToolResults,
+  contentToEvents,
+  home,
+  listDirs,
+  listFiles,
+  parseJsonLine,
+  readHeadLines,
+  readJsonl,
+  statOrNull,
+} from "./shared.js";
+
+/**
+ * Claude Code: ~/.claude/projects/<munged-cwd>/<session-uuid>.jsonl
+ *
+ * Every message line carries `cwd`, `gitBranch`, `sessionId` and `version`. The
+ * directory name is a lossy munge of the cwd (slashes and dots both become dashes),
+ * so it is only used to narrow the search - the per-line `cwd` is the authority.
+ * No git remote is recorded, so a deleted worktree can only reach tier 3.
+ */
+
+const HEADER_LINES = 40;
+
+export const name = "claude";
+
+export function storeRoot() {
+  return home(".claude", "projects");
+}
+
+export function enumerate() {
+  const out = [];
+  for (const dir of listDirs(storeRoot())) {
+    for (const file of listFiles(dir, ".jsonl")) {
+      const stat = statOrNull(file);
+      if (!stat) continue;
+      out.push({ key: file, path: file, mtimeMs: stat.mtimeMs, bytes: stat.size });
+    }
+  }
+  return out;
+}
+
+export function classify(candidate) {
+  for (const line of readHeadLines(candidate.path, HEADER_LINES)) {
+    const entry = parseJsonLine(line);
+    if (!entry || !entry.cwd) continue;
+    return {
+      id: entry.sessionId || path.basename(candidate.path, ".jsonl"),
+      cwd: entry.cwd,
+      gitBranch: entry.gitBranch || null,
+      remotes: [],
+      startedAt: entry.timestamp ? Date.parse(entry.timestamp) : candidate.mtimeMs,
+      model: null,
+    };
+  }
+  return null;
+}
+
+export function read(ref) {
+  const entries = readJsonl(ref.path);
+  const events = [];
+  let model = null;
+
+  for (const entry of entries) {
+    if (entry.type === "user" && entry.message) {
+      if (entry.isSidechain) continue;
+      contentToEvents("user", entry.message.content, events);
+    } else if (entry.type === "assistant" && entry.message) {
+      if (entry.isSidechain) continue;
+      model = model || entry.message.model || null;
+      contentToEvents("assistant", entry.message.content, events);
+    }
+  }
+
+  return { events: attachToolResults(events), model };
+}

package/src/discovery/adapters/codex.js

@@ -0,0 +1,162 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import {
+  attachToolResults,
+  contentToEvents,
+  home,
+  parseJsonLine,
+  readHeadLines,
+  readJsonl,
+  statOrNull,
+} from "./shared.js";
+
+/**
+ * Codex: ~/.codex/sessions/YYYY/MM/DD/rollout-<ts>-<uuid>.jsonl
+ *
+ * Line 1 is a `session_meta` record carrying `cwd` and, for sessions started inside a
+ * repo, `git.repository_url` - which is why codex stays deterministic even after the
+ * worktree is deleted (tier 2). The store is date-sharded and large (10k+ rollouts on
+ * a working machine), so discovery reads only line 1 and leans on the scan cache.
+ */
+
+export const name = "codex";
+
+export function storeRoot() {
+  return home(".codex", "sessions");
+}
+
+/**
+ * Walk the YYYY/MM/DD shards, skipping whole day directories outside the time window.
+ * @param {{ cutoffMs?: number }} [options]
+ */
+export function enumerate({ cutoffMs } = {}) {
+  const root = storeRoot();
+  const out = [];
+  if (!fs.existsSync(root)) return out;
+
+  for (const year of shardDirs(root)) {
+    for (const month of shardDirs(year)) {
+      for (const day of shardDirs(month)) {
+        if (cutoffMs && dayIsBefore(root, day, cutoffMs)) continue;
+        let files;
+        try {
+          files = fs.readdirSync(day, { withFileTypes: true });
+        } catch {
+          continue;
+        }
+        for (const entry of files) {
+          if (!entry.isFile() || !entry.name.startsWith("rollout-") || !entry.name.endsWith(".jsonl")) continue;
+          const file = path.join(day, entry.name);
+          const stat = statOrNull(file);
+          if (!stat) continue;
+          out.push({ key: file, path: file, mtimeMs: stat.mtimeMs, bytes: stat.size });
+        }
+      }
+    }
+  }
+  return out;
+}
+
+function shardDirs(dir) {
+  try {
+    return fs
+      .readdirSync(dir, { withFileTypes: true })
+      .filter((e) => e.isDirectory() && /^\d+$/.test(e.name))
+      .map((e) => path.join(dir, e.name));
+  } catch {
+    return [];
+  }
+}
+
+/** The shard path itself dates the sessions, so whole days can be skipped without stat-ing. */
+function dayIsBefore(root, dayDir, cutoffMs) {
+  const parts = path.relative(root, dayDir).split(path.sep);
+  if (parts.length !== 3) return false;
+  const [y, m, d] = parts.map(Number);
+  if (!y || !m || !d) return false;
+  // End of that day in UTC+14 (the earliest a local timestamp can roll over).
+  const endOfDay = Date.UTC(y, m - 1, d + 1) + 14 * 3600_000;
+  return endOfDay < cutoffMs;
+}
+
+export function classify(candidate) {
+  const [first] = readHeadLines(candidate.path, 1);
+  const entry = first && parseJsonLine(first);
+  if (!entry || entry.type !== "session_meta") return null;
+  const payload = entry.payload || {};
+  const git = payload.git || {};
+  return {
+    id: payload.session_id || payload.id || path.basename(candidate.path, ".jsonl"),
+    cwd: payload.cwd || null,
+    gitBranch: git.branch || null,
+    remotes: git.repository_url ? [git.repository_url] : [],
+    startedAt: payload.timestamp ? Date.parse(payload.timestamp) : candidate.mtimeMs,
+    model: payload.model || null,
+  };
+}
+
+export function read(ref) {
+  const entries = readJsonl(ref.path);
+  const events = [];
+  let model = null;
+
+  for (const entry of entries) {
+    if (entry.type === "turn_context" && entry.payload?.model) {
+      model = model || entry.payload.model;
+      continue;
+    }
+    if (entry.type !== "response_item") continue;
+    const payload = entry.payload || {};
+
+    switch (payload.type) {
+      case "message": {
+        // `developer` messages are harness scaffolding, never user intent.
+        if (payload.role !== "user" && payload.role !== "assistant") break;
+        contentToEvents(payload.role, payload.content, events);
+        break;
+      }
+      case "function_call":
+      case "custom_tool_call":
+        events.push({
+          kind: "tool",
+          name: payload.name,
+          input: parseMaybeJson(payload.arguments ?? payload.input),
+          pendingId: payload.call_id,
+        });
+        break;
+      case "function_call_output":
+      case "custom_tool_call_output":
+        events.push({
+          kind: "tool-result",
+          id: payload.call_id,
+          result: flattenOutput(payload.output),
+        });
+        break;
+      default:
+        break;
+    }
+  }
+
+  return { events: attachToolResults(events), model };
+}
+
+function parseMaybeJson(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+function flattenOutput(output) {
+  if (typeof output === "string") return output;
+  if (Array.isArray(output)) {
+    return output
+      .map((b) => (typeof b === "string" ? b : (b?.text ?? "")))
+      .filter(Boolean)
+      .join("\n");
+  }
+  return output;
+}

package/src/discovery/adapters/cursor-cli.js

@@ -0,0 +1,109 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+import { home, listDirs, readJsonFile, statOrNull } from "./shared.js";
+import { openReadOnly, safeJsonParse } from "./sqlite.js";
+
+/**
+ * Cursor CLI: ~/.cursor/chats/<md5(cwd)>/<session-uuid>/{meta.json, store.db}
+ *
+ * The chat directory name is md5 of the cwd (verified by reproducing the digest), so a
+ * live worktree can be looked up directly instead of scanning. meta.json carries the
+ * exact `cwd` and timestamps.
+ *
+ * store.db is `blobs(id TEXT PRIMARY KEY, data BLOB)`: a content-addressed graph whose
+ * index blobs are an undocumented binary format. Plain-JSON `{role, content}` message
+ * blobs are readable and are what backpass uses; anything that does not parse is
+ * skipped. Because the store is content-addressed there is no recorded message order,
+ * so blobs are read in insertion (rowid) order - the closest available proxy.
+ */
+
+export const name = "cursor";
+export const sqliteBacked = true;
+
+export function storeRoot() {
+  return home(".cursor", "chats");
+}
+
+export function cwdHash(cwd) {
+  return crypto.createHash("md5").update(cwd, "utf8").digest("hex");
+}
+
+export function enumerate() {
+  const out = [];
+  for (const hashDir of listDirs(storeRoot())) {
+    for (const sessionDir of listDirs(hashDir)) {
+      const meta = path.join(sessionDir, "meta.json");
+      const stat = statOrNull(meta);
+      if (!stat) continue;
+      out.push({ key: sessionDir, path: sessionDir, mtimeMs: stat.mtimeMs, bytes: stat.size });
+    }
+  }
+  return out;
+}
+
+export function classify(candidate) {
+  const meta = readJsonFile(path.join(candidate.path, "meta.json"));
+  if (!meta?.cwd) return null;
+  return {
+    id: path.basename(candidate.path),
+    cwd: meta.cwd,
+    gitBranch: null,
+    remotes: [],
+    title: meta.title || null,
+    startedAt: meta.createdAtMs || candidate.mtimeMs,
+    model: null,
+  };
+}
+
+export async function read(ref) {
+  const db = await openReadOnly(path.join(ref.path, "store.db"));
+  if (!db) return { events: [], model: null };
+
+  try {
+    const rows = db.prepare("SELECT data FROM blobs ORDER BY rowid").all();
+    const events = [];
+
+    for (const row of rows) {
+      const text = toUtf8(row.data);
+      if (!text || text[0] !== "{") continue;
+      const value = safeJsonParse(text);
+      if (!value || typeof value !== "object") continue;
+      const role = value.role;
+      if (role !== "user" && role !== "assistant") continue;
+      pushContent(role, value.content, events);
+    }
+
+    return { events, model: null };
+  } finally {
+    db.close();
+  }
+}
+
+function toUtf8(data) {
+  if (typeof data === "string") return data.trim();
+  if (data instanceof Uint8Array || Buffer.isBuffer(data)) return Buffer.from(data).toString("utf8").trim();
+  return null;
+}
+
+function pushContent(role, content, events) {
+  if (typeof content === "string") {
+    if (content.trim()) events.push({ kind: "message", role, text: content });
+    return;
+  }
+  if (!Array.isArray(content)) return;
+  const texts = content
+    .map((b) => (typeof b === "string" ? b : b?.text))
+    .filter((t) => typeof t === "string" && t.trim());
+  if (texts.length) events.push({ kind: "message", role, text: texts.join("\n") });
+}
+
+/**
+ * Fast path for live worktrees: the md5 lookup finds the chat directory without
+ * scanning every session on the machine.
+ */
+export function directoriesForCwd(cwd) {
+  const dir = path.join(storeRoot(), cwdHash(cwd));
+  return fs.existsSync(dir) ? listDirs(dir) : [];
+}