greview-cli 0.0.0 → 0.12.2

package/dist/cli.js

@@ -0,0 +1,1425 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { parseArgs } from "node:util";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { spawn, spawnSync as spawnSync2 } from "node:child_process";
+
+// src/anchor.ts
+function splitLines(text) {
+  if (text === "") return [];
+  const lines = text.split("\n");
+  if (lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+var DP_BUDGET = 2e6;
+function lineMap(a, b) {
+  const map = new Int32Array(a.length + 1);
+  const max = Math.min(a.length, b.length);
+  let prefix = 0;
+  while (prefix < max && a[prefix] === b[prefix]) prefix++;
+  let suffix = 0;
+  while (suffix < max - prefix && a[a.length - 1 - suffix] === b[b.length - 1 - suffix]) suffix++;
+  for (let i2 = 0; i2 < prefix; i2++) map[i2 + 1] = i2 + 1;
+  for (let i2 = 0; i2 < suffix; i2++) map[a.length - i2] = b.length - i2;
+  const aMid = a.slice(prefix, a.length - suffix);
+  const bMid = b.slice(prefix, b.length - suffix);
+  if (aMid.length === 0 || bMid.length === 0) return map;
+  if (aMid.length * bMid.length > DP_BUDGET) return map;
+  const w = bMid.length + 1;
+  const dp = new Int32Array((aMid.length + 1) * w);
+  for (let i2 = aMid.length - 1; i2 >= 0; i2--) {
+    for (let j2 = bMid.length - 1; j2 >= 0; j2--) {
+      dp[i2 * w + j2] = aMid[i2] === bMid[j2] ? dp[(i2 + 1) * w + j2 + 1] + 1 : Math.max(dp[(i2 + 1) * w + j2], dp[i2 * w + j2 + 1]);
+    }
+  }
+  let i = 0;
+  let j = 0;
+  while (i < aMid.length && j < bMid.length) {
+    if (aMid[i] === bMid[j]) {
+      map[prefix + i + 1] = prefix + j + 1;
+      i++;
+      j++;
+    } else if (dp[(i + 1) * w + j] >= dp[i * w + j + 1]) {
+      i++;
+    } else {
+      j++;
+    }
+  }
+  return map;
+}
+function findBlock(b, block, limit) {
+  const out = [];
+  if (block.length === 0 || block.length > b.length) return out;
+  for (let i = 0; i + block.length <= b.length; i++) {
+    let hit = true;
+    for (let k = 0; k < block.length && hit; k++) hit = b[i + k] === block[k];
+    if (hit) {
+      out.push(i + 1);
+      if (out.length > limit) break;
+    }
+  }
+  return out;
+}
+function mapRange(aText, bText, start, end) {
+  const a = splitLines(aText);
+  const b = splitLines(bText);
+  const s = Math.max(1, Math.min(start, a.length || 1));
+  const e = Math.max(s, Math.min(end, a.length || 1));
+  if (aText === bText) return { drift: "current", start: s, end: e };
+  const map = lineMap(a, b);
+  let intact2 = map[s] !== 0;
+  for (let l = s; intact2 && l < e; l++) {
+    if (map[l + 1] !== map[l] + 1) intact2 = false;
+  }
+  if (intact2) {
+    const ns2 = map[s];
+    const ne2 = map[e];
+    return { drift: ns2 === s && ne2 === e ? "current" : "moved", start: ns2, end: ne2 };
+  }
+  const block = a.slice(s - 1, e);
+  const found = findBlock(b, block, 4);
+  const distinctive = block.length >= 2 || block.join("").trim().length >= 12;
+  if (found.length === 1 || found.length > 1 && found.length <= 4 && distinctive) {
+    let best = found[0];
+    for (const o of found) {
+      if (Math.abs(o - s) < Math.abs(best - s)) best = o;
+    }
+    return { drift: "moved", start: best, end: best + block.length - 1 };
+  }
+  let ns = 0;
+  for (let l = s - 1; l >= 1; l--) {
+    if (map[l]) {
+      ns = map[l] + 1;
+      break;
+    }
+  }
+  if (ns === 0) ns = 1;
+  let ne = 0;
+  for (let l = e + 1; l <= a.length; l++) {
+    if (map[l]) {
+      ne = map[l] - 1;
+      break;
+    }
+  }
+  if (ne === 0) ne = b.length;
+  return { drift: "changed", start: ns, end: ne };
+}
+function sliceLines(text, start, end) {
+  if (end < start) return [];
+  return splitLines(text).slice(Math.max(0, start - 1), end);
+}
+
+// src/git.ts
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
+var GitError = class extends Error {
+};
+function git(cwd, args) {
+  const r = spawnSync("git", args, { cwd, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+  if (r.error) throw new GitError(`failed to run git: ${r.error.message}`);
+  return { status: r.status ?? 1, stdout: r.stdout ?? "", stderr: r.stderr ?? "" };
+}
+function gitOk(cwd, args) {
+  const r = git(cwd, args);
+  if (r.status !== 0) throw new GitError(`git ${args.join(" ")} failed: ${r.stderr.trim()}`);
+  return r.stdout;
+}
+function findRepo(cwd) {
+  const root = gitOk(cwd, ["rev-parse", "--show-toplevel"]).trim();
+  const gitDir = gitOk(cwd, ["rev-parse", "--absolute-git-dir"]).trim();
+  if (!root) throw new GitError("not inside a git working tree");
+  return { root, gitDir };
+}
+function headSha(repo) {
+  const r = git(repo.root, ["rev-parse", "HEAD"]);
+  return r.status === 0 ? r.stdout.trim() : null;
+}
+function branchName(repo) {
+  const r = git(repo.root, ["symbolic-ref", "--short", "-q", "HEAD"]);
+  const name = r.stdout.trim();
+  return r.status === 0 && name ? name : null;
+}
+function toRepoPath(repo, input, cwd = process.cwd()) {
+  const r = git(cwd, ["ls-files", "--full-name", "-co", "--error-unmatch", "--", input]);
+  if (r.status === 0) {
+    const first = r.stdout.split("\n").find((l) => l.trim() !== "");
+    if (first) return first.trim();
+  }
+  const abs = isAbsolute(input) ? input : resolve(cwd, input);
+  const rel = relative(repo.root, abs);
+  if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) {
+    throw new GitError(`${input} is outside ${repo.root}`);
+  }
+  return rel.split("\\").join("/");
+}
+function readVersion(repo, version, path) {
+  if (version === "worktree") {
+    try {
+      return readFileSync(join(repo.root, path), "utf8");
+    } catch {
+      return null;
+    }
+  }
+  const spec = version === "index" ? `:${path}` : `HEAD:${path}`;
+  const r = git(repo.root, ["cat-file", "blob", spec]);
+  return r.status === 0 ? r.stdout : null;
+}
+function versionFor(target, side) {
+  if (side === "new") return target === "index" ? "index" : "worktree";
+  return target === "worktree" ? "index" : "head";
+}
+var DIFF_ARGS = {
+  worktree: [],
+  index: ["--cached"],
+  head: ["HEAD"]
+};
+function hunks(repo, target, path) {
+  const r = git(repo.root, [
+    "--no-pager",
+    "diff",
+    ...DIFF_ARGS[target],
+    "--no-color",
+    "-U0",
+    "--",
+    path
+  ]);
+  if (r.status !== 0) return [];
+  const out = [];
+  for (const line of r.stdout.split("\n")) {
+    const m = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(line);
+    if (!m) continue;
+    out.push({
+      header: line,
+      oldStart: Number(m[1]),
+      oldCount: m[2] === void 0 ? 1 : Number(m[2]),
+      newStart: Number(m[3]),
+      newCount: m[4] === void 0 ? 1 : Number(m[4])
+    });
+  }
+  return out;
+}
+function hunkHeaderAt(repo, target, side, path, line) {
+  for (const h of hunks(repo, target, path)) {
+    const start = side === "new" ? h.newStart : h.oldStart;
+    const count = side === "new" ? h.newCount : h.oldCount;
+    if (count === 0 ? line === start || line === start + 1 : line >= start && line < start + count) {
+      return h.header;
+    }
+  }
+  return null;
+}
+function renameOf(repo, path) {
+  const r = git(repo.root, [
+    "--no-pager",
+    "diff",
+    "HEAD",
+    "--name-status",
+    "--find-renames",
+    "--diff-filter=R"
+  ]);
+  if (r.status !== 0) return null;
+  for (const line of r.stdout.split("\n")) {
+    const parts = line.split("	");
+    if (parts.length >= 3 && parts[0].startsWith("R") && parts[1] === path) return parts[2];
+  }
+  return null;
+}
+
+// src/store.ts
+import { createHash } from "node:crypto";
+import { mkdirSync } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+
+// src/sqlite.ts
+import { createRequire } from "node:module";
+var cached = null;
+function sqlite() {
+  if (cached) return cached;
+  const original = process.emitWarning;
+  process.emitWarning = ((warning, ...rest) => {
+    const text = typeof warning === "string" ? warning : String(warning?.message ?? "");
+    if (/SQLite is an experimental feature/i.test(text)) return;
+    return original(warning, ...rest);
+  });
+  try {
+    cached = createRequire(import.meta.url)("node:sqlite");
+  } finally {
+    process.emitWarning = original;
+  }
+  return cached;
+}
+
+// src/store.ts
+var MIGRATIONS = [
+  `
+    CREATE TABLE IF NOT EXISTS blobs (
+      sha TEXT PRIMARY KEY,
+      content TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS threads (
+      id           INTEGER PRIMARY KEY AUTOINCREMENT,
+      file_path    TEXT NOT NULL,
+      side         TEXT NOT NULL,
+      target       TEXT NOT NULL,
+      anchor_blob  TEXT NOT NULL REFERENCES blobs(sha),
+      anchor_start INTEGER NOT NULL,
+      anchor_end   INTEGER NOT NULL,
+      hunk_header  TEXT,
+      status       TEXT NOT NULL DEFAULT 'open',
+      created_at   TEXT NOT NULL,
+      updated_at   TEXT NOT NULL,
+      resolved_at  TEXT,
+      resolved_by  TEXT,
+      drift        TEXT,
+      cur_start    INTEGER,
+      cur_end      INTEGER,
+      locations    TEXT,
+      checked_at   TEXT
+    );
+    CREATE INDEX IF NOT EXISTS threads_by_file ON threads(file_path);
+    CREATE TABLE IF NOT EXISTS comments (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      thread_id   INTEGER NOT NULL REFERENCES threads(id) ON DELETE CASCADE,
+      author      TEXT NOT NULL,
+      author_kind TEXT NOT NULL,
+      body        TEXT NOT NULL,
+      created_at  TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS comments_by_thread ON comments(thread_id);
+    CREATE TABLE IF NOT EXISTS events (
+      id        INTEGER PRIMARY KEY AUTOINCREMENT,
+      thread_id INTEGER NOT NULL REFERENCES threads(id) ON DELETE CASCADE,
+      kind      TEXT NOT NULL,
+      detail    TEXT NOT NULL,
+      at        TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS events_by_thread ON events(thread_id);
+  `,
+  "ALTER TABLE threads ADD COLUMN base_locations TEXT",
+  "ALTER TABLE comments ADD COLUMN edited_at TEXT",
+  `
+    CREATE TABLE IF NOT EXISTS onsubmit (
+      name       TEXT PRIMARY KEY,
+      command    TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    );
+  `
+];
+function one(v) {
+  return v ?? null;
+}
+function many(v) {
+  return v;
+}
+function dbPathFor(repo) {
+  return join2(repo.gitDir, "review", "comments.sqlite");
+}
+function sha256(text) {
+  return createHash("sha256").update(text, "utf8").digest("hex");
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var Store = class {
+  db;
+  path;
+  constructor(repo) {
+    this.path = dbPathFor(repo);
+    mkdirSync(dirname(this.path), { recursive: true });
+    this.db = new (sqlite()).DatabaseSync(this.path);
+    this.db.exec("PRAGMA journal_mode = WAL");
+    this.db.exec("PRAGMA busy_timeout = 5000");
+    this.db.exec("PRAGMA foreign_keys = ON");
+    this.migrate();
+  }
+  close() {
+    this.db.close();
+  }
+  migrate() {
+    this.db.exec("CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
+    const found = Number(this.getMeta("schema_version") ?? "0");
+    if (found > MIGRATIONS.length) {
+      throw new Error(
+        `database schema v${found} is newer than this greview (v${MIGRATIONS.length}); upgrade the CLI`
+      );
+    }
+    for (let version = found; version < MIGRATIONS.length; version++) {
+      this.db.exec(MIGRATIONS[version]);
+    }
+    if (found !== MIGRATIONS.length) this.setMeta("schema_version", String(MIGRATIONS.length));
+  }
+  setMeta(key, value) {
+    this.db.prepare("INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = ?").run(key, value, value);
+  }
+  getMeta(key) {
+    const row = this.db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
+    return row ? row.value : null;
+  }
+  /** Bumped on every write. */
+  bumpRevision() {
+    const next = Number(this.getMeta("revision") ?? "0") + 1;
+    this.setMeta("revision", String(next));
+  }
+  revision() {
+    return Number(this.getMeta("revision") ?? "0");
+  }
+  putBlob(content) {
+    const sha = sha256(content);
+    this.db.prepare("INSERT OR IGNORE INTO blobs (sha, content) VALUES (?, ?)").run(sha, content);
+    return sha;
+  }
+  getBlob(sha) {
+    const row = this.db.prepare("SELECT content FROM blobs WHERE sha = ?").get(sha);
+    return row ? row.content : null;
+  }
+  createThread(input) {
+    const at = nowIso();
+    const blob = this.putBlob(input.content);
+    const info = this.db.prepare(
+      `INSERT INTO threads
+           (file_path, side, target, anchor_blob, anchor_start, anchor_end, hunk_header,
+            status, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, 'open', ?, ?)`
+    ).run(
+      input.filePath,
+      input.side,
+      input.target,
+      blob,
+      input.start,
+      input.end,
+      input.hunkHeader,
+      at,
+      at
+    );
+    const id = Number(info.lastInsertRowid);
+    this.addComment(id, input.author, input.authorKind, input.body);
+    this.addEvent(id, "created", { target: input.target, side: input.side });
+    this.bumpRevision();
+    return id;
+  }
+  addComment(threadId, author, authorKind, body) {
+    const at = nowIso();
+    const info = this.db.prepare(
+      `INSERT INTO comments (thread_id, author, author_kind, body, created_at)
+         VALUES (?, ?, ?, ?, ?)`
+    ).run(threadId, author, authorKind, body, at);
+    this.db.prepare("UPDATE threads SET updated_at = ? WHERE id = ?").run(at, threadId);
+    this.bumpRevision();
+    return Number(info.lastInsertRowid);
+  }
+  /** Rewrites a comment body. Returns the thread it belongs to, or null. */
+  editComment(commentId, body) {
+    const row = one(
+      this.db.prepare("SELECT thread_id FROM comments WHERE id = ?").get(commentId)
+    );
+    if (row === null) return null;
+    const at = nowIso();
+    this.db.prepare("UPDATE comments SET body = ?, edited_at = ? WHERE id = ?").run(body, at, commentId);
+    this.db.prepare("UPDATE threads SET updated_at = ? WHERE id = ?").run(at, row.thread_id);
+    this.bumpRevision();
+    return row.thread_id;
+  }
+  addEvent(threadId, kind, detail) {
+    this.db.prepare("INSERT INTO events (thread_id, kind, detail, at) VALUES (?, ?, ?, ?)").run(threadId, kind, JSON.stringify(detail), nowIso());
+  }
+  setStatus(threadId, status, by) {
+    const at = nowIso();
+    this.db.prepare("UPDATE threads SET status = ?, resolved_at = ?, resolved_by = ?, updated_at = ? WHERE id = ?").run(status, status === "resolved" ? at : null, status === "resolved" ? by : null, at, threadId);
+    this.addEvent(threadId, status === "resolved" ? "resolved" : "unresolved", { by });
+    this.bumpRevision();
+  }
+  /**
+   * Persists a fresh resolution, but only when it differs: the extension watches
+   * this file, so an unchanged row must not be stamped.
+   */
+  saveResolution(threadId, r) {
+    const locations = JSON.stringify(r.locations);
+    const current = one(
+      this.db.prepare("SELECT drift, cur_start, cur_end, locations FROM threads WHERE id = ?").get(threadId)
+    );
+    if (current !== null && current.drift === r.drift && current.cur_start === r.start && current.cur_end === r.end && current.locations === locations) {
+      return;
+    }
+    this.db.prepare("UPDATE threads SET drift = ?, cur_start = ?, cur_end = ?, locations = ?, checked_at = ? WHERE id = ?").run(r.drift, r.start, r.end, locations, nowIso(), threadId);
+  }
+  /** Written once, on the first sync. */
+  saveBaseLocations(threadId, locations) {
+    this.db.prepare("UPDATE threads SET base_locations = ? WHERE id = ? AND base_locations IS NULL").run(JSON.stringify(locations), threadId);
+  }
+  deleteThread(threadId) {
+    const info = this.db.prepare("DELETE FROM threads WHERE id = ?").run(threadId);
+    this.bumpRevision();
+    return info.changes > 0;
+  }
+  thread(id) {
+    return one(this.db.prepare("SELECT * FROM threads WHERE id = ?").get(id));
+  }
+  threads() {
+    return many(
+      this.db.prepare("SELECT * FROM threads ORDER BY file_path, anchor_start, id").all()
+    );
+  }
+  comments(threadId) {
+    return many(
+      this.db.prepare("SELECT * FROM comments WHERE thread_id = ? ORDER BY id").all(threadId)
+    );
+  }
+  events(threadId) {
+    return many(
+      this.db.prepare("SELECT * FROM events WHERE thread_id = ? ORDER BY id").all(threadId)
+    );
+  }
+  lastEvent(threadId, kind) {
+    return one(
+      this.db.prepare("SELECT * FROM events WHERE thread_id = ? AND kind = ? ORDER BY id DESC LIMIT 1").get(threadId, kind)
+    );
+  }
+  callbacks() {
+    return many(this.db.prepare("SELECT * FROM onsubmit ORDER BY name").all());
+  }
+  /** Adds or replaces a submit hook, keyed by name. */
+  putCallback(name, command) {
+    this.db.prepare(
+      `INSERT INTO onsubmit (name, command, created_at) VALUES (?, ?, ?)
+         ON CONFLICT(name) DO UPDATE SET command = excluded.command`
+    ).run(name, command, nowIso());
+    this.bumpRevision();
+  }
+  deleteCallback(name) {
+    const info = this.db.prepare("DELETE FROM onsubmit WHERE name = ?").run(name);
+    this.bumpRevision();
+    return info.changes > 0;
+  }
+  clearCallbacks() {
+    const info = this.db.prepare("DELETE FROM onsubmit").run();
+    this.bumpRevision();
+    return Number(info.changes);
+  }
+  transaction(fn) {
+    this.db.exec("BEGIN");
+    try {
+      const out = fn();
+      this.db.exec("COMMIT");
+      return out;
+    } catch (e) {
+      this.db.exec("ROLLBACK");
+      throw e;
+    }
+  }
+};
+
+// src/sync.ts
+var VERSIONS = ["worktree", "index", "head"];
+function intact(d) {
+  return d === "current" || d === "moved";
+}
+function sameRegion(a, b) {
+  return a !== null && b !== null && a.lines.join("\n") === b.lines.join("\n");
+}
+function resolveThread(repo, store, row) {
+  const anchor = store.getBlob(row.anchor_blob);
+  if (anchor === null) {
+    return {
+      drift: "orphaned",
+      region: null,
+      locations: { worktree: "orphaned", index: "orphaned", head: "orphaned" },
+      notes: [
+        {
+          code: "snapshot-missing",
+          text: "the recorded snapshot of this file is missing from the database"
+        }
+      ],
+      renamedTo: null
+    };
+  }
+  let path = row.file_path;
+  let renamedTo = null;
+  if (readVersion(repo, "worktree", path) === null) {
+    const moved = renameOf(repo, path);
+    if (moved && readVersion(repo, "worktree", moved) !== null) {
+      renamedTo = moved;
+      path = moved;
+    }
+  }
+  const locations = {};
+  const regions = {};
+  for (const v of VERSIONS) {
+    const readPath = v === "worktree" ? path : row.file_path;
+    const content = readVersion(repo, v, readPath);
+    if (content === null) {
+      locations[v] = "orphaned";
+      regions[v] = null;
+      continue;
+    }
+    const m = mapRange(anchor, content, row.anchor_start, row.anchor_end);
+    locations[v] = m.drift;
+    regions[v] = { start: m.start, end: m.end, lines: sliceLines(content, m.start, m.end) };
+  }
+  const primary = versionFor(row.target, row.side);
+  const drift = locations[primary];
+  const region = regions[primary];
+  const baseline = row.base_locations ? JSON.parse(row.base_locations) : null;
+  const wasIntact = (v) => intact(baseline === null ? locations[v] : baseline[v]);
+  const notes = [];
+  const note = (code, text, args) => {
+    notes.push(args ? { code, text, args } : { code, text });
+  };
+  if (renamedTo) note("renamed", `file renamed to ${renamedTo}`, { path: renamedTo });
+  if (drift === "changed") {
+    if (region.end < region.start) note("deleted", "the commented lines were deleted");
+    else note("edited", "the commented lines were edited");
+  }
+  if (drift === "orphaned") {
+    note("orphaned", `${row.file_path} does not exist in the ${primary} version`, {
+      path: row.file_path,
+      version: primary
+    });
+  }
+  if (row.side === "new" && row.target === "worktree") {
+    if (intact(locations.index)) {
+      if (!wasIntact("index")) note("staged", "content is now staged");
+    } else if (sameRegion(regions.worktree, regions.index)) {
+      note("replacement-staged", "the lines that replaced them are staged");
+    }
+  }
+  if (row.side === "new" && intact(locations.head) && !wasIntact("head")) {
+    note("committed", "content is now committed in HEAD");
+  }
+  if (row.side === "new" && row.target !== "worktree" && !intact(locations.worktree) && drift !== "orphaned") {
+    note("worktree-diverged", "the working tree has since diverged from this content");
+  }
+  return { drift, region, locations, notes, renamedTo };
+}
+function syncThread(repo, store, row) {
+  const r = resolveThread(repo, store, row);
+  const prev = row.locations ? JSON.parse(row.locations) : null;
+  if (row.base_locations === null) store.saveBaseLocations(row.id, r.locations);
+  if (row.drift !== null && row.drift !== r.drift) {
+    const anchorLines = splitLines(store.getBlob(row.anchor_blob) ?? "").slice(
+      row.anchor_start - 1,
+      row.anchor_end
+    );
+    store.addEvent(row.id, "drift", {
+      from: row.drift,
+      to: r.drift,
+      before: anchorLines,
+      after: r.region ? r.region.lines : [],
+      beforeRange: [row.anchor_start, row.anchor_end],
+      afterRange: r.region ? [r.region.start, r.region.end] : null
+    });
+  }
+  if (prev) {
+    if (!intact(prev.index) && intact(r.locations.index)) {
+      store.addEvent(row.id, "staged", { drift: r.locations.index });
+    } else if (intact(prev.index) && !intact(r.locations.index)) {
+      store.addEvent(row.id, "unstaged", { drift: r.locations.index });
+    }
+    if (!intact(prev.head) && intact(r.locations.head)) {
+      store.addEvent(row.id, "committed", { drift: r.locations.head });
+    }
+  }
+  store.saveResolution(row.id, {
+    drift: r.drift,
+    start: r.region ? r.region.start : null,
+    end: r.region ? r.region.end : null,
+    locations: r.locations
+  });
+  return r;
+}
+function syncAll(repo, store) {
+  const out = /* @__PURE__ */ new Map();
+  store.transaction(() => {
+    for (const row of store.threads()) out.set(row.id, syncThread(repo, store, row));
+  });
+  return out;
+}
+function toThread(store, row, r, opts = {}) {
+  const anchorText = store.getBlob(row.anchor_blob) ?? "";
+  const anchorLines = splitLines(anchorText).slice(row.anchor_start - 1, row.anchor_end);
+  const comments = store.comments(row.id).map((c) => ({
+    id: c.id,
+    threadId: c.thread_id,
+    author: c.author,
+    authorKind: c.author_kind,
+    body: c.body,
+    createdAt: c.created_at,
+    editedAt: c.edited_at
+  }));
+  const events = opts.events ? store.events(row.id).map((e) => ({
+    id: e.id,
+    threadId: e.thread_id,
+    kind: e.kind,
+    detail: JSON.parse(e.detail),
+    at: e.at
+  })) : [];
+  const displayPath = r.renamedTo ?? row.file_path;
+  const ref = r.region ? `${displayPath}:${r.region.start}${r.region.end > r.region.start ? `-${r.region.end}` : ""}` : `${row.file_path}:${row.anchor_start}${row.anchor_end > row.anchor_start ? `-${row.anchor_end}` : ""}`;
+  return {
+    id: row.id,
+    filePath: displayPath,
+    side: row.side,
+    target: row.target,
+    status: row.status,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    resolvedAt: row.resolved_at,
+    resolvedBy: row.resolved_by,
+    anchor: {
+      blob: row.anchor_blob,
+      start: row.anchor_start,
+      end: row.anchor_end,
+      lines: anchorLines,
+      hunkHeader: row.hunk_header
+    },
+    current: {
+      drift: r.drift,
+      region: r.region,
+      locations: r.locations,
+      notes: r.notes,
+      checkedAt: row.checked_at ?? (/* @__PURE__ */ new Date()).toISOString()
+    },
+    ref,
+    comments,
+    events
+  };
+}
+
+// src/format.ts
+var useColor = process.stdout.isTTY === true && process.env.NO_COLOR === void 0 && process.env.TERM !== "dumb";
+var wrap = (code) => (s) => useColor ? `\x1B[${code}m${s}\x1B[0m` : s;
+var dim = wrap("2");
+var bold = wrap("1");
+var red = wrap("31");
+var green = wrap("32");
+var yellow = wrap("33");
+var blue = wrap("34");
+var magenta = wrap("35");
+var cyan = wrap("36");
+var DRIFT_LABEL = {
+  current: "current",
+  moved: "moved",
+  changed: "changed",
+  orphaned: "orphaned"
+};
+function driftBadge(d) {
+  const label = DRIFT_LABEL[d];
+  if (d === "current") return green(label);
+  if (d === "moved") return dim(label);
+  if (d === "changed") return yellow(`! ${label}`);
+  return red(`! ${label}`);
+}
+var TARGET_LABEL = {
+  worktree: "unstaged diff",
+  index: "staged diff",
+  head: "HEAD..worktree diff"
+};
+function targetLabel(t) {
+  return TARGET_LABEL[t];
+}
+function sideLabel(s) {
+  return s === "new" ? "new side" : "old side";
+}
+function placeLabel(t) {
+  return `${targetLabel(t.target)} \xB7 ${sideLabel(t.side)}`;
+}
+function firstLine(body) {
+  const line = body.split("\n")[0] ?? "";
+  return line.length > 72 ? `${line.slice(0, 71)}\u2026` : line;
+}
+function gutter(lines, start, sign, paint) {
+  if (lines.length === 0) return [`      ${dim("(no lines \u2014 region deleted)")}`];
+  const width = String(start + lines.length - 1).length;
+  return lines.map((l, i) => {
+    const n = String(start + i).padStart(width);
+    return `   ${dim(n)} ${dim("\u2502")} ${paint(`${sign}${l}`)}`;
+  });
+}
+function threadLine(t) {
+  const status = t.status === "resolved" ? green("resolved") : bold("open");
+  const head = `${magenta(`#${t.id}`)} ${cyan(t.ref)}`;
+  const meta = [status, driftBadge(t.current.drift), dim(placeLabel(t))].join(" ");
+  const who = t.comments[0]?.author ?? "?";
+  const n = t.comments.length > 1 ? dim(` (+${t.comments.length - 1})`) : "";
+  return `${head}  ${meta}
+    ${dim(`${who}:`)} ${firstLine(t.comments[0]?.body ?? "")}${n}`;
+}
+function eventLine(e) {
+  const at = dim(e.at.replace("T", " ").slice(0, 19));
+  switch (e.kind) {
+    case "drift":
+      return `${at} ${yellow("drift")} ${e.detail.from} \u2192 ${e.detail.to}`;
+    case "staged":
+      return `${at} ${blue("staged")} the commented content entered the index`;
+    case "unstaged":
+      return `${at} ${blue("unstaged")} the commented content left the index`;
+    case "committed":
+      return `${at} ${blue("committed")} the commented content is in HEAD`;
+    case "resolved":
+      return `${at} ${green("resolved")} by ${e.detail.by}`;
+    case "unresolved":
+      return `${at} ${yellow("reopened")} by ${e.detail.by}`;
+    default:
+      return `${at} ${e.kind}`;
+  }
+}
+function threadDetail(t) {
+  const out = [];
+  const status = t.status === "resolved" ? green("resolved") : bold("open");
+  out.push(
+    `${magenta(`#${t.id}`)} ${cyan(t.ref)}  ${status}  ${driftBadge(t.current.drift)}  ${dim(
+      placeLabel(t)
+    )}`
+  );
+  for (const note of t.current.notes) out.push(`   ${yellow("\u2022")} ${note.text}`);
+  if (t.anchor.hunkHeader) out.push(`   ${dim(t.anchor.hunkHeader)}`);
+  out.push("");
+  if (t.current.drift === "current" || t.current.drift === "moved") {
+    const region = t.current.region;
+    const start = region ? region.start : t.anchor.start;
+    const end = region ? region.end : t.anchor.end;
+    out.push(`  ${bold("commented lines")} ${dim(`(lines ${start}-${end})`)}`);
+    out.push(...gutter(region ? region.lines : t.anchor.lines, start, " ", (s) => s));
+  } else {
+    out.push(`  ${bold("when commented")} ${dim(`(lines ${t.anchor.start}-${t.anchor.end})`)}`);
+    out.push(...gutter(t.anchor.lines, t.anchor.start, t.current.drift === "changed" ? "-" : " ", red));
+    out.push("");
+    if (t.current.region) {
+      const r = t.current.region;
+      out.push(`  ${bold("now")} ${dim(`(lines ${r.start}-${r.end})`)}`);
+      out.push(...gutter(r.lines, r.start, t.current.drift === "changed" ? "+" : " ", green));
+    } else {
+      out.push(`  ${bold("now")} ${red("the file is gone")}`);
+    }
+  }
+  out.push("");
+  out.push(`  ${dim("\u2500\u2500 comments \u2500\u2500")}`);
+  for (const c of t.comments) {
+    const kind = c.authorKind === "agent" ? dim(" (agent)") : "";
+    const edited = c.editedAt === null ? "" : dim(" \xB7 edited");
+    const at = dim(c.createdAt.replace("T", " ").slice(0, 19));
+    out.push(`  ${bold(c.author)}${kind} ${at} ${dim(`\xB7 comment #${c.id}`)}${edited}`);
+    for (const line of c.body.split("\n")) out.push(`    ${line}`);
+  }
+  const interesting = t.events.filter((e) => e.kind !== "created");
+  if (interesting.length > 0) {
+    out.push("");
+    out.push(`  ${dim("\u2500\u2500 history \u2500\u2500")}`);
+    for (const e of interesting) out.push(`  ${eventLine(e)}`);
+  }
+  return out.join("\n");
+}
+
+// src/cli.ts
+function packageVersion() {
+  const pkg = JSON.parse(readFileSync2(new URL("../package.json", import.meta.url), "utf8"));
+  if (typeof pkg.version !== "string" || pkg.version === "") {
+    throw new Error("greview package version is missing");
+  }
+  return pkg.version;
+}
+var VERSION = packageVersion();
+var USAGE = `greview ${VERSION} \u2014 review threads anchored to git diffs
+
+Usage: greview <command> [options]
+
+Commands
+  list                     List threads (open ones by default)
+  show <id>                One thread in full, with before/after and history
+  add                      Start a thread on a line range
+  reply <id> -m <text>     Add a comment to a thread
+  edit <comment-id> -m <t> Rewrite one comment (ids shown by "show")
+  resolve <id>             Mark resolved            unresolve <id>   reopen
+  rm <id>                  Delete a thread and its comments
+  sync                     Re-anchor every thread and record what moved
+  stats                    Counts, for status lines and hooks
+  repo                     Repo root, git dir and database path
+  install-skill            Install the greview skill for coding agents
+  onsubmit <sub>           Commands to run when the reviewer presses Submit:
+                             list                    show this worktree's hooks
+                             add <name> <command>     add or replace one
+                             delete <name>            remove one
+                             clear                    remove all
+                             run                      run them all, concurrently
+
+Options
+  --cwd <dir>              Run as if in this directory (default: cwd)
+  --json                   Machine-readable output; every response is
+                           {"ok":true,"data":...} or {"ok":false,"error":"..."}
+
+  list/show
+  --all                    Include resolved threads
+  --resolved               Only resolved threads
+  --file <path>            Restrict to one file
+  --target <t>             Restrict to worktree | index | head
+  --events                 Include the event history in --json output
+  --no-sync                Skip re-anchoring; report the last known positions
+
+  add
+  --file <path>            File to comment on (required)
+  --line <n|n-m>           Line range in the current version (required)
+  --side new|old           Diff side (default: new)
+  --target worktree|index|head
+                           Which diff the comment belongs to (default: worktree)
+  -m, --message <text>     Comment body; use "-" to read stdin
+
+  add/reply/edit/resolve
+  --author <name>          Default: $GREVIEW_AUTHOR, then git config user.name for
+                           a person, or the agent's own name for an agent
+  --agent                  Record the author as an agent rather than a human.
+                           Implied when $AI_AGENT or $CLAUDECODE is set; override
+                           with GREVIEW_AUTHOR_KIND=human. An agent is never
+                           recorded under git config user.name.
+
+Submit hooks are per-worktree and run through the shell with no arguments. They
+are how something outside greview hears that a review is ready; greview does not
+care what they do.
+
+Anchoring: a thread stores the exact text of the lines it was written against.
+Later, "drift" says what became of them \u2014 current, moved, changed or orphaned.
+Nothing is ever auto-resolved; resolving is a human decision.
+`;
+var UsageError = class extends Error {
+};
+var SKILL_INSTALL_ARGS = [
+  "--yes",
+  "skills",
+  "add",
+  "YouXam/greview",
+  "--skill",
+  "greview",
+  "--global",
+  "--yes"
+];
+function fail(message) {
+  throw new UsageError(message);
+}
+function cmdInstallSkill() {
+  const executable = process.platform === "win32" ? "npx.cmd" : "npx";
+  const result = spawnSync2(executable, SKILL_INSTALL_ARGS, { stdio: "inherit" });
+  if (result.error) {
+    process.stderr.write(`greview: could not start npx: ${result.error.message}
+`);
+    return 1;
+  }
+  if (result.signal) {
+    process.stderr.write(`greview: skill installer stopped by ${result.signal}
+`);
+    return 1;
+  }
+  return result.status ?? 1;
+}
+function parse(argv) {
+  return parseArgs({
+    args: argv,
+    allowPositionals: true,
+    strict: true,
+    options: {
+      cwd: { type: "string" },
+      json: { type: "boolean", default: false },
+      all: { type: "boolean", default: false },
+      resolved: { type: "boolean", default: false },
+      file: { type: "string" },
+      line: { type: "string" },
+      side: { type: "string" },
+      target: { type: "string" },
+      message: { type: "string", short: "m" },
+      author: { type: "string" },
+      agent: { type: "boolean", default: false },
+      by: { type: "string" },
+      events: { type: "boolean", default: false },
+      "no-sync": { type: "boolean", default: false },
+      help: { type: "boolean", short: "h", default: false },
+      version: { type: "boolean", short: "v", default: false }
+    }
+  });
+}
+function agentName() {
+  const declared = process.env.AI_AGENT?.trim();
+  if (declared) {
+    const head = declared.split("_")[0]?.trim();
+    if (head) return head;
+  }
+  if (process.env.CLAUDECODE === "1") return "claude-code";
+  return null;
+}
+function looksLikeAgent() {
+  return process.env.AI_AGENT !== void 0 || process.env.CLAUDECODE === "1";
+}
+function authorOf(repo, values) {
+  const declaredKind = process.env.GREVIEW_AUTHOR_KIND;
+  const kind = values.agent || declaredKind === "agent" || declaredKind !== "human" && looksLikeAgent() ? "agent" : "human";
+  const explicit = (values.author ?? process.env.GREVIEW_AUTHOR)?.trim();
+  if (explicit) return { author: explicit, kind };
+  if (kind === "agent") {
+    const inferred = agentName();
+    if (inferred) return { author: inferred, kind };
+    return fail(
+      "an agent must name itself: pass --author <name> (for example claude-code or codex), or set GREVIEW_AUTHOR. git config user.name belongs to the human reviewer and will not be used for an agent comment."
+    );
+  }
+  const r = spawnSync2("git", ["config", "user.name"], { cwd: repo.root, encoding: "utf8" });
+  return { author: (r.stdout ?? "").trim() || "unknown", kind };
+}
+function messageOf(values) {
+  const raw = values.message;
+  if (raw === void 0) fail('a comment body is required: -m "<text>" (or -m - to read stdin)');
+  const body = raw === "-" ? readFileSync2(0, "utf8") : raw;
+  if (body.trim() === "") fail("the comment body is empty");
+  return body.replace(/\s+$/, "");
+}
+function parseSide(v) {
+  if (v === void 0) return "new";
+  if (v === "new" || v === "old") return v;
+  return fail(`--side must be new or old, got ${v}`);
+}
+function parseTarget(v, dflt) {
+  if (v === void 0) {
+    if (dflt === null) return fail("--target is required");
+    return dflt;
+  }
+  if (v === "worktree" || v === "index" || v === "head") return v;
+  return fail(`--target must be worktree, index or head, got ${v}`);
+}
+function parseRange(v) {
+  if (v === void 0) fail("--line <n|n-m> is required");
+  const m = /^(\d+)(?:\s*-\s*(\d+))?$/.exec(v.trim());
+  if (!m) fail(`--line must look like 12 or 12-18, got ${v}`);
+  const start = Number(m[1]);
+  const end = m[2] === void 0 ? start : Number(m[2]);
+  if (start < 1) fail("line numbers start at 1");
+  if (end < start) fail(`--line range is inverted: ${v}`);
+  return { start, end };
+}
+function threadIdOf(positionals) {
+  const raw = positionals[1];
+  if (raw === void 0) fail("a thread id is required");
+  const id = Number(raw.replace(/^#/, ""));
+  if (!Number.isInteger(id) || id < 1) fail(`not a thread id: ${raw}`);
+  return id;
+}
+function loadThread(ctx, id, opts) {
+  const row = ctx.store.thread(id);
+  if (row === null) fail(`no thread #${id}`);
+  const r = opts.sync ? ctx.store.transaction(() => syncThread(ctx.repo, ctx.store, row)) : resolveThread(ctx.repo, ctx.store, row);
+  const fresh = ctx.store.thread(id);
+  return toThread(ctx.store, fresh, r, { events: opts.events });
+}
+function collect(ctx, values) {
+  const sync = values["no-sync"] !== true;
+  const resolutions = sync ? syncAll(ctx.repo, ctx.store) : null;
+  const target = values.target === void 0 ? null : parseTarget(values.target, null);
+  const file = values.file === void 0 ? null : toRepoPath(ctx.repo, values.file, cwdOf(values));
+  const out = [];
+  for (const row of ctx.store.threads()) {
+    if (values.resolved && row.status !== "resolved") continue;
+    if (!values.resolved && !values.all && row.status !== "open") continue;
+    if (target !== null && row.target !== target) continue;
+    if (file !== null && row.file_path !== file) continue;
+    const r = resolutions?.get(row.id) ?? resolveThread(ctx.repo, ctx.store, row);
+    out.push(toThread(ctx.store, row, r, { events: values.events }));
+  }
+  const weight = (t) => t.status === "resolved" ? 4 : t.current.drift === "changed" || t.current.drift === "orphaned" ? 1 : 3;
+  return out.sort((a, b) => weight(a) - weight(b) || a.filePath.localeCompare(b.filePath) || a.id - b.id);
+}
+function cwdOf(values) {
+  return values.cwd ?? process.env.GREVIEW_CWD ?? process.cwd();
+}
+function emit(ctx, json, data, human) {
+  if (json) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data }, null, 2)}
+`);
+  } else {
+    human();
+  }
+  ctx?.store.close();
+}
+function cmdRepo(ctx) {
+  const info = {
+    root: ctx.repo.root,
+    gitDir: ctx.repo.gitDir,
+    dbPath: dbPathFor(ctx.repo),
+    head: headSha(ctx.repo),
+    branch: branchName(ctx.repo)
+  };
+  emit(ctx, ctx.json, info, () => {
+    console.log(`${dim("root  ")} ${info.root}`);
+    console.log(`${dim("gitdir")} ${info.gitDir}`);
+    console.log(`${dim("db    ")} ${info.dbPath}`);
+    console.log(`${dim("branch")} ${info.branch ?? "(detached)"} ${dim(info.head?.slice(0, 12) ?? "")}`);
+  });
+}
+function cmdAdd(ctx, values) {
+  if (values.file === void 0) fail("--file <path> is required");
+  const filePath = toRepoPath(ctx.repo, values.file, cwdOf(values));
+  const side = parseSide(values.side);
+  const target = parseTarget(values.target, "worktree");
+  const { start, end } = parseRange(values.line);
+  const body = messageOf(values);
+  const { author, kind } = authorOf(ctx.repo, values);
+  const version = versionFor(target, side);
+  const content = readVersion(ctx.repo, version, filePath);
+  if (content === null) {
+    fail(`${filePath} does not exist in the ${version} version, so there is nothing to anchor to`);
+  }
+  if (content.includes("\0")) fail(`${filePath} looks binary; only text files can be commented on`);
+  const total = splitLines(content).length;
+  if (total === 0) fail(`${filePath} is empty in the ${version} version`);
+  if (start > total) fail(`${filePath} has ${total} lines in the ${version} version; --line ${start} is past the end`);
+  const clampedEnd = Math.min(end, total);
+  const hunkHeader = hunkHeaderAt(ctx.repo, target, side, filePath, start);
+  const id = ctx.store.transaction(
+    () => ctx.store.createThread({
+      filePath,
+      side,
+      target,
+      content,
+      start,
+      end: clampedEnd,
+      hunkHeader,
+      author,
+      authorKind: kind,
+      body
+    })
+  );
+  const thread = loadThread(ctx, id, { sync: true, events: true });
+  emit(ctx, ctx.json, thread, () => {
+    console.log(`${bold("created")} ${cyan(`#${id}`)} ${thread.ref}`);
+    if (hunkHeader === null) {
+      console.log(
+        yellow("note: those lines are not part of that diff \u2014 the comment is anchored to them anyway")
+      );
+    }
+  });
+}
+function cmdList(ctx, values) {
+  const threads = collect(ctx, values);
+  emit(ctx, ctx.json, threads, () => {
+    if (threads.length === 0) {
+      console.log(dim(values.resolved ? "no resolved threads" : "no open threads"));
+      return;
+    }
+    let file = "";
+    for (const t of threads) {
+      if (t.filePath !== file) {
+        file = t.filePath;
+        console.log(`
+${bold(file)}`);
+      }
+      console.log(threadLine(t));
+      for (const note of t.current.notes) console.log(`    ${yellow("\u2022")} ${note.text}`);
+    }
+    console.log("");
+  });
+}
+function cmdShow(ctx, values, positionals) {
+  const thread = loadThread(ctx, threadIdOf(positionals), {
+    sync: values["no-sync"] !== true,
+    events: true
+  });
+  emit(ctx, ctx.json, thread, () => console.log(threadDetail(thread)));
+}
+function cmdReply(ctx, values, positionals) {
+  const id = threadIdOf(positionals);
+  if (ctx.store.thread(id) === null) fail(`no thread #${id}`);
+  const body = messageOf(values);
+  const { author, kind } = authorOf(ctx.repo, values);
+  ctx.store.addComment(id, author, kind, body);
+  const thread = loadThread(ctx, id, { sync: true, events: true });
+  emit(ctx, ctx.json, thread, () => console.log(`${bold("replied to")} ${cyan(`#${id}`)}`));
+}
+function cmdEdit(ctx, values, positionals) {
+  const raw = positionals[1];
+  if (raw === void 0) fail("a comment id is required (see comments[].id in `show --json`)");
+  const commentId = Number(raw.replace(/^#/, ""));
+  if (!Number.isInteger(commentId) || commentId < 1) fail(`not a comment id: ${raw}`);
+  const body = messageOf(values);
+  const threadId = ctx.store.editComment(commentId, body);
+  if (threadId === null) fail(`no comment #${commentId}`);
+  const thread = loadThread(ctx, threadId, { sync: true, events: true });
+  emit(
+    ctx,
+    ctx.json,
+    thread,
+    () => console.log(`${bold("edited")} comment ${cyan(`#${commentId}`)} ${dim(`in thread #${threadId}`)}`)
+  );
+}
+function cmdSetStatus(ctx, values, positionals, resolved) {
+  const id = threadIdOf(positionals);
+  if (ctx.store.thread(id) === null) fail(`no thread #${id}`);
+  const by = values.by ?? authorOf(ctx.repo, values).author;
+  ctx.store.setStatus(id, resolved ? "resolved" : "open", by);
+  const thread = loadThread(ctx, id, { sync: false, events: true });
+  emit(
+    ctx,
+    ctx.json,
+    thread,
+    () => console.log(`${bold(resolved ? "resolved" : "reopened")} ${cyan(`#${id}`)} ${dim(`by ${by}`)}`)
+  );
+}
+function cmdRm(ctx, positionals) {
+  const id = threadIdOf(positionals);
+  if (!ctx.store.deleteThread(id)) fail(`no thread #${id}`);
+  emit(ctx, ctx.json, { id, deleted: true }, () => console.log(`${bold("deleted")} ${cyan(`#${id}`)}`));
+}
+function cmdSync(ctx) {
+  const before = new Map(ctx.store.threads().map((r) => [r.id, r.drift]));
+  const resolutions = syncAll(ctx.repo, ctx.store);
+  const changed = [];
+  for (const [id, r] of resolutions) {
+    const from = before.get(id) ?? null;
+    if (from !== r.drift) changed.push({ id, from, to: r.drift });
+  }
+  emit(ctx, ctx.json, { checked: resolutions.size, changed }, () => {
+    console.log(`${bold("checked")} ${resolutions.size} thread(s)`);
+    for (const c of changed) console.log(`  ${cyan(`#${c.id}`)} ${c.from ?? "new"} \u2192 ${c.to}`);
+  });
+}
+var CALLBACK_TIMEOUT_MS = 6e4;
+function toCallback(row) {
+  return { name: row.name, command: row.command, createdAt: row.created_at };
+}
+function runCallback(cwd, callback) {
+  return new Promise((resolve2) => {
+    const started = Date.now();
+    const child = spawn(callback.command, {
+      cwd,
+      shell: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, CALLBACK_TIMEOUT_MS);
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      resolve2({
+        ...callback,
+        code: null,
+        signal: null,
+        timedOut,
+        stdout,
+        stderr: stderr || e.message,
+        durationMs: Date.now() - started
+      });
+    });
+    child.on("close", (code, signal) => {
+      clearTimeout(timer);
+      resolve2({
+        ...callback,
+        code,
+        signal: signal ?? null,
+        timedOut,
+        stdout: stdout.trimEnd(),
+        stderr: stderr.trimEnd(),
+        durationMs: Date.now() - started
+      });
+    });
+  });
+}
+function cmdOnsubmit(ctx, values, positionals) {
+  const sub = positionals[1] ?? "list";
+  switch (sub) {
+    case "list": {
+      const list = ctx.store.callbacks().map(toCallback);
+      return emit(ctx, ctx.json, list, () => {
+        if (list.length === 0) {
+          console.log(dim("no submit hooks in this worktree"));
+          return;
+        }
+        for (const c of list) console.log(`${cyan(c.name)}  ${c.command}`);
+      });
+    }
+    case "add": {
+      const name = positionals[2];
+      const command = positionals[3];
+      if (name === void 0 || name.trim() === "") fail("a hook name is required");
+      if (command === void 0 || command.trim() === "") {
+        fail('a command is required: greview onsubmit add <name> "<command>"');
+      }
+      ctx.store.putCallback(name, command);
+      const list = ctx.store.callbacks().map(toCallback);
+      return emit(ctx, ctx.json, list, () => console.log(`${bold("added")} hook ${cyan(name)}`));
+    }
+    case "delete":
+    case "rm": {
+      const name = positionals[2];
+      if (name === void 0) fail("which hook? greview onsubmit delete <name>");
+      if (!ctx.store.deleteCallback(name)) fail(`no hook named ${name}`);
+      const list = ctx.store.callbacks().map(toCallback);
+      return emit(ctx, ctx.json, list, () => console.log(`${bold("deleted")} hook ${cyan(name)}`));
+    }
+    case "clear": {
+      const removed = ctx.store.clearCallbacks();
+      return emit(
+        ctx,
+        ctx.json,
+        { removed },
+        () => console.log(`${bold("cleared")} ${removed} hook(s)`)
+      );
+    }
+    case "run": {
+      const list = ctx.store.callbacks().map(toCallback);
+      const root = ctx.repo.root;
+      const json = ctx.json;
+      return Promise.all(list.map((c) => runCallback(root, c))).then((results) => {
+        const failed = results.filter((r) => r.code !== 0);
+        if (json) {
+          process.stdout.write(`${JSON.stringify({ ok: true, data: results }, null, 2)}
+`);
+        } else if (results.length === 0) {
+          console.log(dim("no submit hooks in this worktree"));
+        } else {
+          for (const r of results) {
+            const status = r.timedOut ? yellow("timed out") : r.code === 0 ? bold("ok") : `${yellow("exit")} ${r.code ?? r.signal}`;
+            console.log(`${cyan(r.name)} ${status} ${dim(`${r.durationMs}ms`)}`);
+            for (const line of [...r.stdout.split("\n"), ...r.stderr.split("\n")]) {
+              if (line.trim() !== "") console.log(`  ${dim(line)}`);
+            }
+          }
+        }
+        if (failed.length > 0) process.exitCode = 1;
+      });
+    }
+    default:
+      return fail(`unknown onsubmit subcommand "${sub}" (list, add, delete, clear, run)`);
+  }
+}
+function cmdStats(ctx) {
+  const resolutions = syncAll(ctx.repo, ctx.store);
+  const stats = { open: 0, resolved: 0, changed: 0, orphaned: 0 };
+  for (const row of ctx.store.threads()) {
+    if (row.status === "resolved") {
+      stats.resolved++;
+      continue;
+    }
+    stats.open++;
+    const drift = resolutions.get(row.id)?.drift ?? row.drift;
+    if (drift === "changed") stats.changed++;
+    if (drift === "orphaned") stats.orphaned++;
+  }
+  emit(
+    ctx,
+    ctx.json,
+    stats,
+    () => console.log(
+      `${stats.open} open, ${stats.resolved} resolved, ${stats.changed} changed under you, ${stats.orphaned} orphaned`
+    )
+  );
+}
+function main(argv) {
+  let values;
+  let positionals;
+  try {
+    ({ values, positionals } = parse(argv));
+  } catch (e) {
+    process.stderr.write(`greview: ${e.message}
+`);
+    return 2;
+  }
+  const command = positionals[0] ?? (values.version ? "version" : "help");
+  if (values.help || command === "help") {
+    process.stdout.write(USAGE);
+    return 0;
+  }
+  if (command === "version") {
+    process.stdout.write(`${VERSION}
+`);
+    return 0;
+  }
+  if (command === "install-skill") return cmdInstallSkill();
+  let ctx = null;
+  try {
+    const repo = findRepo(cwdOf(values));
+    ctx = { repo, store: new Store(repo), json: values.json === true };
+    switch (command) {
+      case "repo":
+        cmdRepo(ctx);
+        break;
+      case "add":
+        cmdAdd(ctx, values);
+        break;
+      case "list":
+      case "ls":
+        cmdList(ctx, values);
+        break;
+      case "show":
+        cmdShow(ctx, values, positionals);
+        break;
+      case "reply":
+        cmdReply(ctx, values, positionals);
+        break;
+      case "edit":
+        cmdEdit(ctx, values, positionals);
+        break;
+      case "resolve":
+        cmdSetStatus(ctx, values, positionals, true);
+        break;
+      case "unresolve":
+      case "reopen":
+        cmdSetStatus(ctx, values, positionals, false);
+        break;
+      case "rm":
+      case "delete":
+        cmdRm(ctx, positionals);
+        break;
+      case "sync":
+        cmdSync(ctx);
+        break;
+      case "stats":
+        cmdStats(ctx);
+        break;
+      case "onsubmit": {
+        const pending = cmdOnsubmit(ctx, values, positionals);
+        if (pending) return pending.then(() => 0);
+        break;
+      }
+      default:
+        process.stderr.write(`greview: unknown command "${command}"
+Try: greview help
+`);
+        return 2;
+    }
+    return 0;
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    if (values.json) {
+      process.stdout.write(`${JSON.stringify({ ok: false, error: message })}
+`);
+    } else {
+      process.stderr.write(`greview: ${message}
+`);
+    }
+    return e instanceof UsageError ? 2 : e instanceof GitError ? 3 : 1;
+  } finally {
+    try {
+      ctx?.store.close();
+    } catch {
+    }
+  }
+}
+var outcome = main(process.argv.slice(2));
+if (typeof outcome === "number") {
+  process.exitCode = outcome;
+} else {
+  void outcome.then(
+    (code) => {
+      if (process.exitCode === void 0 || process.exitCode === 0) process.exitCode = code;
+    },
+    (e) => {
+      process.stderr.write(`greview: ${e instanceof Error ? e.message : String(e)}
+`);
+      process.exitCode = 1;
+    }
+  );
+}