glassbox 0.1.0

package/dist/cli.js

@@ -0,0 +1,3689 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import { Hono as Hono3 } from "hono";
+import { serve } from "@hono/node-server";
+import { exec } from "child_process";
+
+// src/routes/api.ts
+import { Hono } from "hono";
+
+// src/db/connection.ts
+import { PGlite } from "@electric-sql/pglite";
+import { join } from "path";
+import { homedir } from "os";
+import { mkdirSync } from "fs";
+var dataDir = join(homedir(), ".glassbox", "data");
+mkdirSync(dataDir, { recursive: true });
+var db = null;
+async function getDb() {
+  if (db) return db;
+  db = new PGlite(join(dataDir, "reviews"));
+  await db.waitReady;
+  await initSchema(db);
+  return db;
+}
+async function initSchema(db2) {
+  await db2.exec(`
+    CREATE TABLE IF NOT EXISTS reviews (
+      id TEXT PRIMARY KEY,
+      repo_path TEXT NOT NULL,
+      repo_name TEXT NOT NULL,
+      mode TEXT NOT NULL,
+      mode_args TEXT,
+      head_commit TEXT,
+      status TEXT NOT NULL DEFAULT 'in_progress',
+      created_at TIMESTAMP NOT NULL DEFAULT NOW(),
+      updated_at TIMESTAMP NOT NULL DEFAULT NOW()
+    );
+
+    CREATE TABLE IF NOT EXISTS review_files (
+      id TEXT PRIMARY KEY,
+      review_id TEXT NOT NULL REFERENCES reviews(id) ON DELETE CASCADE,
+      file_path TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending',
+      diff_data TEXT,
+      created_at TIMESTAMP NOT NULL DEFAULT NOW()
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_review_files_review ON review_files(review_id);
+
+    CREATE TABLE IF NOT EXISTS annotations (
+      id TEXT PRIMARY KEY,
+      review_file_id TEXT NOT NULL REFERENCES review_files(id) ON DELETE CASCADE,
+      line_number INTEGER NOT NULL,
+      side TEXT NOT NULL DEFAULT 'new',
+      category TEXT NOT NULL DEFAULT 'note',
+      content TEXT NOT NULL,
+      is_stale BOOLEAN NOT NULL DEFAULT FALSE,
+      original_content TEXT,
+      created_at TIMESTAMP NOT NULL DEFAULT NOW(),
+      updated_at TIMESTAMP NOT NULL DEFAULT NOW()
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_annotations_file ON annotations(review_file_id);
+  `);
+  try {
+    await db2.exec("ALTER TABLE reviews ADD COLUMN head_commit TEXT");
+  } catch {
+  }
+  try {
+    await db2.exec("ALTER TABLE annotations ADD COLUMN is_stale BOOLEAN NOT NULL DEFAULT FALSE");
+  } catch {
+  }
+  try {
+    await db2.exec("ALTER TABLE annotations ADD COLUMN original_content TEXT");
+  } catch {
+  }
+}
+
+// src/db/queries.ts
+function generateId() {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 10);
+}
+async function createReview(repoPath, repoName, mode, modeArgs, headCommit) {
+  const db2 = await getDb();
+  const id = generateId();
+  const result = await db2.query(
+    `INSERT INTO reviews (id, repo_path, repo_name, mode, mode_args, head_commit)
+     VALUES ($1, $2, $3, $4, $5, $6) RETURNING *`,
+    [id, repoPath, repoName, mode, modeArgs ?? null, headCommit ?? null]
+  );
+  return result.rows[0];
+}
+async function getReview(id) {
+  const db2 = await getDb();
+  const result = await db2.query("SELECT * FROM reviews WHERE id = $1", [id]);
+  return result.rows[0];
+}
+async function listReviews(repoPath) {
+  const db2 = await getDb();
+  if (repoPath) {
+    const result2 = await db2.query(
+      "SELECT * FROM reviews WHERE repo_path = $1 ORDER BY created_at DESC",
+      [repoPath]
+    );
+    return result2.rows;
+  }
+  const result = await db2.query("SELECT * FROM reviews ORDER BY created_at DESC");
+  return result.rows;
+}
+async function updateReviewStatus(id, status) {
+  const db2 = await getDb();
+  await db2.query("UPDATE reviews SET status = $1, updated_at = NOW() WHERE id = $2", [status, id]);
+}
+async function updateReviewHead(id, headCommit) {
+  const db2 = await getDb();
+  await db2.query("UPDATE reviews SET head_commit = $1, updated_at = NOW() WHERE id = $2", [headCommit, id]);
+}
+async function deleteReview(id) {
+  const db2 = await getDb();
+  await db2.query("DELETE FROM annotations WHERE review_file_id IN (SELECT id FROM review_files WHERE review_id = $1)", [id]);
+  await db2.query("DELETE FROM review_files WHERE review_id = $1", [id]);
+  await db2.query("DELETE FROM reviews WHERE id = $1", [id]);
+}
+async function getLatestInProgressReview(repoPath, mode, modeArgs) {
+  const db2 = await getDb();
+  const result = await db2.query(
+    `SELECT * FROM reviews
+     WHERE repo_path = $1 AND mode = $2 AND status = 'in_progress'
+     AND ($3::text IS NULL OR mode_args = $3)
+     ORDER BY created_at DESC LIMIT 1`,
+    [repoPath, mode, modeArgs ?? null]
+  );
+  return result.rows[0];
+}
+async function addReviewFile(reviewId, filePath, diffData) {
+  const db2 = await getDb();
+  const id = generateId();
+  const result = await db2.query(
+    `INSERT INTO review_files (id, review_id, file_path, diff_data)
+     VALUES ($1, $2, $3, $4) RETURNING *`,
+    [id, reviewId, filePath, diffData]
+  );
+  return result.rows[0];
+}
+async function getReviewFiles(reviewId) {
+  const db2 = await getDb();
+  const result = await db2.query(
+    "SELECT * FROM review_files WHERE review_id = $1 ORDER BY file_path",
+    [reviewId]
+  );
+  return result.rows;
+}
+async function getReviewFile(id) {
+  const db2 = await getDb();
+  const result = await db2.query("SELECT * FROM review_files WHERE id = $1", [id]);
+  return result.rows[0];
+}
+async function updateFileStatus(id, status) {
+  const db2 = await getDb();
+  await db2.query("UPDATE review_files SET status = $1 WHERE id = $2", [status, id]);
+}
+async function updateFileDiff(id, diffData) {
+  const db2 = await getDb();
+  await db2.query("UPDATE review_files SET diff_data = $1 WHERE id = $2", [diffData, id]);
+}
+async function deleteReviewFile(id) {
+  const db2 = await getDb();
+  await db2.query("DELETE FROM annotations WHERE review_file_id = $1", [id]);
+  await db2.query("DELETE FROM review_files WHERE id = $1", [id]);
+}
+async function addAnnotation(reviewFileId, lineNumber, side, category, content) {
+  const db2 = await getDb();
+  const id = generateId();
+  const result = await db2.query(
+    `INSERT INTO annotations (id, review_file_id, line_number, side, category, content)
+     VALUES ($1, $2, $3, $4, $5, $6) RETURNING *`,
+    [id, reviewFileId, lineNumber, side, category, content]
+  );
+  return result.rows[0];
+}
+async function getAnnotationsForFile(reviewFileId) {
+  const db2 = await getDb();
+  const result = await db2.query(
+    "SELECT * FROM annotations WHERE review_file_id = $1 ORDER BY line_number, created_at",
+    [reviewFileId]
+  );
+  return result.rows;
+}
+async function getAnnotationsForReview(reviewId) {
+  const db2 = await getDb();
+  const result = await db2.query(
+    `SELECT a.*, rf.file_path FROM annotations a
+     JOIN review_files rf ON a.review_file_id = rf.id
+     WHERE rf.review_id = $1
+     ORDER BY rf.file_path, a.line_number, a.created_at`,
+    [reviewId]
+  );
+  return result.rows;
+}
+async function updateAnnotation(id, content, category) {
+  const db2 = await getDb();
+  await db2.query(
+    "UPDATE annotations SET content = $1, category = $2, updated_at = NOW() WHERE id = $3",
+    [content, category, id]
+  );
+}
+async function deleteAnnotation(id) {
+  const db2 = await getDb();
+  await db2.query("DELETE FROM annotations WHERE id = $1", [id]);
+}
+async function moveAnnotation(id, lineNumber, side) {
+  const db2 = await getDb();
+  await db2.query(
+    "UPDATE annotations SET line_number = $1, side = $2, is_stale = FALSE, original_content = NULL, updated_at = NOW() WHERE id = $3",
+    [lineNumber, side, id]
+  );
+}
+async function markAnnotationStale(id, originalContent) {
+  const db2 = await getDb();
+  await db2.query(
+    "UPDATE annotations SET is_stale = TRUE, original_content = $1, updated_at = NOW() WHERE id = $2",
+    [originalContent, id]
+  );
+}
+async function markAnnotationCurrent(id) {
+  const db2 = await getDb();
+  await db2.query(
+    "UPDATE annotations SET is_stale = FALSE, original_content = NULL, updated_at = NOW() WHERE id = $1",
+    [id]
+  );
+}
+async function deleteStaleAnnotations(reviewId) {
+  const db2 = await getDb();
+  await db2.query(
+    `DELETE FROM annotations WHERE is_stale = TRUE AND review_file_id IN
+     (SELECT id FROM review_files WHERE review_id = $1)`,
+    [reviewId]
+  );
+}
+async function keepAllStaleAnnotations(reviewId) {
+  const db2 = await getDb();
+  await db2.query(
+    `UPDATE annotations SET is_stale = FALSE, original_content = NULL, updated_at = NOW()
+     WHERE is_stale = TRUE AND review_file_id IN
+     (SELECT id FROM review_files WHERE review_id = $1)`,
+    [reviewId]
+  );
+}
+async function getStaleCountsForReview(reviewId) {
+  const db2 = await getDb();
+  const result = await db2.query(
+    `SELECT a.review_file_id, COUNT(*)::text as count FROM annotations a
+     JOIN review_files rf ON a.review_file_id = rf.id
+     WHERE rf.review_id = $1 AND a.is_stale = TRUE
+     GROUP BY a.review_file_id`,
+    [reviewId]
+  );
+  const counts = {};
+  for (const row of result.rows) {
+    counts[row.review_file_id] = parseInt(row.count, 10);
+  }
+  return counts;
+}
+
+// src/export/generate.ts
+import { mkdirSync as mkdirSync2, writeFileSync, readFileSync, unlinkSync, existsSync, appendFileSync } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import { execSync } from "child_process";
+var DISMISS_FILE = join2(homedir2(), ".glassbox", "gitignore-dismissed.json");
+var DISMISS_DAYS = 30;
+function loadDismissals() {
+  try {
+    return JSON.parse(readFileSync(DISMISS_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveDismissals(data) {
+  const dir = join2(homedir2(), ".glassbox");
+  mkdirSync2(dir, { recursive: true });
+  writeFileSync(DISMISS_FILE, JSON.stringify(data), "utf-8");
+}
+function isGlassboxGitignored(repoRoot) {
+  try {
+    execSync("git check-ignore -q .glassbox", { cwd: repoRoot, stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function shouldPromptGitignore(repoRoot) {
+  if (isGlassboxGitignored(repoRoot)) return false;
+  const dismissals = loadDismissals();
+  const dismissed = dismissals[repoRoot];
+  if (dismissed) {
+    const daysSince = (Date.now() - dismissed) / (1e3 * 60 * 60 * 24);
+    if (daysSince < DISMISS_DAYS) return false;
+  }
+  return true;
+}
+function addGlassboxToGitignore(repoRoot) {
+  const gitignorePath = join2(repoRoot, ".gitignore");
+  if (existsSync(gitignorePath)) {
+    const content = readFileSync(gitignorePath, "utf-8");
+    if (!content.endsWith("\n")) {
+      appendFileSync(gitignorePath, "\n.glassbox/\n", "utf-8");
+    } else {
+      appendFileSync(gitignorePath, ".glassbox/\n", "utf-8");
+    }
+  } else {
+    writeFileSync(gitignorePath, ".glassbox/\n", "utf-8");
+  }
+}
+function dismissGitignorePrompt(repoRoot) {
+  const dismissals = loadDismissals();
+  dismissals[repoRoot] = Date.now();
+  saveDismissals(dismissals);
+}
+function deleteReviewExport(reviewId, repoRoot) {
+  const exportDir = join2(repoRoot, ".glassbox");
+  const archivePath = join2(exportDir, `review-${reviewId}.md`);
+  if (existsSync(archivePath)) unlinkSync(archivePath);
+}
+async function generateReviewExport(reviewId, repoRoot, isCurrent) {
+  const review = await getReview(reviewId);
+  if (!review) throw new Error("Review not found");
+  const files = await getReviewFiles(reviewId);
+  const annotations = await getAnnotationsForReview(reviewId);
+  const exportDir = join2(repoRoot, ".glassbox");
+  mkdirSync2(exportDir, { recursive: true });
+  const byFile = {};
+  for (const a of annotations) {
+    if (!byFile[a.file_path]) byFile[a.file_path] = [];
+    byFile[a.file_path].push(a);
+  }
+  const lines = [];
+  lines.push("# Code Review");
+  lines.push("");
+  lines.push(`- **Repository**: ${review.repo_name}`);
+  lines.push(`- **Review mode**: ${review.mode}${review.mode_args ? ` (${review.mode_args})` : ""}`);
+  lines.push(`- **Review ID**: ${review.id}`);
+  lines.push(`- **Date**: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push(`- **Files reviewed**: ${files.filter((f) => f.status === "reviewed").length}/${files.length}`);
+  lines.push(`- **Total annotations**: ${annotations.length}`);
+  lines.push("");
+  const categoryCounts = {};
+  for (const a of annotations) {
+    categoryCounts[a.category] = (categoryCounts[a.category] || 0) + 1;
+  }
+  if (Object.keys(categoryCounts).length > 0) {
+    lines.push("## Annotation Summary");
+    lines.push("");
+    for (const [cat, count] of Object.entries(categoryCounts).sort((a, b) => b[1] - a[1])) {
+      lines.push(`- **${cat}**: ${count}`);
+    }
+    lines.push("");
+  }
+  const rememberItems = annotations.filter((a) => a.category === "remember");
+  if (rememberItems.length > 0) {
+    lines.push("## Items to Remember");
+    lines.push("");
+    lines.push("> These annotations are flagged for long-term retention. AI tools should consider updating");
+    lines.push("> project configuration (CLAUDE.md, .cursorrules, etc.) with these preferences/rules.");
+    lines.push("");
+    for (const item of rememberItems) {
+      lines.push(`- **${item.file_path}:${item.line_number}** - ${item.content}`);
+    }
+    lines.push("");
+  }
+  lines.push("## File Annotations");
+  lines.push("");
+  for (const filePath of Object.keys(byFile).sort()) {
+    const fileAnns = byFile[filePath];
+    lines.push(`### ${filePath}`);
+    lines.push("");
+    for (const a of fileAnns) {
+      lines.push(`- **Line ${a.line_number}** [${a.category}]: ${a.content}`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("## Instructions for AI Tools");
+  lines.push("");
+  lines.push("When processing this code review:");
+  lines.push("");
+  lines.push("1. **bug** and **fix** annotations indicate code that needs to be changed. Apply the suggested fixes.");
+  lines.push("2. **style** annotations indicate stylistic preferences. Apply them to the indicated lines and similar patterns nearby.");
+  lines.push("3. **pattern-follow** annotations highlight good patterns. Continue using these patterns in new code.");
+  lines.push("4. **pattern-avoid** annotations highlight anti-patterns. Refactor the indicated code and avoid the pattern elsewhere.");
+  lines.push("5. **remember** annotations are rules/preferences to persist. Update the project's AI configuration file (e.g., CLAUDE.md) with these.");
+  lines.push("6. **note** annotations are informational context. Consider them but they may not require code changes.");
+  lines.push("");
+  const content = lines.join("\n");
+  const archivePath = join2(exportDir, `review-${review.id}.md`);
+  writeFileSync(archivePath, content, "utf-8");
+  if (isCurrent) {
+    const latestPath = join2(exportDir, "latest-review.md");
+    writeFileSync(latestPath, content, "utf-8");
+    return latestPath;
+  }
+  return archivePath;
+}
+
+// src/git/diff.ts
+import { execSync as execSync2 } from "child_process";
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve } from "path";
+function git(args, cwd) {
+  try {
+    return execSync2(`git ${args}`, { cwd, encoding: "utf-8", maxBuffer: 50 * 1024 * 1024 });
+  } catch (e) {
+    const err = e;
+    if (err.stdout) return err.stdout;
+    throw e;
+  }
+}
+function getRepoRoot(cwd) {
+  return git("rev-parse --show-toplevel", cwd).trim();
+}
+function getRepoName(cwd) {
+  const root = getRepoRoot(cwd);
+  return root.split("/").pop() || "unknown";
+}
+function isGitRepo(cwd) {
+  try {
+    git("rev-parse --is-inside-work-tree", cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getDiffArgs(mode) {
+  switch (mode.type) {
+    case "uncommitted":
+      return "diff HEAD";
+    case "staged":
+      return "diff --cached";
+    case "unstaged":
+      return "diff";
+    case "commit":
+      return `diff ${mode.sha}~1 ${mode.sha}`;
+    case "range":
+      return `diff ${mode.from} ${mode.to}`;
+    case "branch": {
+      return `diff ${mode.name}...HEAD`;
+    }
+    case "files":
+      return `diff HEAD -- ${mode.patterns.join(" ")}`;
+    case "all":
+      return "diff --no-index /dev/null .";
+  }
+}
+function getFileDiffs(mode, cwd) {
+  const repoRoot = getRepoRoot(cwd);
+  if (mode.type === "all") {
+    return getAllFiles(repoRoot);
+  }
+  const diffArgs = getDiffArgs(mode);
+  let rawDiff;
+  try {
+    rawDiff = git(`${diffArgs} -U3`, repoRoot);
+  } catch {
+    rawDiff = "";
+  }
+  const diffs = parseDiff(rawDiff);
+  if (mode.type === "uncommitted") {
+    const untracked = git("ls-files --others --exclude-standard", repoRoot).trim();
+    if (untracked) {
+      for (const file of untracked.split("\n").filter(Boolean)) {
+        if (!diffs.some((d) => d.filePath === file)) {
+          diffs.push(createNewFileDiff(file, repoRoot));
+        }
+      }
+    }
+  }
+  return diffs;
+}
+function getAllFiles(repoRoot) {
+  const files = git("ls-files", repoRoot).trim().split("\n").filter(Boolean);
+  return files.map((file) => createNewFileDiff(file, repoRoot));
+}
+function createNewFileDiff(filePath, repoRoot) {
+  let content;
+  try {
+    const buf = readFileSync2(resolve(repoRoot, filePath));
+    const checkLen = Math.min(buf.length, 8192);
+    for (let i = 0; i < checkLen; i++) {
+      if (buf[i] === 0) {
+        return { filePath, oldPath: null, status: "added", hunks: [], isBinary: true };
+      }
+    }
+    content = buf.toString("utf-8");
+  } catch {
+    content = "";
+  }
+  const lines = content.split("\n");
+  const diffLines = lines.map((line, i) => ({
+    type: "add",
+    oldNum: null,
+    newNum: i + 1,
+    content: line
+  }));
+  return {
+    filePath,
+    oldPath: null,
+    status: "added",
+    hunks: diffLines.length ? [{
+      oldStart: 0,
+      oldCount: 0,
+      newStart: 1,
+      newCount: lines.length,
+      lines: diffLines
+    }] : [],
+    isBinary: false
+  };
+}
+function parseDiff(raw2) {
+  const files = [];
+  const fileChunks = raw2.split(/^diff --git /m).filter(Boolean);
+  for (const chunk of fileChunks) {
+    const headerEnd = chunk.indexOf("@@");
+    const header = headerEnd === -1 ? chunk : chunk.slice(0, headerEnd);
+    if (headerEnd === -1 && !header.includes("Binary")) {
+      const pathMatch2 = chunk.match(/^a\/(.+?) b\/(.+)/m);
+      if (pathMatch2) {
+        const isBinary2 = header.includes("Binary");
+        files.push({
+          filePath: pathMatch2[2],
+          oldPath: pathMatch2[1] !== pathMatch2[2] ? pathMatch2[1] : null,
+          status: header.includes("new file") ? "added" : header.includes("deleted file") ? "deleted" : "modified",
+          hunks: [],
+          isBinary: isBinary2
+        });
+      }
+      continue;
+    }
+    const pathMatch = chunk.match(/^a\/(.+?) b\/(.+)/m);
+    if (!pathMatch) continue;
+    const filePath = pathMatch[2];
+    const oldPath = pathMatch[1] !== pathMatch[2] ? pathMatch[1] : null;
+    let status = "modified";
+    if (header.includes("new file mode")) status = "added";
+    else if (header.includes("deleted file mode")) status = "deleted";
+    else if (oldPath) status = "renamed";
+    const isBinary = header.includes("Binary file");
+    if (isBinary) {
+      files.push({ filePath, oldPath, status, hunks: [], isBinary: true });
+      continue;
+    }
+    const hunks = parseHunks(chunk.slice(headerEnd));
+    files.push({ filePath, oldPath, status, hunks, isBinary: false });
+  }
+  return files;
+}
+function parseHunks(raw2) {
+  const hunks = [];
+  const hunkRegex = /^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@(.*)/gm;
+  let match;
+  const hunkStarts = [];
+  while ((match = hunkRegex.exec(raw2)) !== null) {
+    hunkStarts.push({
+      index: match.index + match[0].length,
+      oldStart: parseInt(match[1], 10),
+      oldCount: match[2] != null ? parseInt(match[2], 10) : 1,
+      newStart: parseInt(match[3], 10),
+      newCount: match[4] != null ? parseInt(match[4], 10) : 1
+    });
+  }
+  for (let i = 0; i < hunkStarts.length; i++) {
+    const start = hunkStarts[i];
+    const end = i + 1 < hunkStarts.length ? raw2.lastIndexOf("\n@@", hunkStarts[i + 1].index) : raw2.length;
+    const body = raw2.slice(start.index, end);
+    const lines = [];
+    let oldNum = start.oldStart;
+    let newNum = start.newStart;
+    for (const line of body.split("\n")) {
+      if (line === "") continue;
+      if (line.startsWith("+")) {
+        lines.push({ type: "add", oldNum: null, newNum, content: line.slice(1) });
+        newNum++;
+      } else if (line.startsWith("-")) {
+        lines.push({ type: "remove", oldNum, newNum: null, content: line.slice(1) });
+        oldNum++;
+      } else if (line.startsWith(" ") || line.startsWith("\\")) {
+        if (line.startsWith("\\")) continue;
+        lines.push({ type: "context", oldNum, newNum, content: line.slice(1) });
+        oldNum++;
+        newNum++;
+      }
+    }
+    hunks.push({
+      oldStart: start.oldStart,
+      oldCount: start.oldCount,
+      newStart: start.newStart,
+      newCount: start.newCount,
+      lines
+    });
+  }
+  return hunks;
+}
+function getFileContent(filePath, ref, cwd) {
+  const repoRoot = getRepoRoot(cwd);
+  try {
+    if (ref === "working") {
+      return execSync2(`cat "${resolve(repoRoot, filePath)}"`, { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
+    }
+    return git(`show ${ref}:${filePath}`, repoRoot);
+  } catch {
+    return "";
+  }
+}
+function getHeadCommit(cwd) {
+  return execSync2("git rev-parse HEAD", { cwd, encoding: "utf-8" }).trim();
+}
+function getModeString(mode) {
+  switch (mode.type) {
+    case "uncommitted":
+      return "uncommitted";
+    case "staged":
+      return "staged";
+    case "unstaged":
+      return "unstaged";
+    case "commit":
+      return `commit:${mode.sha}`;
+    case "range":
+      return `range:${mode.from}..${mode.to}`;
+    case "branch":
+      return `branch:${mode.name}`;
+    case "files":
+      return `files:${mode.patterns.join(",")}`;
+    case "all":
+      return "all";
+  }
+}
+function getModeArgs(mode) {
+  switch (mode.type) {
+    case "commit":
+      return mode.sha;
+    case "range":
+      return `${mode.from}..${mode.to}`;
+    case "branch":
+      return mode.name;
+    case "files":
+      return mode.patterns.join(",");
+    default:
+      return void 0;
+  }
+}
+
+// src/routes/api.ts
+var apiRoutes = new Hono();
+function resolveReviewId(c) {
+  return c.req.query("reviewId") || c.get("reviewId");
+}
+apiRoutes.get("/reviews", async (c) => {
+  const repoRoot = c.get("repoRoot");
+  const reviews = await listReviews(repoRoot);
+  return c.json(reviews);
+});
+apiRoutes.get("/review", async (c) => {
+  const reviewId = resolveReviewId(c);
+  const review = await getReview(reviewId);
+  return c.json(review);
+});
+apiRoutes.post("/review/complete", async (c) => {
+  const reviewId = resolveReviewId(c);
+  const currentReviewId = c.get("currentReviewId");
+  const repoRoot = c.get("repoRoot");
+  await updateReviewStatus(reviewId, "completed");
+  const isCurrent = reviewId === currentReviewId;
+  const exportPath = await generateReviewExport(reviewId, repoRoot, isCurrent);
+  const gitignorePrompt = shouldPromptGitignore(repoRoot);
+  return c.json({ status: "completed", exportPath, isCurrent, reviewId, gitignorePrompt });
+});
+apiRoutes.post("/gitignore/add", async (c) => {
+  const repoRoot = c.get("repoRoot");
+  addGlassboxToGitignore(repoRoot);
+  return c.json({ ok: true });
+});
+apiRoutes.post("/gitignore/dismiss", async (c) => {
+  const repoRoot = c.get("repoRoot");
+  dismissGitignorePrompt(repoRoot);
+  return c.json({ ok: true });
+});
+apiRoutes.post("/review/reopen", async (c) => {
+  const reviewId = resolveReviewId(c);
+  await updateReviewStatus(reviewId, "in_progress");
+  return c.json({ status: "in_progress" });
+});
+apiRoutes.delete("/review/:id", async (c) => {
+  const reviewId = c.req.param("id");
+  const currentReviewId = c.get("currentReviewId");
+  if (reviewId === currentReviewId) {
+    return c.json({ error: "Cannot delete the current review" }, 400);
+  }
+  const repoRoot = c.get("repoRoot");
+  deleteReviewExport(reviewId, repoRoot);
+  await deleteReview(reviewId);
+  return c.json({ ok: true });
+});
+apiRoutes.post("/reviews/delete-completed", async (c) => {
+  const currentReviewId = c.get("currentReviewId");
+  const repoRoot = c.get("repoRoot");
+  const reviews = await listReviews(repoRoot);
+  const toDelete = reviews.filter((r) => r.status === "completed" && r.id !== currentReviewId);
+  for (const r of toDelete) {
+    deleteReviewExport(r.id, repoRoot);
+    await deleteReview(r.id);
+  }
+  return c.json({ deleted: toDelete.length });
+});
+apiRoutes.post("/reviews/delete-all", async (c) => {
+  const currentReviewId = c.get("currentReviewId");
+  const repoRoot = c.get("repoRoot");
+  const reviews = await listReviews(repoRoot);
+  const toDelete = reviews.filter((r) => r.id !== currentReviewId);
+  for (const r of toDelete) {
+    deleteReviewExport(r.id, repoRoot);
+    await deleteReview(r.id);
+  }
+  return c.json({ deleted: toDelete.length });
+});
+apiRoutes.get("/files", async (c) => {
+  const reviewId = resolveReviewId(c);
+  const files = await getReviewFiles(reviewId);
+  const annotationCounts = {};
+  for (const file of files) {
+    const annotations = await getAnnotationsForFile(file.id);
+    annotationCounts[file.id] = annotations.length;
+  }
+  const staleCounts = await getStaleCountsForReview(reviewId);
+  return c.json({ files, annotationCounts, staleCounts });
+});
+apiRoutes.get("/files/:fileId", async (c) => {
+  const file = await getReviewFile(c.req.param("fileId"));
+  if (!file) return c.json({ error: "Not found" }, 404);
+  const annotations = await getAnnotationsForFile(file.id);
+  return c.json({ file, annotations });
+});
+apiRoutes.patch("/files/:fileId/status", async (c) => {
+  const { status } = await c.req.json();
+  await updateFileStatus(c.req.param("fileId"), status);
+  return c.json({ ok: true });
+});
+apiRoutes.post("/annotations", async (c) => {
+  const body = await c.req.json();
+  const annotation = await addAnnotation(
+    body.reviewFileId,
+    body.lineNumber,
+    body.side,
+    body.category,
+    body.content
+  );
+  return c.json(annotation, 201);
+});
+apiRoutes.patch("/annotations/:id", async (c) => {
+  const { content, category } = await c.req.json();
+  await updateAnnotation(c.req.param("id"), content, category);
+  return c.json({ ok: true });
+});
+apiRoutes.delete("/annotations/:id", async (c) => {
+  await deleteAnnotation(c.req.param("id"));
+  return c.json({ ok: true });
+});
+apiRoutes.patch("/annotations/:id/move", async (c) => {
+  const { lineNumber, side } = await c.req.json();
+  await moveAnnotation(c.req.param("id"), lineNumber, side);
+  return c.json({ ok: true });
+});
+apiRoutes.post("/annotations/:id/keep", async (c) => {
+  await markAnnotationCurrent(c.req.param("id"));
+  return c.json({ ok: true });
+});
+apiRoutes.post("/annotations/stale/delete-all", async (c) => {
+  const reviewId = resolveReviewId(c);
+  await deleteStaleAnnotations(reviewId);
+  return c.json({ ok: true });
+});
+apiRoutes.post("/annotations/stale/keep-all", async (c) => {
+  const reviewId = resolveReviewId(c);
+  await keepAllStaleAnnotations(reviewId);
+  return c.json({ ok: true });
+});
+apiRoutes.get("/annotations/all", async (c) => {
+  const reviewId = resolveReviewId(c);
+  const annotations = await getAnnotationsForReview(reviewId);
+  return c.json(annotations);
+});
+apiRoutes.get("/context/:fileId", async (c) => {
+  const repoRoot = c.get("repoRoot");
+  const file = await getReviewFile(c.req.param("fileId"));
+  if (!file) return c.json({ error: "Not found" }, 404);
+  const startLine = parseInt(c.req.query("start") || "1", 10);
+  const endLine = parseInt(c.req.query("end") || "20", 10);
+  const content = getFileContent(file.file_path, "working", repoRoot);
+  const allLines = content.split("\n");
+  const clampedStart = Math.max(1, startLine);
+  const clampedEnd = Math.min(allLines.length, endLine);
+  const lines = [];
+  for (let i = clampedStart; i <= clampedEnd; i++) {
+    lines.push({ num: i, content: allLines[i - 1] || "" });
+  }
+  return c.json({ lines });
+});
+
+// src/routes/pages.tsx
+import { Hono as Hono2 } from "hono";
+
+// src/utils/escapeHtml.ts
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function escapeAttr(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+// src/jsx-runtime.ts
+var SafeHtml = class {
+  __html;
+  constructor(html) {
+    this.__html = html;
+  }
+  toString() {
+    return this.__html;
+  }
+};
+function raw(html) {
+  return new SafeHtml(html);
+}
+var VOID_TAGS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "source",
+  "track",
+  "wbr"
+]);
+function renderChildren(children) {
+  if (children == null || typeof children === "boolean") return "";
+  if (children instanceof SafeHtml) return children.__html;
+  if (typeof children === "string") return escapeHtml(children);
+  if (typeof children === "number") return String(children);
+  if (Array.isArray(children)) return children.map(renderChildren).join("");
+  return "";
+}
+function renderAttr(key, value) {
+  if (value == null || value === false) return "";
+  if (value === true) return ` ${key}`;
+  const name = key === "className" ? "class" : key === "htmlFor" ? "for" : key;
+  let strValue;
+  if (value instanceof SafeHtml) {
+    strValue = value.__html;
+  } else if (typeof value === "number") {
+    strValue = String(value);
+  } else if (typeof value === "string") {
+    strValue = escapeAttr(value);
+  } else {
+    strValue = "";
+  }
+  return ` ${name}="${strValue}"`;
+}
+function jsx(tag, props) {
+  if (typeof tag === "function") return tag(props);
+  const { children, ...attrs } = props;
+  const attrStr = Object.entries(attrs).map(([k, v]) => renderAttr(k, v)).join("");
+  if (VOID_TAGS.has(tag)) return new SafeHtml(`<${tag}${attrStr}>`);
+  const childStr = children != null ? renderChildren(children) : "";
+  return new SafeHtml(`<${tag}${attrStr}>${childStr}</${tag}>`);
+}
+
+// src/components/layout.tsx
+function Layout({ title, reviewId, children }) {
+  return /* @__PURE__ */ jsx("html", { lang: "en", children: [
+    /* @__PURE__ */ jsx("head", { children: [
+      /* @__PURE__ */ jsx("meta", { charset: "utf-8" }),
+      /* @__PURE__ */ jsx("meta", { name: "viewport", content: "width=device-width, initial-scale=1" }),
+      /* @__PURE__ */ jsx("title", { children: title }),
+      /* @__PURE__ */ jsx("style", { children: raw(getStyles()) })
+    ] }),
+    /* @__PURE__ */ jsx("body", { "data-review-id": reviewId, children: [
+      children,
+      /* @__PURE__ */ jsx("script", { children: raw(getClientScript()) })
+    ] })
+  ] });
+}
+function getStyles() {
+  return `
+:root {
+  --bg: #1e1e2e;
+  --bg-surface: #252536;
+  --bg-hover: #2d2d44;
+  --bg-active: #363652;
+  --text: #cdd6f4;
+  --text-dim: #8888aa;
+  --text-bright: #ffffff;
+  --accent: #89b4fa;
+  --accent-hover: #74a8fc;
+  --green: #a6e3a1;
+  --red: #f38ba8;
+  --yellow: #f9e2af;
+  --orange: #fab387;
+  --blue: #89b4fa;
+  --purple: #cba6f7;
+  --teal: #94e2d5;
+  --border: #363652;
+  --diff-add-bg: rgba(166, 227, 161, 0.1);
+  --diff-add-border: rgba(166, 227, 161, 0.3);
+  --diff-remove-bg: rgba(243, 139, 168, 0.1);
+  --diff-remove-border: rgba(243, 139, 168, 0.3);
+  --diff-context-bg: transparent;
+  --gutter-bg: #1a1a2e;
+  --gutter-text: #555577;
+  --sidebar-w: 300px;
+  --radius: 6px;
+  --font-mono: 'JetBrains Mono', 'Fira Code', 'Cascadia Code', monospace;
+  --font-sans: -apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif;
+}
+
+* { margin: 0; padding: 0; box-sizing: border-box; }
+
+body {
+  font-family: var(--font-sans);
+  background: var(--bg);
+  color: var(--text);
+  height: 100vh;
+  overflow: hidden;
+}
+
+.review-app {
+  display: flex;
+  height: 100vh;
+}
+
+/* Sidebar */
+.sidebar {
+  width: var(--sidebar-w);
+  min-width: 200px;
+  max-width: 60vw;
+  background: var(--bg-surface);
+  border-right: 1px solid var(--border);
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  flex-shrink: 0;
+}
+
+.sidebar-resize {
+  width: 4px;
+  cursor: col-resize;
+  background: transparent;
+  flex-shrink: 0;
+  transition: background 0.15s;
+}
+
+.sidebar-resize:hover,
+.sidebar-resize.dragging {
+  background: var(--accent);
+}
+
+.sidebar-header {
+  padding: 16px;
+  border-bottom: 1px solid var(--border);
+}
+
+.sidebar-header h2 {
+  font-size: 16px;
+  font-weight: 600;
+  color: var(--text-bright);
+}
+
+.review-mode {
+  font-size: 12px;
+  color: var(--text-dim);
+  margin-top: 4px;
+  display: block;
+}
+
+.sidebar-controls {
+  padding: 8px 16px;
+  border-bottom: 1px solid var(--border);
+}
+
+.diff-mode-toggle {
+  display: flex;
+  gap: 4px;
+}
+
+.file-filter {
+  padding: 8px 16px;
+  border-bottom: 1px solid var(--border);
+}
+
+.file-filter-input {
+  width: 100%;
+  padding: 5px 8px;
+  background: var(--bg);
+  color: var(--text);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  font-family: var(--font-mono);
+  font-size: 12px;
+  outline: none;
+}
+
+.file-filter-input:focus {
+  border-color: var(--accent);
+}
+
+.file-filter-input::placeholder {
+  color: var(--text-dim);
+}
+
+.sidebar-footer {
+  padding: 16px;
+  border-top: 1px solid var(--border);
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+/* File list */
+.file-list {
+  flex: 1;
+  overflow-y: auto;
+  padding: 8px 0;
+}
+
+.file-item {
+  display: flex;
+  align-items: center;
+  padding: 6px 16px 6px 16px;
+  cursor: pointer;
+  font-size: 13px;
+  gap: 8px;
+  border-left: 3px solid transparent;
+  transition: background 0.1s;
+}
+
+.file-item:hover { background: var(--bg-hover); }
+.file-item.active { background: var(--bg-active); border-left-color: var(--accent); }
+
+.file-item .status-dot {
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  flex-shrink: 0;
+}
+
+.file-item .status-dot.pending { background: var(--text-dim); }
+.file-item .status-dot.reviewed { background: var(--green); }
+.file-item .status-dot.skipped { background: var(--yellow); }
+
+.file-item .file-name {
+  flex: 1;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-family: var(--font-mono);
+  font-size: 12px;
+}
+
+.file-item .file-status {
+  font-size: 11px;
+  font-weight: 500;
+  padding: 1px 6px;
+  border-radius: 3px;
+}
+
+.file-status.added { color: var(--green); background: rgba(166,227,161,0.1); }
+.file-status.modified { color: var(--yellow); background: rgba(249,226,175,0.1); }
+.file-status.deleted { color: var(--red); background: rgba(243,139,168,0.1); }
+.file-status.renamed { color: var(--purple); background: rgba(203,166,247,0.1); }
+
+.annotation-count {
+  font-size: 11px;
+  color: var(--accent);
+  background: rgba(137,180,250,0.15);
+  padding: 0 5px;
+  border-radius: 8px;
+  min-width: 18px;
+  text-align: center;
+}
+
+/* Folder tree */
+.folder-header {
+  display: flex;
+  align-items: center;
+  padding: 4px 16px;
+  font-size: 12px;
+  color: var(--text-dim);
+  gap: 4px;
+  user-select: none;
+}
+
+.folder-header.collapsible {
+  cursor: pointer;
+}
+
+.folder-header.collapsible:hover {
+  color: var(--text);
+}
+
+.folder-header.collapsed + .folder-content {
+  display: none;
+}
+
+.folder-arrow {
+  width: 12px;
+  font-size: 10px;
+  flex-shrink: 0;
+  text-align: center;
+  transition: transform 0.1s;
+}
+
+.folder-header.collapsed .folder-arrow {
+  transform: rotate(-90deg);
+}
+
+.folder-arrow-spacer {
+  width: 12px;
+  flex-shrink: 0;
+}
+
+.folder-name {
+  font-family: var(--font-mono);
+  font-size: 12px;
+}
+
+/* Main content */
+.main-content {
+  flex: 1;
+  overflow: auto;
+}
+
+.welcome-message {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  height: 100%;
+  color: var(--text-dim);
+  gap: 8px;
+}
+
+.welcome-message h3 { color: var(--text); }
+
+/* Diff view */
+.diff-header {
+  position: sticky;
+  top: 0;
+  z-index: 10;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 10px 16px;
+  background: var(--bg-surface);
+  border-bottom: 1px solid var(--border);
+}
+
+.diff-header .file-path {
+  font-family: var(--font-mono);
+  font-size: 13px;
+  color: var(--text-bright);
+}
+
+.diff-header-actions {
+  display: flex;
+  gap: 8px;
+  align-items: center;
+}
+
+/* Split diff */
+.diff-table-split {
+  width: 100%;
+  font-family: var(--font-mono);
+  font-size: 13px;
+  line-height: 20px;
+}
+
+.split-row {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+}
+
+.split-row .diff-line {
+  display: flex;
+  min-width: 0;
+  overflow: hidden;
+}
+
+.split-row .diff-line.empty {
+  background: var(--gutter-bg);
+  min-height: 20px;
+}
+
+.split-row .gutter {
+  width: 50px;
+  min-width: 50px;
+  padding: 0 6px;
+  text-align: right;
+  color: var(--gutter-text);
+  background: var(--gutter-bg);
+  user-select: none;
+  font-size: 12px;
+  flex-shrink: 0;
+}
+
+.split-left { border-right: 1px solid var(--border); }
+
+.diff-table-split .hunk-separator {
+  grid-column: 1 / -1;
+}
+
+.diff-line {
+  display: flex;
+  min-height: 20px;
+  border-bottom: 1px solid rgba(54,54,82,0.3);
+  cursor: pointer;
+}
+
+.diff-line:hover { filter: brightness(1.2); }
+
+.diff-line.add { background: var(--diff-add-bg); }
+.diff-line.remove { background: var(--diff-remove-bg); }
+.diff-line.context { background: var(--diff-context-bg); }
+
+.diff-line .gutter {
+  width: 60px;
+  min-width: 60px;
+  padding: 0 8px;
+  text-align: right;
+  color: var(--gutter-text);
+  background: var(--gutter-bg);
+  user-select: none;
+  font-size: 12px;
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+}
+
+.diff-line .code {
+  flex: 1;
+  padding: 0 12px;
+  white-space: pre;
+  overflow-x: auto;
+  tab-size: 4;
+}
+
+.diff-line.add .code::before { content: '+'; color: var(--green); margin-right: 4px; }
+.diff-line.remove .code::before { content: '-'; color: var(--red); margin-right: 4px; }
+
+/* Unified diff */
+.diff-table-unified {
+  width: 100%;
+  font-family: var(--font-mono);
+  font-size: 13px;
+  line-height: 20px;
+}
+
+.diff-table-unified .diff-line {
+  display: flex;
+  min-width: 0;
+}
+
+.diff-table-unified .gutter-old,
+.diff-table-unified .gutter-new {
+  width: 50px;
+  min-width: 50px;
+  padding: 0 6px;
+  text-align: right;
+  color: var(--gutter-text);
+  background: var(--gutter-bg);
+  user-select: none;
+  font-size: 12px;
+}
+
+/* Hunk separator */
+.hunk-separator {
+  padding: 4px 16px;
+  background: rgba(137,180,250,0.05);
+  color: var(--text-dim);
+  font-size: 12px;
+  font-family: var(--font-mono);
+  border-top: 1px solid var(--border);
+  border-bottom: 1px solid var(--border);
+  cursor: pointer;
+}
+
+.hunk-separator:hover { background: rgba(137,180,250,0.1); }
+
+.expand-controls {
+  display: flex;
+  gap: 8px;
+  padding: 2px 16px;
+  background: rgba(137,180,250,0.05);
+  border-bottom: 1px solid var(--border);
+}
+
+.expand-btn {
+  font-size: 11px;
+  color: var(--accent);
+  background: none;
+  border: none;
+  cursor: pointer;
+  padding: 2px 6px;
+  border-radius: 3px;
+}
+
+.expand-btn:hover { background: rgba(137,180,250,0.15); }
+
+/* Annotation indicators */
+.has-annotation .gutter {
+  position: relative;
+}
+
+.has-annotation .gutter::after {
+  content: '';
+  position: absolute;
+  right: 2px;
+  top: 50%;
+  transform: translateY(-50%);
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: var(--accent);
+}
+
+/* Annotation inline display */
+.annotation-row {
+  padding: 8px 16px 8px 76px;
+  background: rgba(137,180,250,0.05);
+  border-left: 3px solid var(--accent);
+  font-family: var(--font-sans);
+  font-size: 13px;
+}
+
+.annotation-row .annotation-item {
+  display: flex;
+  gap: 8px;
+  align-items: flex-start;
+  padding: 4px 0;
+}
+
+.annotation-category {
+  font-size: 11px;
+  font-weight: 600;
+  padding: 1px 6px;
+  border-radius: 3px;
+  white-space: nowrap;
+  flex-shrink: 0;
+}
+
+.category-bug { color: var(--red); background: rgba(243,139,168,0.15); }
+.category-fix { color: var(--orange); background: rgba(250,179,135,0.15); }
+.category-style { color: var(--purple); background: rgba(203,166,247,0.15); }
+.category-pattern-follow { color: var(--green); background: rgba(166,227,161,0.15); }
+.category-pattern-avoid { color: var(--red); background: rgba(243,139,168,0.15); }
+.category-note { color: var(--blue); background: rgba(137,180,250,0.15); }
+.category-remember { color: var(--yellow); background: rgba(249,226,175,0.15); }
+
+.annotation-text {
+  flex: 1;
+  color: var(--text);
+  line-height: 1.4;
+}
+
+.annotation-actions {
+  display: flex;
+  gap: 4px;
+  flex-shrink: 0;
+}
+
+/* Stale annotations */
+.annotation-stale {
+  opacity: 0.7;
+}
+
+.annotation-row:has(.annotation-stale) {
+  border-left-color: var(--orange);
+  background: rgba(250,179,135,0.05);
+}
+
+.btn-keep { color: var(--orange); }
+.btn-keep:hover { background: rgba(250,179,135,0.15); }
+
+.btn-icon { display: inline-flex; align-items: center; justify-content: center; padding: 3px 4px; }
+.btn-icon svg { display: block; }
+
+.annotation-category[data-action="reclassify"] { cursor: pointer; }
+.annotation-category[data-action="reclassify"]:hover { filter: brightness(1.3); }
+
+.reclassify-popup {
+  background: var(--bg-surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  padding: 4px 0;
+  box-shadow: 0 4px 12px rgba(0,0,0,0.3);
+  min-width: 140px;
+}
+
+.reclassify-option {
+  padding: 6px 12px;
+  cursor: pointer;
+}
+
+.reclassify-option:hover {
+  background: var(--bg-hover);
+}
+
+.reclassify-option.active {
+  background: rgba(137,180,250,0.1);
+}
+
+/* Stale indicator dot */
+.stale-dot {
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: var(--orange);
+  flex-shrink: 0;
+}
+
+/* Drag handle */
+.annotation-drag-handle {
+  cursor: grab;
+  color: var(--text-dim);
+  font-size: 14px;
+  line-height: 1;
+  flex-shrink: 0;
+  user-select: none;
+  padding: 0 2px;
+}
+
+.annotation-drag-handle:hover {
+  color: var(--text);
+}
+
+/* Drop target highlight */
+.diff-line.drag-over {
+  outline: 2px solid var(--accent);
+  outline-offset: -2px;
+}
+
+/* Annotation form */
+.annotation-form-container {
+  padding: 12px 16px 12px 76px;
+  background: rgba(137,180,250,0.08);
+  border-left: 3px solid var(--accent);
+}
+
+.annotation-form {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.form-category-badge {
+  cursor: pointer;
+  align-self: flex-start;
+}
+
+.form-category-badge:hover {
+  filter: brightness(1.3);
+}
+
+.annotation-form textarea {
+  width: 100%;
+  min-height: 60px;
+  padding: 8px;
+  background: var(--bg);
+  color: var(--text);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  font-family: var(--font-sans);
+  font-size: 13px;
+  resize: vertical;
+}
+
+.annotation-form textarea:focus {
+  outline: none;
+  border-color: var(--accent);
+}
+
+.annotation-form-actions {
+  display: flex;
+  gap: 8px;
+  justify-content: flex-end;
+}
+
+/* Buttons */
+.btn {
+  padding: 6px 14px;
+  border-radius: var(--radius);
+  border: 1px solid var(--border);
+  background: var(--bg-surface);
+  color: var(--text);
+  cursor: pointer;
+  font-size: 13px;
+  transition: background 0.15s;
+}
+
+.btn:hover { background: var(--bg-hover); }
+.btn.active { background: var(--accent); color: var(--bg); border-color: var(--accent); }
+
+.btn-sm { padding: 3px 10px; font-size: 12px; }
+.btn-xs { padding: 2px 6px; font-size: 11px; }
+
+.btn-primary {
+  background: var(--accent);
+  color: var(--bg);
+  border-color: var(--accent);
+  font-weight: 600;
+}
+
+.btn-primary:hover { background: var(--accent-hover); }
+
+.btn-danger { color: var(--red); }
+.btn-danger:hover { background: rgba(243,139,168,0.15); }
+
+.btn-link {
+  background: none;
+  border: none;
+  color: var(--accent);
+  text-decoration: none;
+  text-align: center;
+}
+
+.btn-link:hover { text-decoration: underline; }
+
+/* History */
+body:has(.history-page) {
+  overflow: auto;
+}
+
+.history-page {
+  max-width: 800px;
+  margin: 0 auto;
+  padding: 40px 20px;
+}
+
+.history-page h1 { margin-bottom: 24px; }
+
+.history-item {
+  padding: 16px;
+  background: var(--bg-surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  margin-bottom: 12px;
+}
+
+.history-item {
+  position: relative;
+}
+
+.history-item h3 { font-size: 15px; margin-bottom: 4px; padding-right: 32px; }
+.history-item .meta { font-size: 12px; color: var(--text-dim); }
+
+.history-item .delete-review-btn {
+  position: absolute;
+  top: 12px;
+  right: 12px;
+  background: none;
+  border: none;
+  color: var(--text-dim);
+  cursor: pointer;
+  padding: 4px;
+  border-radius: var(--radius);
+  font-size: 16px;
+  line-height: 1;
+  opacity: 0;
+  transition: opacity 0.15s, color 0.15s;
+}
+
+.history-item:hover .delete-review-btn { opacity: 1; }
+.history-item .delete-review-btn:hover { color: var(--red); background: rgba(243,139,168,0.15); }
+
+.bulk-actions {
+  display: flex;
+  gap: 8px;
+  margin: 12px 0;
+  padding: 4px 0;
+  align-items: center;
+}
+
+.bulk-actions span {
+  font-size: 13px;
+  color: var(--text-dim);
+  margin-right: auto;
+}
+
+.status-badge {
+  display: inline-block;
+  font-size: 11px;
+  padding: 1px 8px;
+  border-radius: 10px;
+  font-weight: 500;
+}
+
+.status-badge.in_progress, .status-badge.in-progress { color: var(--yellow); background: rgba(249,226,175,0.15); }
+.status-badge.completed { color: var(--green); background: rgba(166,227,161,0.15); }
+
+.history-item-link {
+  text-decoration: none;
+  color: inherit;
+  display: block;
+}
+
+.history-item-link:hover .history-item {
+  border-color: var(--accent);
+  background: var(--bg-hover);
+}
+
+.expanded-context {
+  background: rgba(137,180,250,0.03);
+}
+
+/* Wrap mode */
+.wrap-lines .code {
+  white-space: pre-wrap !important;
+  word-break: break-all;
+  overflow-x: visible !important;
+}
+
+/* Hide horizontal scrollbars on code cells (still scrollable via trackpad) */
+.diff-line .code {
+  scrollbar-width: none;
+}
+.diff-line .code::-webkit-scrollbar {
+  height: 0;
+}
+
+/* Controls layout */
+.sidebar-controls-row {
+  display: flex;
+  gap: 8px;
+  align-items: center;
+}
+
+.controls-divider {
+  width: 1px;
+  height: 18px;
+  background: var(--border);
+}
+
+/* Complete modal */
+.modal-overlay {
+  position: fixed;
+  inset: 0;
+  background: rgba(0,0,0,0.6);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 100;
+}
+
+.modal {
+  background: var(--bg-surface);
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  padding: 24px;
+  max-width: 480px;
+  width: 90%;
+}
+
+.modal h3 { margin-bottom: 12px; }
+.modal p { margin-bottom: 16px; color: var(--text-dim); font-size: 14px; }
+
+.modal-label { margin-bottom: 4px !important; font-size: 13px !important; color: var(--text-dim) !important; }
+
+.modal-copyable {
+  font-family: var(--font-mono);
+  font-size: 12px;
+  color: var(--accent);
+  background: var(--bg);
+  padding: 8px 12px;
+  border-radius: var(--radius);
+  border: 1px solid var(--border);
+  margin-bottom: 16px;
+  cursor: pointer;
+  position: relative;
+  word-break: break-all;
+  transition: border-color 0.15s;
+}
+
+.modal-copyable:hover { border-color: var(--accent); }
+
+.modal-copyable.copied::after {
+  content: 'Copied!';
+  position: absolute;
+  right: 8px;
+  top: 50%;
+  transform: translateY(-50%);
+  font-size: 11px;
+  color: var(--green);
+  font-family: var(--font-sans);
+}
+
+.modal-gitignore {
+  margin-bottom: 16px;
+  padding-top: 12px;
+  border-top: 1px solid var(--border);
+}
+
+.modal-actions {
+  display: flex;
+  gap: 8px;
+  justify-content: flex-end;
+}
+
+/* Scrollbar */
+::-webkit-scrollbar { width: 8px; height: 8px; }
+::-webkit-scrollbar-track { background: transparent; }
+::-webkit-scrollbar-thumb { background: var(--border); border-radius: 4px; }
+::-webkit-scrollbar-thumb:hover { background: var(--text-dim); }
+
+/* Progress */
+.progress-bar {
+  height: 3px;
+  background: var(--border);
+  border-radius: 2px;
+  overflow: hidden;
+  margin: 8px 16px;
+}
+
+.progress-bar-fill {
+  height: 100%;
+  background: var(--accent);
+  transition: width 0.3s;
+}
+`;
+}
+function getClientScript() {
+  return `
+(function() {
+  const state = {
+    reviewId: document.body.dataset.reviewId,
+    currentFileId: null,
+    diffMode: 'split',
+    wrapLines: false,
+    files: [],
+    fileOrder: [],
+    annotationCounts: {},
+    staleCounts: {},
+    filterText: '',
+    _dragAnnotation: null,
+  };
+
+  const CATEGORIES = [
+    { value: 'bug', label: 'Bug' },
+    { value: 'fix', label: 'Fix needed' },
+    { value: 'style', label: 'Style' },
+    { value: 'pattern-follow', label: 'Pattern to follow' },
+    { value: 'pattern-avoid', label: 'Pattern to avoid' },
+    { value: 'note', label: 'Note' },
+    { value: 'remember', label: 'Remember (for AI)' },
+  ];
+
+  // --- API ---
+  async function api(path, opts = {}) {
+    const separator = path.includes('?') ? '&' : '?';
+    const url = '/api' + path + separator + 'reviewId=' + encodeURIComponent(state.reviewId);
+    const res = await fetch(url, {
+      headers: { 'Content-Type': 'application/json' },
+      ...opts,
+      body: opts.body ? JSON.stringify(opts.body) : undefined,
+    });
+    return res.json();
+  }
+
+  // --- Init ---
+  async function init() {
+    await loadFiles();
+    bindSidebarEvents();
+    bindDiffModeToggle();
+    bindWrapToggle();
+    bindFileFilter();
+    bindSidebarResize();
+    bindCompleteButton();
+    bindReopenButton();
+    initScrollSync();
+    updateProgress();
+    document.addEventListener('dragend', () => {
+      state._dragAnnotation = null;
+      document.querySelectorAll('.diff-line.drag-over').forEach(d => d.classList.remove('drag-over'));
+    });
+  }
+
+  async function loadFiles() {
+    const data = await api('/files');
+    state.files = data.files;
+    state.annotationCounts = data.annotationCounts;
+    state.staleCounts = data.staleCounts || {};
+    renderFileList();
+  }
+
+  function renderFileList() {
+    var list = document.querySelector('.file-list-items');
+    if (!list) return;
+    list.innerHTML = '';
+    state.fileOrder = [];
+    var filtered = state.files;
+    if (state.filterText) {
+      var q = state.filterText.toLowerCase();
+      filtered = state.files.filter(function(f) {
+        return f.file_path.toLowerCase().indexOf(q) !== -1;
+      });
+    }
+    var tree = buildFileTree(filtered);
+    renderTreeNode(list, tree, 0);
+  }
+
+  function buildFileTree(files) {
+    var root = { name: '', children: [], files: [] };
+    files.forEach(function(f) {
+      var parts = f.file_path.split('/');
+      var node = root;
+      for (var i = 0; i < parts.length - 1; i++) {
+        var child = node.children.find(function(c) { return c.name === parts[i]; });
+        if (!child) {
+          child = { name: parts[i], children: [], files: [] };
+          node.children.push(child);
+        }
+        node = child;
+      }
+      node.files.push(f);
+    });
+    compressTree(root);
+    return root;
+  }
+
+  function compressTree(node) {
+    for (var i = 0; i < node.children.length; i++) {
+      var child = node.children[i];
+      while (child.children.length === 1 && child.files.length === 0) {
+        var gc = child.children[0];
+        child = { name: child.name + '/' + gc.name, children: gc.children, files: gc.files };
+        node.children[i] = child;
+      }
+      compressTree(child);
+    }
+  }
+
+  function countTreeFiles(node) {
+    var count = node.files.length;
+    node.children.forEach(function(c) { count += countTreeFiles(c); });
+    return count;
+  }
+
+  function hasStaleInTree(node) {
+    for (var i = 0; i < node.files.length; i++) {
+      if (state.staleCounts[node.files[i].id]) return true;
+    }
+    for (var i = 0; i < node.children.length; i++) {
+      if (hasStaleInTree(node.children[i])) return true;
+    }
+    return false;
+  }
+
+  function renderTreeNode(container, node, depth) {
+    var sortedChildren = node.children.slice().sort(function(a, b) { return a.name.localeCompare(b.name); });
+
+    sortedChildren.forEach(function(child) {
+      var total = countTreeFiles(child);
+      var isCollapsible = total > 1;
+
+      var group = document.createElement('div');
+      group.className = 'folder-group';
+
+      var header = document.createElement('div');
+      header.className = 'folder-header' + (isCollapsible ? ' collapsible' : '');
+      header.style.paddingLeft = (16 + depth * 12) + 'px';
+      var stale = hasStaleInTree(child);
+      header.innerHTML =
+        (isCollapsible ? '<span class="folder-arrow">\u25BE</span>' : '<span class="folder-arrow-spacer"></span>') +
+        '<span class="folder-name">' + esc(child.name) + '/</span>' +
+        (stale ? '<span class="stale-dot"></span>' : '');
+
+      var content = document.createElement('div');
+      content.className = 'folder-content';
+
+      if (isCollapsible) {
+        header.addEventListener('click', function() {
+          header.classList.toggle('collapsed');
+        });
+      }
+
+      renderTreeNode(content, child, depth + 1);
+
+      group.appendChild(header);
+      group.appendChild(content);
+      container.appendChild(group);
+    });
+
+    node.files.forEach(function(f) {
+      var diff = JSON.parse(f.diff_data || '{}');
+      var el = document.createElement('div');
+      el.className = 'file-item' + (f.id === state.currentFileId ? ' active' : '');
+      el.dataset.fileId = f.id;
+      el.style.paddingLeft = (16 + depth * 12) + 'px';
+      var count = state.annotationCounts[f.id] || 0;
+      var staleCount = state.staleCounts[f.id] || 0;
+      var fileName = f.file_path.split('/').pop();
+      el.innerHTML =
+        '<span class="status-dot ' + f.status + '"></span>' +
+        '<span class="file-name" title="' + esc(f.file_path) + '">' + esc(fileName) + '</span>' +
+        '<span class="file-status ' + (diff.status || '') + '">' + (diff.status || '') + '</span>' +
+        (staleCount ? '<span class="stale-dot"></span>' : '') +
+        (count ? '<span class="annotation-count">' + count + '</span>' : '');
+      el.addEventListener('click', function() { selectFile(f.id); });
+      container.appendChild(el);
+      state.fileOrder.push(f.id);
+    });
+  }
+
+  function esc(s) {
+    const d = document.createElement('div');
+    d.textContent = s;
+    return d.innerHTML;
+  }
+
+  // --- File Selection ---
+  async function selectFile(fileId) {
+    state.currentFileId = fileId;
+    document.querySelectorAll('.file-item').forEach(el => {
+      el.classList.toggle('active', el.dataset.fileId === fileId);
+    });
+
+    const container = document.getElementById('diff-container');
+    const welcome = document.querySelector('.welcome-message');
+    if (welcome) welcome.style.display = 'none';
+    container.style.display = 'block';
+
+    const res = await fetch('/file/' + fileId + '?mode=' + state.diffMode);
+    container.innerHTML = await res.text();
+
+    // Reapply wrap mode
+    container.classList.toggle('wrap-lines', state.wrapLines);
+
+    // Mark file as reviewed
+    const file = state.files.find(f => f.id === fileId);
+    if (file && file.status === 'pending') {
+      await api('/files/' + fileId + '/status', { method: 'PATCH', body: { status: 'reviewed' } });
+      file.status = 'reviewed';
+      renderFileList();
+      updateProgress();
+    }
+
+    bindDiffLineClicks();
+    bindHunkExpanders();
+    bindDragDrop();
+    bindServerAnnotations();
+  }
+
+  // --- Context Expansion ---
+  function bindHunkExpanders() {
+    document.querySelectorAll('.hunk-separator').forEach(el => {
+      el.addEventListener('click', async () => {
+        const fileId = document.querySelector('.diff-view')?.dataset?.fileId;
+        if (!fileId) return;
+
+        const hunkBlock = el.closest('.hunk-block');
+        const prevBlock = hunkBlock?.previousElementSibling;
+
+        // Determine the gap: from end of previous hunk to start of this hunk
+        const newStart = parseInt(el.dataset.newStart, 10);
+        let gapStart = 1;
+        if (prevBlock) {
+          const prevSep = prevBlock.querySelector('.hunk-separator');
+          if (prevSep) {
+            gapStart = parseInt(prevSep.dataset.newStart, 10) + parseInt(prevSep.dataset.newCount, 10);
+          }
+        }
+        const gapEnd = newStart - 1;
+        if (gapEnd < gapStart) return;
+
+        const data = await api('/context/' + fileId + '?start=' + gapStart + '&end=' + gapEnd);
+        if (!data.lines || !data.lines.length) return;
+
+        // Build context lines and insert before the hunk separator
+        const fragment = document.createDocumentFragment();
+        data.lines.forEach(line => {
+          const wrapper = document.createElement('div');
+          const lineEl = document.createElement('div');
+          lineEl.className = 'diff-line context expanded-context';
+          lineEl.dataset.line = line.num;
+          lineEl.dataset.side = 'new';
+
+          if (state.diffMode === 'split') {
+            lineEl.innerHTML =
+              '<span class="gutter">' + line.num + '</span>' +
+              '<span class="code">' + esc(line.content) + '</span>';
+            const row = document.createElement('div');
+            row.className = 'split-row';
+            const leftEl = lineEl.cloneNode(true);
+            leftEl.dataset.side = 'old';
+            row.appendChild(leftEl);
+            row.appendChild(lineEl);
+            wrapper.appendChild(row);
+          } else {
+            lineEl.innerHTML =
+              '<span class="gutter-old">' + line.num + '</span>' +
+              '<span class="gutter-new">' + line.num + '</span>' +
+              '<span class="code">' + esc(line.content) + '</span>';
+            wrapper.appendChild(lineEl);
+          }
+          fragment.appendChild(wrapper);
+        });
+
+        el.replaceWith(fragment);
+        bindDiffLineClicks();
+      });
+    });
+  }
+
+  // --- Diff Line Clicks ---
+  function bindDiffLineClicks() {
+    document.querySelectorAll('.diff-line').forEach(el => {
+      el.addEventListener('click', (e) => {
+        if (e.target.closest('.annotation-form-container') || e.target.closest('.annotation-row')) return;
+        const line = parseInt(el.dataset.line, 10);
+        const side = el.dataset.side || 'new';
+        if (!isNaN(line)) showAnnotationForm(el, line, side);
+      });
+    });
+  }
+
+  function buildCategoryBadge(value) {
+    var cat = CATEGORIES.find(function(c) { return c.value === value; });
+    return '<span class="annotation-category category-' + esc(value) + ' form-category-badge" data-category="' + esc(value) + '">' + esc(cat ? cat.label : value) + '</span>';
+  }
+
+  function bindCategoryBadgeClick(container) {
+    var badge = container.querySelector('.form-category-badge');
+    if (!badge) return;
+    badge.addEventListener('click', function(e) {
+      e.stopPropagation();
+      showCategoryPicker(badge);
+    });
+  }
+
+  function showCategoryPicker(badge) {
+    document.querySelectorAll('.reclassify-popup').forEach(function(el) { el.remove(); });
+
+    var current = badge.dataset.category;
+    var popup = document.createElement('div');
+    popup.className = 'reclassify-popup';
+    popup.innerHTML = CATEGORIES.map(function(c) {
+      return '<div class="reclassify-option' + (c.value === current ? ' active' : '') + '" data-value="' + c.value + '">' +
+        '<span class="annotation-category category-' + c.value + '">' + c.label + '</span>' +
+      '</div>';
+    }).join('');
+
+    var rect = badge.getBoundingClientRect();
+    popup.style.position = 'fixed';
+    popup.style.left = rect.left + 'px';
+    popup.style.top = (rect.bottom + 4) + 'px';
+    popup.style.zIndex = '1000';
+
+    popup.addEventListener('click', function(e) {
+      var opt = e.target.closest('.reclassify-option');
+      if (!opt) return;
+      e.stopPropagation();
+      var val = opt.dataset.value;
+      var cat = CATEGORIES.find(function(c) { return c.value === val; });
+      badge.className = 'annotation-category category-' + val + ' form-category-badge';
+      badge.dataset.category = val;
+      badge.textContent = cat ? cat.label : val;
+      popup.remove();
+    });
+
+    document.body.appendChild(popup);
+    var closePopup = function(e) {
+      if (!popup.contains(e.target)) {
+        popup.remove();
+        document.removeEventListener('click', closePopup, true);
+      }
+    };
+    setTimeout(function() { document.addEventListener('click', closePopup, true); }, 0);
+  }
+
+  function showAnnotationForm(afterEl, lineNumber, side) {
+    // Remove any existing form
+    document.querySelectorAll('.annotation-form-container').forEach(el => el.remove());
+
+    var defaultCategory = CATEGORIES[0].value;
+    const container = document.createElement('div');
+    container.className = 'annotation-form-container';
+    container.innerHTML =
+      '<div class="annotation-form">' +
+        buildCategoryBadge(defaultCategory) +
+        '<textarea placeholder="Enter your annotation..." autofocus></textarea>' +
+        '<div class="annotation-form-actions">' +
+          '<button class="btn btn-sm cancel-btn">Cancel</button>' +
+          '<button class="btn btn-sm btn-primary annotation-save-btn">Save</button>' +
+        '</div>' +
+      '</div>';
+
+    // Insert after the clicked line (or after its annotation rows)
+    let insertAfter = afterEl;
+    let next = afterEl.nextElementSibling;
+    while (next && (next.classList.contains('annotation-row'))) {
+      insertAfter = next;
+      next = next.nextElementSibling;
+    }
+    insertAfter.parentNode.insertBefore(container, insertAfter.nextSibling);
+
+    bindCategoryBadgeClick(container);
+
+    container.querySelector('.cancel-btn').addEventListener('click', () => {
+      container.remove();
+    });
+
+    const textarea = container.querySelector('textarea');
+    textarea.focus();
+
+    // Handle Cmd/Ctrl+Enter to save
+    textarea.addEventListener('keydown', (e) => {
+      if ((e.metaKey || e.ctrlKey) && e.key === 'Enter') {
+        saveAnnotation(container, lineNumber, side);
+      }
+      if (e.key === 'Escape') {
+        container.remove();
+      }
+    });
+
+    container.querySelector('.annotation-save-btn').addEventListener('click', () => {
+      saveAnnotation(container, lineNumber, side);
+    });
+  }
+
+  async function saveAnnotation(container, lineNumber, side) {
+    const content = container.querySelector('textarea').value.trim();
+    const category = container.querySelector('.form-category-badge').dataset.category;
+    if (!content) return;
+
+    const annotation = await api('/annotations', {
+      method: 'POST',
+      body: {
+        reviewFileId: state.currentFileId,
+        lineNumber,
+        side,
+        category,
+        content,
+      },
+    });
+
+    container.remove();
+    renderAnnotationInline(annotation, lineNumber, side);
+
+    // Update count
+    state.annotationCounts[state.currentFileId] = (state.annotationCounts[state.currentFileId] || 0) + 1;
+    renderFileList();
+  }
+
+  function renderAnnotationInline(annotation, lineNumber, side) {
+    // Find the line element
+    const lineEl = document.querySelector('.diff-line[data-line="' + lineNumber + '"][data-side="' + side + '"]');
+    if (!lineEl) return;
+
+    lineEl.classList.add('has-annotation');
+
+    // Find or create annotation row after this line
+    let annotationRow = lineEl.nextElementSibling;
+    if (!annotationRow || !annotationRow.classList.contains('annotation-row')) {
+      annotationRow = document.createElement('div');
+      annotationRow.className = 'annotation-row';
+      lineEl.parentNode.insertBefore(annotationRow, lineEl.nextSibling);
+    }
+
+    const item = document.createElement('div');
+    item.className = 'annotation-item' + (annotation.is_stale ? ' annotation-stale' : '');
+    item.dataset.annotationId = annotation.id;
+    if (annotation.is_stale) item.dataset.isStale = 'true';
+    item.innerHTML = buildAnnotationItemHtml(annotation);
+
+    bindAnnotationItemEvents(item, annotation, lineEl, annotationRow);
+    annotationRow.appendChild(item);
+  }
+
+  var ICON_TRASH = '<svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M3 6h18"/><path d="M19 6v14c0 1-1 2-2 2H7c-1 0-2-1-2-2V6"/><path d="M8 6V4c0-1 1-2 2-2h4c1 0 2 1 2 2v2"/><line x1="10" y1="11" x2="10" y2="17"/><line x1="14" y1="11" x2="14" y2="17"/></svg>';
+  var ICON_EDIT = '<svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17 3a2.85 2.85 0 1 1 4 4L7.5 20.5 2 22l1.5-5.5Z"/><path d="m15 5 4 4"/></svg>';
+
+  function buildAnnotationItemHtml(annotation) {
+    return '<span class="annotation-drag-handle" draggable="true" title="Drag to move">\u2807</span>' +
+      '<span class="annotation-category category-' + esc(annotation.category) + '" data-action="reclassify">' + esc(annotation.category) + '</span>' +
+      '<span class="annotation-text">' + esc(annotation.content) + '</span>' +
+      '<div class="annotation-actions">' +
+        (annotation.is_stale ? '<button class="btn btn-xs btn-keep" data-action="keep">Keep</button>' : '') +
+        '<button class="btn btn-xs btn-icon" data-action="edit" title="Edit">' + ICON_EDIT + '</button>' +
+        '<button class="btn btn-xs btn-icon btn-danger" data-action="delete" title="Delete">' + ICON_TRASH + '</button>' +
+      '</div>';
+  }
+
+  function bindAnnotationItemEvents(item, annotation, lineEl, annotationRow) {
+    item.querySelector('[data-action="delete"]')?.addEventListener('click', async (e) => {
+      e.stopPropagation();
+      await api('/annotations/' + annotation.id, { method: 'DELETE' });
+      item.remove();
+      if (annotationRow && !annotationRow.querySelector('.annotation-item')) {
+        annotationRow.remove();
+        if (lineEl) lineEl.classList.remove('has-annotation');
+      }
+      state.annotationCounts[state.currentFileId] = Math.max(0, (state.annotationCounts[state.currentFileId] || 1) - 1);
+      if (annotation.is_stale) {
+        state.staleCounts[state.currentFileId] = Math.max(0, (state.staleCounts[state.currentFileId] || 1) - 1);
+      }
+      renderFileList();
+    });
+
+    item.querySelector('[data-action="edit"]')?.addEventListener('click', (e) => {
+      e.stopPropagation();
+      editAnnotation(item, annotation);
+    });
+
+    // Double-click to edit
+    item.addEventListener('dblclick', (e) => {
+      e.stopPropagation();
+      if (item.querySelector('.annotation-form')) return;
+      editAnnotation(item, annotation);
+    });
+
+    // Click category to reclassify
+    item.querySelector('[data-action="reclassify"]')?.addEventListener('click', (e) => {
+      e.stopPropagation();
+      showReclassifyPopup(e.target.closest('[data-action="reclassify"]'), item, annotation);
+    });
+
+    item.querySelector('[data-action="keep"]')?.addEventListener('click', async (e) => {
+      e.stopPropagation();
+      await api('/annotations/' + annotation.id + '/keep', { method: 'POST' });
+      annotation.is_stale = false;
+      item.classList.remove('annotation-stale');
+      delete item.dataset.isStale;
+      item.innerHTML = buildAnnotationItemHtml(annotation);
+      bindAnnotationItemEvents(item, annotation, lineEl, annotationRow);
+      state.staleCounts[state.currentFileId] = Math.max(0, (state.staleCounts[state.currentFileId] || 1) - 1);
+      renderFileList();
+    });
+
+    // Drag handle
+    var handle = item.querySelector('.annotation-drag-handle');
+    if (handle) {
+      handle.addEventListener('dragstart', (e) => {
+        e.stopPropagation();
+        state._dragAnnotation = { id: annotation.id, item: item, annotation: annotation };
+        e.dataTransfer.effectAllowed = 'move';
+        e.dataTransfer.setData('text/plain', annotation.id);
+      });
+    }
+  }
+
+  function showReclassifyPopup(badge, item, annotation) {
+    // Remove any existing popup
+    document.querySelectorAll('.reclassify-popup').forEach(el => el.remove());
+
+    var popup = document.createElement('div');
+    popup.className = 'reclassify-popup';
+    popup.innerHTML = CATEGORIES.map(function(c) {
+      return '<div class="reclassify-option' + (c.value === annotation.category ? ' active' : '') + '" data-value="' + c.value + '">' +
+        '<span class="annotation-category category-' + c.value + '">' + c.label + '</span>' +
+      '</div>';
+    }).join('');
+
+    // Position near the badge
+    var rect = badge.getBoundingClientRect();
+    popup.style.position = 'fixed';
+    popup.style.left = rect.left + 'px';
+    popup.style.top = (rect.bottom + 4) + 'px';
+    popup.style.zIndex = '1000';
+
+    popup.addEventListener('click', async (e) => {
+      var opt = e.target.closest('.reclassify-option');
+      if (!opt) return;
+      e.stopPropagation();
+      var newCategory = opt.dataset.value;
+      if (newCategory === annotation.category) { popup.remove(); return; }
+      annotation.category = newCategory;
+      await api('/annotations/' + annotation.id, { method: 'PATCH', body: { content: annotation.content, category: newCategory } });
+      item.innerHTML = buildAnnotationItemHtml(annotation);
+      var row = item.closest('.annotation-row');
+      var lineElRef = row ? row.previousElementSibling : null;
+      bindAnnotationItemEvents(item, annotation, lineElRef, row);
+      popup.remove();
+    });
+
+    document.body.appendChild(popup);
+
+    // Close on outside click
+    var closePopup = function(e) {
+      if (!popup.contains(e.target)) {
+        popup.remove();
+        document.removeEventListener('click', closePopup, true);
+      }
+    };
+    setTimeout(function() {
+      document.addEventListener('click', closePopup, true);
+    }, 0);
+  }
+
+  function editAnnotation(item, annotation) {
+    var annotationRow = item.closest('.annotation-row');
+    var formContainer = document.createElement('div');
+    formContainer.className = 'annotation-form-container';
+    formContainer.innerHTML =
+      '<div class="annotation-form">' +
+        buildCategoryBadge(annotation.category) +
+        '<textarea>' + esc(annotation.content) + '</textarea>' +
+        '<div class="annotation-form-actions">' +
+          '<button class="btn btn-sm cancel-edit">Cancel</button>' +
+          '<button class="btn btn-sm btn-primary save-edit">Save</button>' +
+        '</div>' +
+      '</div>';
+
+    item.style.display = 'none';
+    annotationRow.parentNode.insertBefore(formContainer, annotationRow.nextSibling);
+
+    bindCategoryBadgeClick(formContainer);
+
+    function cancelEdit() {
+      item.style.display = '';
+      formContainer.remove();
+    }
+
+    formContainer.querySelector('.cancel-edit').addEventListener('click', (e) => {
+      e.stopPropagation();
+      cancelEdit();
+    });
+
+    formContainer.querySelector('.save-edit').addEventListener('click', async (e) => {
+      e.stopPropagation();
+      const content = formContainer.querySelector('textarea').value.trim();
+      const category = formContainer.querySelector('.form-category-badge').dataset.category;
+      if (!content) return;
+      annotation.content = content;
+      annotation.category = category;
+      await api('/annotations/' + annotation.id, { method: 'PATCH', body: { content, category } });
+      item.innerHTML = buildAnnotationItemHtml(annotation);
+      rebindAnnotationActions(item, annotation);
+      item.style.display = '';
+      formContainer.remove();
+    });
+
+    const textarea = formContainer.querySelector('textarea');
+    textarea.focus();
+    textarea.setSelectionRange(textarea.value.length, textarea.value.length);
+    textarea.addEventListener('keydown', (e) => {
+      if ((e.metaKey || e.ctrlKey) && e.key === 'Enter') {
+        formContainer.querySelector('.save-edit').click();
+      }
+      if (e.key === 'Escape') {
+        cancelEdit();
+      }
+    });
+  }
+
+  function rebindAnnotationActions(item, annotation) {
+    var row = item.closest('.annotation-row');
+    var lineEl = row ? row.previousElementSibling : null;
+    bindAnnotationItemEvents(item, annotation, lineEl, row);
+  }
+
+  // --- Drag & Drop for Annotations ---
+  function bindDragDrop() {
+    document.querySelectorAll('.diff-line').forEach(el => {
+      el.addEventListener('dragover', (e) => {
+        if (!state._dragAnnotation) return;
+        e.preventDefault();
+        e.dataTransfer.dropEffect = 'move';
+        document.querySelectorAll('.diff-line.drag-over').forEach(d => d.classList.remove('drag-over'));
+        el.classList.add('drag-over');
+      });
+
+      el.addEventListener('dragleave', () => {
+        el.classList.remove('drag-over');
+      });
+
+      el.addEventListener('drop', async (e) => {
+        e.preventDefault();
+        el.classList.remove('drag-over');
+        document.querySelectorAll('.diff-line.drag-over').forEach(d => d.classList.remove('drag-over'));
+        if (!state._dragAnnotation) return;
+
+        const lineNum = parseInt(el.dataset.line, 10);
+        const side = el.dataset.side || 'new';
+        if (isNaN(lineNum)) return;
+
+        const drag = state._dragAnnotation;
+        state._dragAnnotation = null;
+
+        await api('/annotations/' + drag.id + '/move', {
+          method: 'PATCH',
+          body: { lineNumber: lineNum, side: side },
+        });
+
+        // Refresh the file view
+        if (state.currentFileId) selectFile(state.currentFileId);
+      });
+    });
+  }
+
+  function bindServerAnnotations() {
+    document.querySelectorAll('.annotation-item').forEach(item => {
+      const id = item.dataset.annotationId;
+      if (!id) return;
+      const isStale = item.dataset.isStale === 'true';
+      const category = item.querySelector('.annotation-category')?.textContent || '';
+      const content = item.querySelector('.annotation-text')?.textContent || '';
+      const annotation = { id: id, category: category, content: content, is_stale: isStale };
+      var row = item.closest('.annotation-row');
+      var lineEl = row ? row.previousElementSibling : null;
+      bindAnnotationItemEvents(item, annotation, lineEl, row);
+    });
+  }
+
+  // --- Diff Mode ---
+  function bindDiffModeToggle() {
+    document.querySelectorAll('[data-diff-mode]').forEach(btn => {
+      btn.addEventListener('click', () => {
+        state.diffMode = btn.dataset.diffMode;
+        document.querySelectorAll('[data-diff-mode]').forEach(b => b.classList.toggle('active', b === btn));
+        if (state.currentFileId) selectFile(state.currentFileId);
+      });
+    });
+  }
+
+  // --- File Filter ---
+  function bindFileFilter() {
+    var input = document.getElementById('file-filter');
+    if (!input) return;
+    var timer = null;
+    input.addEventListener('input', function() {
+      clearTimeout(timer);
+      timer = setTimeout(function() {
+        state.filterText = input.value;
+        renderFileList();
+      }, 150);
+    });
+    // Also handle Escape to clear
+    input.addEventListener('keydown', function(e) {
+      if (e.key === 'Escape') {
+        input.value = '';
+        state.filterText = '';
+        renderFileList();
+        input.blur();
+      }
+    });
+  }
+
+  // --- Sidebar Resize ---
+  function bindSidebarResize() {
+    var handle = document.getElementById('sidebar-resize');
+    var sidebar = document.querySelector('.sidebar');
+    if (!handle || !sidebar) return;
+
+    var dragging = false;
+    var startX, startWidth;
+
+    handle.addEventListener('mousedown', function(e) {
+      dragging = true;
+      startX = e.clientX;
+      startWidth = sidebar.offsetWidth;
+      handle.classList.add('dragging');
+      document.body.style.cursor = 'col-resize';
+      document.body.style.userSelect = 'none';
+      e.preventDefault();
+    });
+
+    document.addEventListener('mousemove', function(e) {
+      if (!dragging) return;
+      var newWidth = startWidth + (e.clientX - startX);
+      newWidth = Math.max(200, Math.min(newWidth, window.innerWidth * 0.6));
+      sidebar.style.width = newWidth + 'px';
+    });
+
+    document.addEventListener('mouseup', function() {
+      if (!dragging) return;
+      dragging = false;
+      handle.classList.remove('dragging');
+      document.body.style.cursor = '';
+      document.body.style.userSelect = '';
+    });
+  }
+
+  // --- Wrap Toggle ---
+  function bindWrapToggle() {
+    const btn = document.getElementById('wrap-toggle');
+    if (!btn) return;
+    btn.addEventListener('click', () => {
+      state.wrapLines = !state.wrapLines;
+      btn.classList.toggle('active', state.wrapLines);
+      const container = document.getElementById('diff-container');
+      if (container) {
+        container.classList.toggle('wrap-lines', state.wrapLines);
+      }
+      // Reset scroll positions when toggling
+      if (!state.wrapLines) {
+        resetScrollSync();
+      }
+    });
+  }
+
+  // --- Scroll Sync (split mode, no-wrap) ---
+  function initScrollSync() {
+    const container = document.getElementById('diff-container');
+    if (!container) return;
+
+    let lastScrollLeft = 0;
+    let rafId = null;
+    let syncing = false;
+
+    container.addEventListener('scroll', function(e) {
+      if (syncing || state.wrapLines || state.diffMode !== 'split') return;
+      const target = e.target;
+      if (!target.classList || !target.classList.contains('code')) return;
+      if (!target.closest('.split-row')) return;
+
+      const scrollLeft = target.scrollLeft;
+      if (scrollLeft === lastScrollLeft) return;
+      lastScrollLeft = scrollLeft;
+
+      if (rafId) cancelAnimationFrame(rafId);
+      rafId = requestAnimationFrame(function() {
+        syncing = true;
+        container.querySelectorAll('.split-row .code').forEach(function(el) {
+          if (el !== target && el.scrollLeft !== scrollLeft) {
+            el.scrollLeft = scrollLeft;
+          }
+        });
+        syncing = false;
+      });
+    }, true);
+  }
+
+  function resetScrollSync() {
+    const container = document.getElementById('diff-container');
+    if (!container) return;
+    container.querySelectorAll('.split-row .code').forEach(function(el) {
+      el.scrollLeft = 0;
+    });
+  }
+
+  // --- Complete ---
+  function bindCompleteButton() {
+    const btn = document.getElementById('complete-review');
+    if (!btn) return;
+    btn.addEventListener('click', () => {
+      showCompleteModal();
+    });
+  }
+
+  function showCompleteModal() {
+    var totalStale = 0;
+    Object.keys(state.staleCounts).forEach(function(k) { totalStale += (state.staleCounts[k] || 0); });
+
+    const overlay = document.createElement('div');
+    overlay.className = 'modal-overlay';
+
+    if (totalStale > 0) {
+      overlay.innerHTML =
+        '<div class="modal">' +
+          '<h3>Stale Annotations</h3>' +
+          '<p>There ' + (totalStale === 1 ? 'is 1 stale annotation' : 'are ' + totalStale + ' stale annotations') +
+          ' that could not be matched to the current diff. What would you like to do?</p>' +
+          '<div class="modal-actions">' +
+            '<button class="btn btn-sm modal-cancel">Cancel</button>' +
+            '<button class="btn btn-sm btn-danger" data-stale-action="discard">Discard All Stale</button>' +
+            '<button class="btn btn-sm btn-primary" data-stale-action="keep">Keep All &amp; Complete</button>' +
+          '</div>' +
+        '</div>';
+
+      overlay.querySelector('.modal-cancel').addEventListener('click', () => overlay.remove());
+      overlay.querySelector('[data-stale-action="discard"]').addEventListener('click', async () => {
+        await api('/annotations/stale/delete-all', { method: 'POST' });
+        state.staleCounts = {};
+        renderFileList();
+        overlay.remove();
+        showCompleteModal();
+      });
+      overlay.querySelector('[data-stale-action="keep"]').addEventListener('click', async () => {
+        await api('/annotations/stale/keep-all', { method: 'POST' });
+        state.staleCounts = {};
+        renderFileList();
+        overlay.remove();
+        showCompleteModal();
+      });
+
+      overlay.addEventListener('click', (e) => { if (e.target === overlay) overlay.remove(); });
+      document.body.appendChild(overlay);
+      return;
+    }
+
+    overlay.innerHTML =
+      '<div class="modal">' +
+        '<h3>Complete Review</h3>' +
+        '<p>This will generate a review summary that AI tools can read and act on. Annotations will be exported to .glassbox/ in the repository.</p>' +
+        '<div class="modal-actions">' +
+          '<button class="btn btn-sm modal-cancel">Cancel</button>' +
+          '<button class="btn btn-sm btn-primary modal-confirm">Complete</button>' +
+        '</div>' +
+      '</div>';
+
+    overlay.querySelector('.modal-cancel').addEventListener('click', () => overlay.remove());
+    overlay.querySelector('.modal-confirm').addEventListener('click', async () => {
+      const result = await api('/review/complete', { method: 'POST' });
+      var aiCommand = result.isCurrent
+        ? 'Read .glassbox/latest-review.md and apply the feedback.'
+        : 'Read .glassbox/review-' + result.reviewId + '.md and apply the feedback.';
+
+      var gitignoreHtml = '';
+      if (result.gitignorePrompt) {
+        gitignoreHtml =
+          '<div class="modal-gitignore">' +
+            '<p class="modal-label">.glassbox/ is not in your .gitignore</p>' +
+            '<div class="modal-actions" style="justify-content:flex-start;margin-top:4px">' +
+              '<button class="btn btn-sm btn-primary" id="gitignore-add">Add to .gitignore</button>' +
+              '<button class="btn btn-sm" id="gitignore-dismiss">Don\\'t ask for 30 days</button>' +
+            '</div>' +
+          '</div>';
+      }
+
+      overlay.querySelector('.modal').innerHTML =
+        '<h3>Review Completed</h3>' +
+        '<p class="modal-label">Review exported to:</p>' +
+        '<div class="modal-copyable" data-copy="' + esc(result.exportPath) + '" title="Click to copy">' + esc(result.exportPath) + '</div>' +
+        '<p class="modal-label">Tell your AI tool:</p>' +
+        '<div class="modal-copyable" data-copy="' + esc(aiCommand) + '" title="Click to copy">' + esc(aiCommand) + '</div>' +
+        gitignoreHtml +
+        '<div class="modal-actions"><button class="btn btn-sm btn-primary" onclick="this.closest(\\'.modal-overlay\\').remove()">Done</button></div>';
+
+      // Bind copy-to-clipboard
+      overlay.querySelectorAll('.modal-copyable').forEach(function(el) {
+        el.addEventListener('click', function() {
+          navigator.clipboard.writeText(el.dataset.copy);
+          el.classList.add('copied');
+          setTimeout(function() { el.classList.remove('copied'); }, 1500);
+        });
+      });
+
+      // Bind gitignore buttons
+      var addBtn = overlay.querySelector('#gitignore-add');
+      if (addBtn) {
+        addBtn.addEventListener('click', async function() {
+          await api('/gitignore/add', { method: 'POST' });
+          var container = addBtn.closest('.modal-gitignore');
+          container.innerHTML = '<p class="modal-label" style="color:var(--green)">Added .glassbox/ to .gitignore</p>';
+        });
+      }
+      var dismissBtn = overlay.querySelector('#gitignore-dismiss');
+      if (dismissBtn) {
+        dismissBtn.addEventListener('click', async function() {
+          await api('/gitignore/dismiss', { method: 'POST' });
+          dismissBtn.closest('.modal-gitignore').remove();
+        });
+      }
+
+      // Swap complete button to reopen
+      const completeBtn = document.getElementById('complete-review');
+      if (completeBtn) {
+        const reopenBtn = document.createElement('button');
+        reopenBtn.className = 'btn btn-primary';
+        reopenBtn.id = 'reopen-review';
+        reopenBtn.textContent = 'Reopen Review';
+        completeBtn.replaceWith(reopenBtn);
+        bindReopenButton();
+      }
+    });
+
+    overlay.addEventListener('click', (e) => { if (e.target === overlay) overlay.remove(); });
+    document.body.appendChild(overlay);
+  }
+
+  function bindReopenButton() {
+    const btn = document.getElementById('reopen-review');
+    if (!btn) return;
+    btn.addEventListener('click', async () => {
+      await api('/review/reopen', { method: 'POST' });
+      // Swap reopen button to complete
+      const completeBtn = document.createElement('button');
+      completeBtn.className = 'btn btn-primary btn-complete';
+      completeBtn.id = 'complete-review';
+      completeBtn.textContent = 'Complete Review';
+      btn.replaceWith(completeBtn);
+      bindCompleteButton();
+    });
+  }
+
+  // --- Progress ---
+  function updateProgress() {
+    const total = state.files.length;
+    const reviewed = state.files.filter(f => f.status === 'reviewed').length;
+    const summary = document.getElementById('progress-summary');
+    if (summary) summary.textContent = reviewed + ' of ' + total + ' files reviewed';
+
+    // Update progress bar
+    let bar = document.querySelector('.progress-bar');
+    if (!bar) {
+      bar = document.createElement('div');
+      bar.className = 'progress-bar';
+      bar.innerHTML = '<div class="progress-bar-fill"></div>';
+      const controls = document.querySelector('.sidebar-controls');
+      if (controls) controls.appendChild(bar);
+    }
+    const fill = bar.querySelector('.progress-bar-fill');
+    if (fill) fill.style.width = (total ? (reviewed / total * 100) : 0) + '%';
+  }
+
+  // --- Sidebar Events ---
+  function bindSidebarEvents() {
+    // Keyboard navigation
+    document.addEventListener('keydown', (e) => {
+      if (e.target.tagName === 'TEXTAREA' || e.target.tagName === 'INPUT') return;
+      if (e.key === 'j' || e.key === 'ArrowDown') {
+        navigateFile(1);
+        e.preventDefault();
+      } else if (e.key === 'k' || e.key === 'ArrowUp') {
+        navigateFile(-1);
+        e.preventDefault();
+      }
+    });
+  }
+
+  function navigateFile(delta) {
+    var order = state.fileOrder;
+    var idx = order.indexOf(state.currentFileId);
+    var next = idx + delta;
+    if (next >= 0 && next < order.length) {
+      selectFile(order[next]);
+    }
+  }
+
+  // Run
+  init();
+})();
+`;
+}
+
+// src/components/fileList.tsx
+function buildFileTree(files) {
+  const root = { name: "", children: [], files: [] };
+  for (const f of files) {
+    const parts = f.file_path.split("/");
+    let node = root;
+    for (let i = 0; i < parts.length - 1; i++) {
+      let child = node.children.find((c) => c.name === parts[i]);
+      if (!child) {
+        child = { name: parts[i], children: [], files: [] };
+        node.children.push(child);
+      }
+      node = child;
+    }
+    node.files.push(f);
+  }
+  compressTree(root);
+  return root;
+}
+function compressTree(node) {
+  for (let i = 0; i < node.children.length; i++) {
+    let child = node.children[i];
+    while (child.children.length === 1 && child.files.length === 0) {
+      const grandchild = child.children[0];
+      child = { name: child.name + "/" + grandchild.name, children: grandchild.children, files: grandchild.files };
+      node.children[i] = child;
+    }
+    compressTree(child);
+  }
+}
+function countFiles(node) {
+  let count = node.files.length;
+  for (const child of node.children) count += countFiles(child);
+  return count;
+}
+function hasStale(node, staleCounts) {
+  for (const f of node.files) {
+    if (staleCounts[f.id]) return true;
+  }
+  for (const child of node.children) {
+    if (hasStale(child, staleCounts)) return true;
+  }
+  return false;
+}
+function TreeView({ node, depth, annotationCounts, staleCounts }) {
+  const sortedChildren = [...node.children].sort((a, b) => a.name.localeCompare(b.name));
+  return /* @__PURE__ */ jsx("div", { children: [
+    sortedChildren.map((child) => {
+      const total = countFiles(child);
+      const isCollapsible = total > 1;
+      const stale = hasStale(child, staleCounts);
+      return /* @__PURE__ */ jsx("div", { className: "folder-group", children: [
+        /* @__PURE__ */ jsx("div", { className: `folder-header${isCollapsible ? " collapsible" : ""}`, style: `padding-left:${16 + depth * 12}px`, children: [
+          isCollapsible ? /* @__PURE__ */ jsx("span", { className: "folder-arrow", children: "\u25BE" }) : /* @__PURE__ */ jsx("span", { className: "folder-arrow-spacer" }),
+          /* @__PURE__ */ jsx("span", { className: "folder-name", children: [
+            child.name,
+            "/"
+          ] }),
+          stale ? /* @__PURE__ */ jsx("span", { className: "stale-dot" }) : null
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "folder-content", children: /* @__PURE__ */ jsx(TreeView, { node: child, depth: depth + 1, annotationCounts, staleCounts }) })
+      ] });
+    }),
+    node.files.map((f) => {
+      const diff = JSON.parse(f.diff_data || "{}");
+      const count = annotationCounts[f.id] || 0;
+      const stale = staleCounts[f.id] || 0;
+      const fileName = f.file_path.split("/").pop();
+      return /* @__PURE__ */ jsx("div", { className: "file-item", "data-file-id": f.id, style: `padding-left:${16 + depth * 12}px`, children: [
+        /* @__PURE__ */ jsx("span", { className: `status-dot ${f.status}` }),
+        /* @__PURE__ */ jsx("span", { className: "file-name", title: f.file_path, children: fileName }),
+        /* @__PURE__ */ jsx("span", { className: `file-status ${diff.status || ""}`, children: diff.status || "" }),
+        stale > 0 ? /* @__PURE__ */ jsx("span", { className: "stale-dot" }) : null,
+        count > 0 ? /* @__PURE__ */ jsx("span", { className: "annotation-count", children: count }) : null
+      ] });
+    })
+  ] });
+}
+function FileList({ files, annotationCounts, staleCounts }) {
+  const tree = buildFileTree(files);
+  return /* @__PURE__ */ jsx("div", { className: "file-list", children: /* @__PURE__ */ jsx("div", { className: "file-list-items", children: /* @__PURE__ */ jsx(TreeView, { node: tree, depth: 0, annotationCounts, staleCounts }) }) });
+}
+
+// src/components/diffView.tsx
+function DiffView({ file, diff, annotations, mode }) {
+  const annotationsByLine = {};
+  for (const a of annotations) {
+    const key = `${a.line_number}:${a.side}`;
+    if (!annotationsByLine[key]) annotationsByLine[key] = [];
+    annotationsByLine[key].push(a);
+  }
+  return /* @__PURE__ */ jsx("div", { className: "diff-view", "data-file-id": file.id, "data-file-path": file.file_path, children: [
+    /* @__PURE__ */ jsx("div", { className: "diff-header", children: [
+      /* @__PURE__ */ jsx("span", { className: "file-path", children: diff.filePath }),
+      /* @__PURE__ */ jsx("div", { className: "diff-header-actions", children: /* @__PURE__ */ jsx("span", { className: `file-status ${diff.status}`, children: diff.status }) })
+    ] }),
+    diff.isBinary ? /* @__PURE__ */ jsx("div", { className: "hunk-separator", children: "Binary file" }) : diff.status === "added" || diff.status === "deleted" || mode === "unified" ? /* @__PURE__ */ jsx(UnifiedDiff, { hunks: diff.hunks, annotationsByLine }) : /* @__PURE__ */ jsx(SplitDiff, { hunks: diff.hunks, annotationsByLine })
+  ] });
+}
+function SplitDiff({ hunks, annotationsByLine }) {
+  return /* @__PURE__ */ jsx("div", { className: "diff-table-split", children: hunks.map((hunk, hunkIdx) => {
+    const pairs = pairLines(hunk.lines);
+    return /* @__PURE__ */ jsx("div", { className: "hunk-block", children: [
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: "hunk-separator",
+          "data-hunk-idx": hunkIdx,
+          "data-old-start": hunk.oldStart,
+          "data-old-count": hunk.oldCount,
+          "data-new-start": hunk.newStart,
+          "data-new-count": hunk.newCount,
+          children: [
+            "@@ -",
+            hunk.oldStart,
+            ",",
+            hunk.oldCount,
+            " +",
+            hunk.newStart,
+            ",",
+            hunk.newCount,
+            " @@"
+          ]
+        }
+      ),
+      pairs.map((pair) => {
+        const leftAnns = pair.left ? annotationsByLine[`${pair.left.oldNum}:old`] || [] : [];
+        const rightAnns = pair.right ? annotationsByLine[`${pair.right.newNum}:new`] || [] : [];
+        const allAnns = [...leftAnns, ...rightAnns];
+        return /* @__PURE__ */ jsx("div", { children: [
+          /* @__PURE__ */ jsx("div", { className: "split-row", children: [
+            /* @__PURE__ */ jsx(
+              "div",
+              {
+                className: `diff-line split-left ${pair.left?.type || "empty"}`,
+                "data-line": pair.left?.oldNum ?? "",
+                "data-side": "old",
+                children: [
+                  /* @__PURE__ */ jsx("span", { className: "gutter", children: pair.left?.oldNum ?? "" }),
+                  /* @__PURE__ */ jsx("span", { className: "code", children: pair.left ? raw(escapeHtml(pair.left.content)) : "" })
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              "div",
+              {
+                className: `diff-line split-right ${pair.right?.type || "empty"}`,
+                "data-line": pair.right?.newNum ?? "",
+                "data-side": "new",
+                children: [
+                  /* @__PURE__ */ jsx("span", { className: "gutter", children: pair.right?.newNum ?? "" }),
+                  /* @__PURE__ */ jsx("span", { className: "code", children: pair.right ? raw(escapeHtml(pair.right.content)) : "" })
+                ]
+              }
+            )
+          ] }),
+          allAnns.length > 0 ? /* @__PURE__ */ jsx(AnnotationRows, { annotations: allAnns }) : null
+        ] });
+      })
+    ] });
+  }) });
+}
+function pairLines(lines) {
+  const pairs = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.type === "context") {
+      pairs.push({ left: line, right: line });
+      i++;
+    } else if (line.type === "remove") {
+      const removes = [];
+      while (i < lines.length && lines[i].type === "remove") {
+        removes.push(lines[i]);
+        i++;
+      }
+      const adds = [];
+      while (i < lines.length && lines[i].type === "add") {
+        adds.push(lines[i]);
+        i++;
+      }
+      const max = Math.max(removes.length, adds.length);
+      for (let j = 0; j < max; j++) {
+        pairs.push({
+          left: j < removes.length ? removes[j] : null,
+          right: j < adds.length ? adds[j] : null
+        });
+      }
+    } else if (line.type === "add") {
+      pairs.push({ left: null, right: line });
+      i++;
+    } else {
+      i++;
+    }
+  }
+  return pairs;
+}
+function UnifiedDiff({ hunks, annotationsByLine }) {
+  return /* @__PURE__ */ jsx("div", { className: "diff-table-unified", children: hunks.map((hunk, hunkIdx) => /* @__PURE__ */ jsx("div", { className: "hunk-block", children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "hunk-separator",
+        "data-hunk-idx": hunkIdx,
+        "data-old-start": hunk.oldStart,
+        "data-old-count": hunk.oldCount,
+        "data-new-start": hunk.newStart,
+        "data-new-count": hunk.newCount,
+        children: [
+          "@@ -",
+          hunk.oldStart,
+          ",",
+          hunk.oldCount,
+          " +",
+          hunk.newStart,
+          ",",
+          hunk.newCount,
+          " @@"
+        ]
+      }
+    ),
+    hunk.lines.map((line) => {
+      const lineNum = line.type === "remove" ? line.oldNum : line.newNum;
+      const side = line.type === "remove" ? "old" : "new";
+      const anns = annotationsByLine[`${lineNum}:${side}`] || [];
+      return /* @__PURE__ */ jsx("div", { children: [
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: `diff-line ${line.type}${anns.length ? " has-annotation" : ""}`,
+            "data-line": lineNum,
+            "data-side": side,
+            children: [
+              /* @__PURE__ */ jsx("span", { className: "gutter-old", children: line.oldNum ?? "" }),
+              /* @__PURE__ */ jsx("span", { className: "gutter-new", children: line.newNum ?? "" }),
+              /* @__PURE__ */ jsx("span", { className: "code", children: raw(escapeHtml(line.content)) })
+            ]
+          }
+        ),
+        anns.length > 0 ? /* @__PURE__ */ jsx(AnnotationRows, { annotations: anns }) : null
+      ] });
+    })
+  ] })) });
+}
+function AnnotationRows({ annotations }) {
+  return /* @__PURE__ */ jsx("div", { className: "annotation-row", children: annotations.map((a) => /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: `annotation-item${a.is_stale ? " annotation-stale" : ""}`,
+      "data-annotation-id": a.id,
+      "data-is-stale": a.is_stale ? "true" : void 0,
+      children: [
+        /* @__PURE__ */ jsx("span", { className: "annotation-drag-handle", draggable: "true", title: "Drag to move", children: "\u283F" }),
+        /* @__PURE__ */ jsx("span", { className: `annotation-category category-${a.category}`, "data-action": "reclassify", children: a.category }),
+        /* @__PURE__ */ jsx("span", { className: "annotation-text", children: a.content }),
+        /* @__PURE__ */ jsx("div", { className: "annotation-actions", children: [
+          a.is_stale ? /* @__PURE__ */ jsx("button", { className: "btn btn-xs btn-keep", "data-action": "keep", children: "Keep" }) : null,
+          /* @__PURE__ */ jsx("button", { className: "btn btn-xs btn-icon", "data-action": "edit", title: "Edit", children: raw('<svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17 3a2.85 2.85 0 1 1 4 4L7.5 20.5 2 22l1.5-5.5Z"/><path d="m15 5 4 4"/></svg>') }),
+          /* @__PURE__ */ jsx("button", { className: "btn btn-xs btn-icon btn-danger", "data-action": "delete", title: "Delete", children: raw('<svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M3 6h18"/><path d="M19 6v14c0 1-1 2-2 2H7c-1 0-2-1-2-2V6"/><path d="M8 6V4c0-1 1-2 2-2h4c1 0 2 1 2 2v2"/><line x1="10" y1="11" x2="10" y2="17"/><line x1="14" y1="11" x2="14" y2="17"/></svg>') })
+        ] })
+      ]
+    }
+  )) });
+}
+
+// src/components/reviewHistory.tsx
+function titleCase(s) {
+  return s.replace(/[_-]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+var trashIcon = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M3 6h18"/><path d="M19 6v14c0 1-1 2-2 2H7c-1 0-2-1-2-2V6"/><path d="M8 6V4c0-1 1-2 2-2h4c1 0 2 1 2 2v2"/><line x1="10" y1="11" x2="10" y2="17"/><line x1="14" y1="11" x2="14" y2="17"/></svg>';
+function shortenArgs(args) {
+  const shaPattern = /\b([0-9a-f]{7,40})\b/gi;
+  let hasLong = false;
+  const short = args.replace(shaPattern, (match) => {
+    if (match.length > 8) {
+      hasLong = true;
+      return match.slice(0, 7);
+    }
+    return match;
+  });
+  return { short, full: hasLong ? args : "" };
+}
+function ReviewHistory({ reviews, currentReviewId }) {
+  const hasOtherReviews = reviews.some((r) => r.id !== currentReviewId);
+  const hasCompletedOthers = reviews.some((r) => r.id !== currentReviewId && r.status === "completed");
+  return /* @__PURE__ */ jsx("div", { className: "history-page", children: [
+    /* @__PURE__ */ jsx("h1", { children: "Review History" }),
+    reviews.length === 0 ? /* @__PURE__ */ jsx("p", { style: "color:var(--text-dim)", children: "No previous reviews found." }) : /* @__PURE__ */ jsx("div", { children: reviews.map((r) => {
+      const isCurrent = r.id === currentReviewId;
+      const href = isCurrent ? "/" : `/review/${r.id}`;
+      let argsDisplay = null;
+      if (r.mode_args) {
+        const { short, full } = shortenArgs(r.mode_args);
+        argsDisplay = full ? /* @__PURE__ */ jsx("span", { title: full, children: [
+          ": ",
+          short
+        ] }) : /* @__PURE__ */ jsx("span", { children: [
+          ": ",
+          short
+        ] });
+      }
+      return /* @__PURE__ */ jsx("div", { children: [
+        /* @__PURE__ */ jsx("a", { href, className: "history-item-link", children: /* @__PURE__ */ jsx("div", { className: "history-item", "data-review-id": r.id, children: [
+          /* @__PURE__ */ jsx("h3", { children: [
+            r.repo_name,
+            " - ",
+            titleCase(r.mode),
+            argsDisplay,
+            isCurrent ? /* @__PURE__ */ jsx("span", { className: "status-badge in_progress", style: "margin-left:8px", children: "Current" }) : null,
+            /* @__PURE__ */ jsx("span", { className: `status-badge ${r.status}`, style: "margin-left:8px", children: titleCase(r.status) })
+          ] }),
+          /* @__PURE__ */ jsx("div", { className: "meta", children: [
+            "ID: ",
+            r.id,
+            " | Created: ",
+            r.created_at
+          ] }),
+          !isCurrent ? /* @__PURE__ */ jsx("button", { className: "delete-review-btn", "data-delete-id": r.id, title: "Delete review", children: raw(trashIcon) }) : null
+        ] }) }),
+        isCurrent && hasOtherReviews ? /* @__PURE__ */ jsx("div", { className: "bulk-actions", children: [
+          /* @__PURE__ */ jsx("span", { children: "Bulk actions:" }),
+          hasCompletedOthers ? /* @__PURE__ */ jsx("button", { className: "btn btn-sm btn-danger", id: "delete-completed-btn", children: "Delete Completed" }) : null,
+          /* @__PURE__ */ jsx("button", { className: "btn btn-sm btn-danger", id: "delete-all-btn", children: "Delete All" })
+        ] }) : null
+      ] });
+    }) }),
+    /* @__PURE__ */ jsx("a", { href: "/", className: "btn btn-link", style: "margin-top:16px;display:inline-block", children: "Back to current review" }),
+    /* @__PURE__ */ jsx("script", { children: raw(getHistoryScript()) })
+  ] });
+}
+function getHistoryScript() {
+  return `
+(function() {
+  function esc(s) {
+    var d = document.createElement('div');
+    d.textContent = s;
+    return d.innerHTML;
+  }
+
+  function updateBulkVisibility() {
+    var bulk = document.querySelector('.bulk-actions');
+    if (bulk && !document.querySelector('.delete-review-btn')) {
+      bulk.remove();
+    }
+  }
+
+  // Single review delete
+  document.querySelectorAll('.delete-review-btn').forEach(function(btn) {
+    btn.addEventListener('click', function(e) {
+      e.preventDefault();
+      e.stopPropagation();
+      var id = btn.dataset.deleteId;
+      showConfirm('Delete this review? This cannot be undone.', function() {
+        fetch('/api/review/' + encodeURIComponent(id), { method: 'DELETE' })
+          .then(function(r) { return r.json(); })
+          .then(function() {
+            btn.closest('.history-item-link').parentElement.remove();
+            updateBulkVisibility();
+          });
+      });
+    });
+  });
+
+  // Bulk delete completed
+  var delCompletedBtn = document.getElementById('delete-completed-btn');
+  if (delCompletedBtn) {
+    delCompletedBtn.addEventListener('click', function() {
+      showConfirm('Delete all completed reviews (except current)? This cannot be undone.', function() {
+        fetch('/api/reviews/delete-completed', { method: 'POST', headers: { 'Content-Type': 'application/json' } })
+          .then(function(r) { return r.json(); })
+          .then(function() { location.reload(); });
+      });
+    });
+  }
+
+  // Bulk delete all
+  var delAllBtn = document.getElementById('delete-all-btn');
+  if (delAllBtn) {
+    delAllBtn.addEventListener('click', function() {
+      showConfirm('Delete ALL reviews except the current one? This cannot be undone.', function() {
+        fetch('/api/reviews/delete-all', { method: 'POST', headers: { 'Content-Type': 'application/json' } })
+          .then(function(r) { return r.json(); })
+          .then(function() { location.reload(); });
+      });
+    });
+  }
+
+  function showConfirm(message, onConfirm) {
+    var overlay = document.createElement('div');
+    overlay.className = 'modal-overlay';
+    overlay.innerHTML =
+      '<div class="modal">' +
+        '<h3>Confirm</h3>' +
+        '<p>' + esc(message) + '</p>' +
+        '<div class="modal-actions">' +
+          '<button class="btn btn-sm modal-cancel">Cancel</button>' +
+          '<button class="btn btn-sm btn-danger modal-confirm">Delete</button>' +
+        '</div>' +
+      '</div>';
+    overlay.querySelector('.modal-cancel').addEventListener('click', function() { overlay.remove(); });
+    overlay.querySelector('.modal-confirm').addEventListener('click', function() { overlay.remove(); onConfirm(); });
+    overlay.addEventListener('click', function(e) { if (e.target === overlay) overlay.remove(); });
+    document.body.appendChild(overlay);
+  }
+})();
+`;
+}
+
+// src/routes/pages.tsx
+var pageRoutes = new Hono2();
+pageRoutes.get("/", async (c) => {
+  const reviewId = c.get("reviewId");
+  const review = await getReview(reviewId);
+  if (!review) return c.text("Review not found", 404);
+  const files = await getReviewFiles(reviewId);
+  const annotationCounts = {};
+  for (const f of files) {
+    const anns = await getAnnotationsForFile(f.id);
+    annotationCounts[f.id] = anns.length;
+  }
+  const html = /* @__PURE__ */ jsx(Layout, { title: `Glassbox - ${review.repo_name}`, reviewId, children: /* @__PURE__ */ jsx("div", { className: "review-app", "data-review-id": reviewId, children: [
+    /* @__PURE__ */ jsx("aside", { className: "sidebar", children: [
+      /* @__PURE__ */ jsx("div", { className: "sidebar-header", children: [
+        /* @__PURE__ */ jsx("h2", { children: review.repo_name }),
+        /* @__PURE__ */ jsx("span", { className: "review-mode", children: [
+          review.mode,
+          review.mode_args ? `: ${review.mode_args}` : ""
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx("div", { className: "sidebar-controls", children: /* @__PURE__ */ jsx("div", { className: "sidebar-controls-row", children: [
+        /* @__PURE__ */ jsx("div", { className: "diff-mode-toggle", children: [
+          /* @__PURE__ */ jsx("button", { className: "btn btn-sm active", "data-diff-mode": "split", children: "Split" }),
+          /* @__PURE__ */ jsx("button", { className: "btn btn-sm", "data-diff-mode": "unified", children: "Unified" })
+        ] }),
+        /* @__PURE__ */ jsx("span", { className: "controls-divider" }),
+        /* @__PURE__ */ jsx("button", { className: "btn btn-sm", id: "wrap-toggle", children: "Wrap" })
+      ] }) }),
+      /* @__PURE__ */ jsx("div", { className: "file-filter", children: /* @__PURE__ */ jsx("input", { type: "text", className: "file-filter-input", id: "file-filter", placeholder: "Filter files..." }) }),
+      /* @__PURE__ */ jsx(FileList, { files, annotationCounts, staleCounts: {} }),
+      /* @__PURE__ */ jsx("div", { className: "sidebar-footer", children: [
+        /* @__PURE__ */ jsx("button", { className: "btn btn-primary btn-complete", id: "complete-review", children: "Complete Review" }),
+        /* @__PURE__ */ jsx("a", { href: "/history", className: "btn btn-sm btn-link", children: "Review History" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "sidebar-resize", id: "sidebar-resize" }),
+    /* @__PURE__ */ jsx("main", { className: "main-content", children: [
+      /* @__PURE__ */ jsx("div", { className: "welcome-message", children: [
+        /* @__PURE__ */ jsx("h3", { children: "Select a file to begin reviewing" }),
+        /* @__PURE__ */ jsx("p", { children: [
+          files.length,
+          " file(s) to review"
+        ] }),
+        /* @__PURE__ */ jsx("p", { className: "progress-summary", id: "progress-summary" })
+      ] }),
+      /* @__PURE__ */ jsx("div", { className: "diff-container", id: "diff-container", style: "display:none" })
+    ] })
+  ] }) });
+  return c.html(html.toString());
+});
+pageRoutes.get("/file/:fileId", async (c) => {
+  const fileId = c.req.param("fileId");
+  const mode = c.req.query("mode") === "unified" ? "unified" : "split";
+  const file = await getReviewFile(fileId);
+  if (!file) return c.text("File not found", 404);
+  const annotations = await getAnnotationsForFile(fileId);
+  const diff = JSON.parse(file.diff_data || "{}");
+  const html = /* @__PURE__ */ jsx(DiffView, { file, diff, annotations, mode });
+  return c.html(html.toString());
+});
+pageRoutes.get("/review/:reviewId", async (c) => {
+  const reviewId = c.req.param("reviewId");
+  const currentReviewId = c.get("reviewId");
+  if (reviewId === currentReviewId) {
+    return c.redirect("/");
+  }
+  const review = await getReview(reviewId);
+  if (!review) return c.text("Review not found", 404);
+  const files = await getReviewFiles(reviewId);
+  const annotationCounts = {};
+  for (const f of files) {
+    const anns = await getAnnotationsForFile(f.id);
+    annotationCounts[f.id] = anns.length;
+  }
+  const html = /* @__PURE__ */ jsx(Layout, { title: `Glassbox - ${review.repo_name}`, reviewId, children: /* @__PURE__ */ jsx("div", { className: "review-app", "data-review-id": reviewId, children: [
+    /* @__PURE__ */ jsx("aside", { className: "sidebar", children: [
+      /* @__PURE__ */ jsx("div", { className: "sidebar-header", children: [
+        /* @__PURE__ */ jsx("h2", { children: review.repo_name }),
+        /* @__PURE__ */ jsx("span", { className: "review-mode", children: [
+          review.mode,
+          review.mode_args ? `: ${review.mode_args}` : ""
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx("div", { className: "sidebar-controls", children: /* @__PURE__ */ jsx("div", { className: "sidebar-controls-row", children: [
+        /* @__PURE__ */ jsx("div", { className: "diff-mode-toggle", children: [
+          /* @__PURE__ */ jsx("button", { className: "btn btn-sm active", "data-diff-mode": "split", children: "Split" }),
+          /* @__PURE__ */ jsx("button", { className: "btn btn-sm", "data-diff-mode": "unified", children: "Unified" })
+        ] }),
+        /* @__PURE__ */ jsx("span", { className: "controls-divider" }),
+        /* @__PURE__ */ jsx("button", { className: "btn btn-sm", id: "wrap-toggle", children: "Wrap" })
+      ] }) }),
+      /* @__PURE__ */ jsx("div", { className: "file-filter", children: /* @__PURE__ */ jsx("input", { type: "text", className: "file-filter-input", id: "file-filter", placeholder: "Filter files..." }) }),
+      /* @__PURE__ */ jsx(FileList, { files, annotationCounts, staleCounts: {} }),
+      /* @__PURE__ */ jsx("div", { className: "sidebar-footer", children: [
+        review.status === "completed" ? /* @__PURE__ */ jsx("button", { className: "btn btn-primary", id: "reopen-review", children: "Reopen Review" }) : /* @__PURE__ */ jsx("button", { className: "btn btn-primary btn-complete", id: "complete-review", children: "Complete Review" }),
+        /* @__PURE__ */ jsx("a", { href: "/history", className: "btn btn-sm btn-link", children: "Review History" }),
+        /* @__PURE__ */ jsx("a", { href: "/", className: "btn btn-sm btn-link", children: "Back to current review" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "sidebar-resize", id: "sidebar-resize" }),
+    /* @__PURE__ */ jsx("main", { className: "main-content", children: [
+      /* @__PURE__ */ jsx("div", { className: "welcome-message", children: [
+        /* @__PURE__ */ jsx("h3", { children: "Select a file to begin reviewing" }),
+        /* @__PURE__ */ jsx("p", { children: [
+          files.length,
+          " file(s) to review"
+        ] }),
+        /* @__PURE__ */ jsx("p", { className: "progress-summary", id: "progress-summary" })
+      ] }),
+      /* @__PURE__ */ jsx("div", { className: "diff-container", id: "diff-container", style: "display:none" })
+    ] })
+  ] }) });
+  return c.html(html.toString());
+});
+pageRoutes.get("/history", async (c) => {
+  const repoRoot = c.get("repoRoot");
+  const currentReviewId = c.get("reviewId");
+  const reviews = await listReviews(repoRoot);
+  const html = /* @__PURE__ */ jsx(Layout, { title: "Review History", reviewId: "", children: /* @__PURE__ */ jsx(ReviewHistory, { reviews, currentReviewId }) });
+  return c.html(html.toString());
+});
+
+// src/server.ts
+function tryServe(fetch, port) {
+  return new Promise((resolve2, reject) => {
+    const server = serve({ fetch, port });
+    server.on("listening", () => resolve2(port));
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        reject(err);
+      } else {
+        reject(err);
+      }
+    });
+  });
+}
+async function startServer(port, reviewId, repoRoot) {
+  const app = new Hono3();
+  app.use("*", async (c, next) => {
+    c.set("reviewId", reviewId);
+    c.set("currentReviewId", reviewId);
+    c.set("repoRoot", repoRoot);
+    await next();
+  });
+  app.route("/api", apiRoutes);
+  app.route("/", pageRoutes);
+  let actualPort = port;
+  for (let attempt = 0; attempt < 20; attempt++) {
+    try {
+      actualPort = await tryServe(app.fetch, port + attempt);
+      break;
+    } catch (err) {
+      if (err.code === "EADDRINUSE" && attempt < 19) {
+        continue;
+      }
+      throw err;
+    }
+  }
+  if (actualPort !== port) {
+    console.log(`  Port ${port} in use, using ${actualPort} instead.`);
+  }
+  const url = `http://localhost:${actualPort}`;
+  console.log(`
+  Glassbox running at ${url}
+`);
+  const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  exec(`${openCmd} ${url}`);
+}
+
+// src/update-check.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync2 } from "fs";
+import { join as join3, dirname } from "path";
+import { homedir as homedir3 } from "os";
+import { get } from "https";
+import { fileURLToPath } from "url";
+var DATA_DIR = join3(homedir3(), ".glassbox");
+var CHECK_FILE = join3(DATA_DIR, "last-update-check");
+var PACKAGE_NAME = "glassbox";
+function getCurrentVersion() {
+  try {
+    const dir = dirname(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(readFileSync3(join3(dir, "..", "package.json"), "utf-8"));
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+function getLastCheckDate() {
+  try {
+    if (existsSync2(CHECK_FILE)) {
+      return readFileSync3(CHECK_FILE, "utf-8").trim();
+    }
+  } catch {
+  }
+  return null;
+}
+function saveCheckDate() {
+  mkdirSync3(DATA_DIR, { recursive: true });
+  writeFileSync2(CHECK_FILE, (/* @__PURE__ */ new Date()).toISOString().slice(0, 10), "utf-8");
+}
+function isFirstUseToday() {
+  const last = getLastCheckDate();
+  if (!last) return true;
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return last !== today;
+}
+function fetchLatestVersion() {
+  return new Promise((resolve2) => {
+    const req = get(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, { timeout: 5e3 }, (res) => {
+      if (res.statusCode !== 200) {
+        resolve2(null);
+        return;
+      }
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      res.on("end", () => {
+        try {
+          resolve2(JSON.parse(data).version);
+        } catch {
+          resolve2(null);
+        }
+      });
+    });
+    req.on("error", () => resolve2(null));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve2(null);
+    });
+  });
+}
+function detectUpgradeCommand() {
+  const binPath = process.argv[1] || "";
+  if (binPath.includes("/.bun/") || binPath.includes("/bun/")) {
+    return `bun update -g ${PACKAGE_NAME}`;
+  }
+  if (binPath.includes("/.pnpm/") || binPath.includes("/pnpm/")) {
+    return `pnpm update -g ${PACKAGE_NAME}`;
+  }
+  if (binPath.includes("/.yarn/") || binPath.includes("/yarn/")) {
+    return `yarn global upgrade ${PACKAGE_NAME}`;
+  }
+  return `npm update -g ${PACKAGE_NAME}`;
+}
+function compareVersions(current, latest) {
+  const a = current.split(".").map(Number);
+  const b = latest.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((a[i] || 0) < (b[i] || 0)) return -1;
+    if ((a[i] || 0) > (b[i] || 0)) return 1;
+  }
+  return 0;
+}
+async function checkForUpdates(force) {
+  if (!force && !isFirstUseToday()) return;
+  const current = getCurrentVersion();
+  const latest = await fetchLatestVersion();
+  saveCheckDate();
+  if (!latest || compareVersions(current, latest) >= 0) return;
+  const cmd = detectUpgradeCommand();
+  const updateLine = `Update available: ${current} \u2192 ${latest}`;
+  const cmdLine = `Run: ${cmd}`;
+  const width = Math.max(updateLine.length, cmdLine.length) + 4;
+  const pad = (text, visLen) => text + " ".repeat(Math.max(0, width - visLen));
+  const border = "\u2500".repeat(width);
+  const empty = " ".repeat(width);
+  console.log("");
+  console.log(`  \u250C${border}\u2510`);
+  console.log(`  \u2502${empty}\u2502`);
+  console.log(`  \u2502  ${pad(`Update available: ${current} \u2192 \x1B[32m${latest}\x1B[0m`, updateLine.length + 2)}\u2502`);
+  console.log(`  \u2502${empty}\u2502`);
+  console.log(`  \u2502  ${pad(`Run: \x1B[36m${cmd}\x1B[0m`, cmdLine.length + 2)}\u2502`);
+  console.log(`  \u2502${empty}\u2502`);
+  console.log(`  \u2514${border}\u2518`);
+  console.log("");
+}
+
+// src/review-update.ts
+function findLineContent(diff, lineNumber, side) {
+  for (const hunk of diff.hunks || []) {
+    for (const line of hunk.lines) {
+      if (side === "old" && line.oldNum === lineNumber) return line.content;
+      if (side === "new" && line.newNum === lineNumber) return line.content;
+    }
+  }
+  return null;
+}
+function findMatchingLine(diff, content, origLineNum, side, radius = 10) {
+  let bestMatch = null;
+  let bestDistance = Infinity;
+  for (const hunk of diff.hunks || []) {
+    for (const line of hunk.lines) {
+      if (line.content !== content) continue;
+      const lineNum = side === "old" ? line.oldNum : line.newNum;
+      if (lineNum == null) continue;
+      const distance = Math.abs(lineNum - origLineNum);
+      if (distance <= radius && distance < bestDistance) {
+        bestDistance = distance;
+        bestMatch = { lineNumber: lineNum, side };
+      }
+    }
+  }
+  return bestMatch;
+}
+async function migrateAnnotations(annotations, oldDiff, newDiff) {
+  let staleCount = 0;
+  for (const annotation of annotations) {
+    const oldContent = findLineContent(oldDiff, annotation.line_number, annotation.side);
+    if (!oldContent) {
+      if (!annotation.is_stale) {
+        await markAnnotationStale(annotation.id, null);
+        staleCount++;
+      }
+      continue;
+    }
+    const match = findMatchingLine(newDiff, oldContent, annotation.line_number, annotation.side);
+    if (match) {
+      if (match.lineNumber !== annotation.line_number || match.side !== annotation.side) {
+        await moveAnnotation(annotation.id, match.lineNumber, match.side);
+      } else if (annotation.is_stale) {
+        await markAnnotationCurrent(annotation.id);
+      }
+    } else {
+      if (!annotation.is_stale) {
+        await markAnnotationStale(annotation.id, oldContent);
+        staleCount++;
+      }
+    }
+  }
+  return staleCount;
+}
+async function updateReviewDiffs(reviewId, newDiffs, headCommit) {
+  const existingFiles = await getReviewFiles(reviewId);
+  const existingByPath = /* @__PURE__ */ new Map();
+  for (const f of existingFiles) {
+    existingByPath.set(f.file_path, f);
+  }
+  const newDiffsByPath = /* @__PURE__ */ new Map();
+  for (const d of newDiffs) {
+    newDiffsByPath.set(d.filePath, d);
+  }
+  let updated = 0;
+  let added = 0;
+  let stale = 0;
+  for (const [path, existingFile] of existingByPath) {
+    const newDiff = newDiffsByPath.get(path);
+    if (newDiff) {
+      const oldDiff = JSON.parse(existingFile.diff_data || "{}");
+      const annotations = await getAnnotationsForFile(existingFile.id);
+      if (annotations.length > 0) {
+        stale += await migrateAnnotations(annotations, oldDiff, newDiff);
+      }
+      await updateFileDiff(existingFile.id, JSON.stringify(newDiff));
+      updated++;
+    } else {
+      const annotations = await getAnnotationsForFile(existingFile.id);
+      if (annotations.length === 0) {
+        await deleteReviewFile(existingFile.id);
+      } else {
+        const oldDiff = JSON.parse(existingFile.diff_data || "{}");
+        for (const a of annotations) {
+          if (!a.is_stale) {
+            const content = findLineContent(oldDiff, a.line_number, a.side);
+            await markAnnotationStale(a.id, content);
+            stale++;
+          }
+        }
+      }
+    }
+  }
+  for (const [path, diff] of newDiffsByPath) {
+    if (!existingByPath.has(path)) {
+      await addReviewFile(reviewId, path, JSON.stringify(diff));
+      added++;
+    }
+  }
+  await updateReviewHead(reviewId, headCommit);
+  return { updated, added, stale };
+}
+
+// src/cli.ts
+function printUsage() {
+  console.log(`
+glassbox - Review AI-generated code with annotations
+
+Usage:
+  glassbox [options]
+
+Modes (pick one):
+  --uncommitted       Review all uncommitted changes (staged + unstaged + untracked)
+  --staged            Review only staged changes
+  --unstaged          Review only unstaged changes
+  --commit <sha>      Review changes from a specific commit
+  --range <from>..<to>  Review changes between two refs
+  --branch <name>     Review changes on current branch vs <name>
+  --files <patterns>  Review specific files (glob patterns, comma-separated)
+  --all               Review entire codebase
+
+Options:
+  --port <number>     Port to run on (default: 4173)
+  --resume            Resume the latest in-progress review for this mode
+  --check-for-updates Check for a newer version on npm
+  --help              Show this help message
+
+Examples:
+  glassbox --uncommitted
+  glassbox --commit abc123
+  glassbox --branch main
+  glassbox --files "src/**/*.ts,lib/*.js"
+  glassbox --all --resume
+`);
+}
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  let mode = null;
+  let port = 4173;
+  let resume = false;
+  let forceUpdateCheck = false;
+  let debug = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--help":
+      case "-h":
+        printUsage();
+        process.exit(0);
+      case "--uncommitted":
+        mode = { type: "uncommitted" };
+        break;
+      case "--staged":
+        mode = { type: "staged" };
+        break;
+      case "--unstaged":
+        mode = { type: "unstaged" };
+        break;
+      case "--commit":
+        mode = { type: "commit", sha: args[++i] };
+        break;
+      case "--range": {
+        const parts = args[++i].split("..");
+        mode = { type: "range", from: parts[0], to: parts[1] || "HEAD" };
+        break;
+      }
+      case "--branch":
+        mode = { type: "branch", name: args[++i] };
+        break;
+      case "--files":
+        mode = { type: "files", patterns: args[++i].split(",") };
+        break;
+      case "--all":
+        mode = { type: "all" };
+        break;
+      case "--port":
+        port = parseInt(args[++i], 10);
+        break;
+      case "--resume":
+        resume = true;
+        break;
+      case "--check-for-updates":
+        forceUpdateCheck = true;
+        break;
+      case "--debug":
+        debug = true;
+        break;
+      default:
+        console.error(`Unknown option: ${arg}`);
+        printUsage();
+        process.exit(1);
+    }
+  }
+  if (!mode) {
+    mode = { type: "uncommitted" };
+  }
+  return { mode, port, resume, forceUpdateCheck, debug };
+}
+async function main() {
+  const parsed = parseArgs(process.argv);
+  if (!parsed) {
+    printUsage();
+    process.exit(1);
+  }
+  const { mode, port, resume, forceUpdateCheck, debug } = parsed;
+  if (debug) {
+    console.log(`Build timestamp: ${"2026-03-05T06:52:47.945Z"}`);
+  }
+  await checkForUpdates(forceUpdateCheck);
+  const cwd = process.cwd();
+  if (!isGitRepo(cwd)) {
+    console.error("Error: Not a git repository. Run this from inside a git repo.");
+    process.exit(1);
+  }
+  const repoRoot = getRepoRoot(cwd);
+  const repoName = getRepoName(cwd);
+  const modeStr = getModeString(mode);
+  const modeArgs = getModeArgs(mode);
+  const headCommit = getHeadCommit(cwd);
+  const existing = await getLatestInProgressReview(repoRoot, modeStr, modeArgs);
+  if (existing) {
+    if (existing.head_commit === headCommit) {
+      console.log(`Updating existing review ${existing.id}...`);
+      const diffs2 = getFileDiffs(mode, cwd);
+      const result = await updateReviewDiffs(existing.id, diffs2, headCommit);
+      console.log(`Updated ${result.updated} file(s), ${result.added} added, ${result.stale} stale annotation(s)`);
+      await startServer(port, existing.id, repoRoot);
+      return;
+    }
+    if (resume) {
+      console.log(`Resuming review ${existing.id} (started ${existing.created_at})`);
+      await startServer(port, existing.id, repoRoot);
+      return;
+    }
+  } else if (resume) {
+    console.log("No in-progress review found, starting a new one.");
+  }
+  console.log(`Scanning ${modeStr} changes in ${repoName}...`);
+  const diffs = getFileDiffs(mode, cwd);
+  if (diffs.length === 0) {
+    console.log("No changes found for the specified mode.");
+    process.exit(0);
+  }
+  console.log(`Found ${diffs.length} file(s) to review.`);
+  const review = await createReview(repoRoot, repoName, modeStr, modeArgs, headCommit);
+  for (const diff of diffs) {
+    await addReviewFile(review.id, diff.filePath, JSON.stringify(diff));
+  }
+  console.log(`Review ${review.id} created.`);
+  await startServer(port, review.id, repoRoot);
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map