@spader/spall-tui 1.0.0

package/dist/App.js

@@ -0,0 +1,3636 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/lib/git.ts
+var {$ } = globalThis.Bun;
+var Git;
+((Git) => {
+  async function root(startPath) {
+    try {
+      const result = await $`git -C ${startPath} rev-parse --show-toplevel`.quiet();
+      return result.stdout.toString().trim() || null;
+    } catch {
+      return null;
+    }
+  }
+  Git.root = root;
+  async function head(repoPath) {
+    try {
+      const result = await $`git -C ${repoPath} rev-parse HEAD`.quiet();
+      return result.stdout.toString().trim() || null;
+    } catch {
+      return null;
+    }
+  }
+  Git.head = head;
+  async function diff(repoPath) {
+    const e = await entries(repoPath);
+    return e.map((x) => x.content).join(`
+`);
+  }
+  Git.diff = diff;
+  async function hash(repoPath) {
+    const trackedResult = await $`git -C ${repoPath} diff HEAD --name-only --relative`.quiet();
+    const untrackedResult = await $`git -C ${repoPath} ls-files --others --exclude-standard`.quiet();
+    const combined = trackedResult.stdout.toString() + "\x00" + untrackedResult.stdout.toString();
+    return Number(Bun.hash(combined));
+  }
+  Git.hash = hash;
+  async function entries(repoPath) {
+    const context = 0;
+    const result = [];
+    const filesResult = await $`git -C ${repoPath} diff -U${context} HEAD --name-only --relative`.quiet();
+    const filesOutput = filesResult.stdout.toString().trim();
+    const trackedFiles = filesOutput ? filesOutput.split(`
+`).filter(Boolean) : [];
+    const deletedResult = await $`git -C ${repoPath} diff -U${context} HEAD --name-only --diff-filter=D --relative`.quiet();
+    const deletedOutput = deletedResult.stdout.toString().trim();
+    const deletedFiles = new Set(deletedOutput ? deletedOutput.split(`
+`).filter(Boolean) : []);
+    for (const file of trackedFiles) {
+      const diffResult = await $`git -C ${repoPath} diff -U${context} HEAD -- ${file}`.quiet();
+      const content = diffResult.stdout.toString();
+      const isDeleted = deletedFiles.has(file);
+      result.push({ file, content, isNew: false, isDeleted });
+    }
+    const untrackedResult = await $`git -C ${repoPath} ls-files --others --exclude-standard`.quiet();
+    const untrackedOutput = untrackedResult.stdout.toString().trim();
+    const untrackedFiles = untrackedOutput ? untrackedOutput.split(`
+`).filter(Boolean) : [];
+    for (const file of untrackedFiles) {
+      const fileContent = await Bun.file(`${repoPath}/${file}`).text();
+      const lines2 = fileContent.split(`
+`);
+      const diffLines = lines2.map((line) => `+${line}`);
+      const content = `diff --git a/${file} b/${file}
+new file mode 100644
+--- /dev/null
++++ b/${file}
+@@ -0,0 +1,${lines2.length} @@
+${diffLines.join(`
+`)}`;
+      result.push({ file, content, isNew: true, isDeleted: false });
+    }
+    return result;
+  }
+  Git.entries = entries;
+  function lines(diffContent) {
+    if (!diffContent)
+      return 0;
+    const allLines = diffContent.split(`
+`);
+    let count = 0;
+    let inHunk = false;
+    for (const line of allLines) {
+      if (line.startsWith("@@")) {
+        inHunk = true;
+        continue;
+      }
+      if (!inHunk)
+        continue;
+      const firstChar = line[0];
+      if (firstChar === " " || firstChar === "+" || firstChar === "-") {
+        count++;
+      }
+    }
+    return count;
+  }
+  Git.lines = lines;
+})(Git ||= {});
+
+// src/store/db.ts
+var exports_db = {};
+__export(exports_db, {
+  path: () => path,
+  init: () => init,
+  get: () => get,
+  close: () => close
+});
+import { Database } from "bun:sqlite";
+import { mkdirSync, existsSync } from "fs";
+import { dirname, join } from "path";
+import { Config } from "@spader/spall-core/config";
+var DB_PATH = join(Config.get().dirs.data, "tui.db");
+var CREATE_REPOS_TABLE = `
+  CREATE TABLE IF NOT EXISTS repos (
+    id INTEGER PRIMARY KEY,
+    path TEXT NOT NULL UNIQUE
+  )
+`;
+var CREATE_REVIEWS_TABLE = `
+  CREATE TABLE IF NOT EXISTS reviews (
+    id INTEGER PRIMARY KEY,
+    repo INTEGER NOT NULL,
+    commit_sha TEXT NOT NULL,
+    name TEXT,
+    created_at INTEGER NOT NULL,
+    FOREIGN KEY (repo) REFERENCES repos(id)
+  )
+`;
+var CREATE_PATCHES_TABLE = `
+  CREATE TABLE IF NOT EXISTS patches (
+    id INTEGER PRIMARY KEY,
+    review INTEGER NOT NULL,
+    seq INTEGER NOT NULL,
+    hash TEXT NOT NULL,
+    content TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    FOREIGN KEY (review) REFERENCES reviews(id),
+    UNIQUE (review, seq)
+  )
+`;
+var CREATE_REVIEW_COMMENTS_TABLE = `
+  CREATE TABLE IF NOT EXISTS review_comments (
+    id INTEGER PRIMARY KEY,
+    review INTEGER NOT NULL,
+    note_id INTEGER NOT NULL,
+    file TEXT NOT NULL,
+    patch_id INTEGER NOT NULL,
+    start_row INTEGER NOT NULL,
+    end_row INTEGER NOT NULL,
+    created_at INTEGER NOT NULL,
+    FOREIGN KEY (review) REFERENCES reviews(id)
+  )
+`;
+var db = null;
+function path() {
+  return DB_PATH;
+}
+function init() {
+  if (db)
+    return db;
+  const dir = dirname(DB_PATH);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  db = new Database(DB_PATH);
+  db.exec(CREATE_REPOS_TABLE);
+  db.exec(CREATE_REVIEWS_TABLE);
+  db.exec(CREATE_PATCHES_TABLE);
+  db.exec(CREATE_REVIEW_COMMENTS_TABLE);
+  return db;
+}
+function get() {
+  if (!db) {
+    throw new Error("Store not initialized. Call init() first.");
+  }
+  return db;
+}
+function close() {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}
+
+// src/store/repo.ts
+var exports_repo = {};
+__export(exports_repo, {
+  getOrCreate: () => getOrCreate,
+  getByPath: () => getByPath,
+  create: () => create
+});
+function create(path2) {
+  const row = get().prepare(`INSERT INTO repos (path) VALUES (?) RETURNING id`).get(path2);
+  return { id: row.id, path: path2 };
+}
+function getByPath(path2) {
+  const row = get().prepare(`SELECT * FROM repos WHERE path = ?`).get(path2);
+  if (!row)
+    return null;
+  return { id: row.id, path: row.path };
+}
+function getOrCreate(path2) {
+  const existing = getByPath(path2);
+  if (existing)
+    return existing;
+  return create(path2);
+}
+
+// src/store/review.ts
+var exports_review = {};
+__export(exports_review, {
+  list: () => list,
+  latest: () => latest,
+  getOrCreate: () => getOrCreate2,
+  getByRepoAndCommit: () => getByRepoAndCommit,
+  get: () => get2,
+  create: () => create2
+});
+function rowToInfo(row) {
+  return {
+    id: row.id,
+    repo: row.repo,
+    commitSha: row.commit_sha,
+    name: row.name,
+    createdAt: row.created_at
+  };
+}
+function create2(input) {
+  const createdAt = Date.now();
+  const row = get().prepare(`INSERT INTO reviews (repo, commit_sha, name, created_at) 
+       VALUES (?, ?, ?, ?) RETURNING *`).get(input.repo, input.commitSha, input.name ?? null, createdAt);
+  return rowToInfo(row);
+}
+function list(repo) {
+  const rows = get().prepare(`SELECT * FROM reviews WHERE repo = ? ORDER BY created_at DESC`).all(repo);
+  return rows.map(rowToInfo);
+}
+function get2(id) {
+  const row = get().prepare(`SELECT * FROM reviews WHERE id = ?`).get(id);
+  if (!row)
+    return null;
+  return rowToInfo(row);
+}
+function latest(repo) {
+  const row = get().prepare(`SELECT * FROM reviews WHERE repo = ? ORDER BY created_at DESC LIMIT 1`).get(repo);
+  if (!row)
+    return null;
+  return rowToInfo(row);
+}
+function getByRepoAndCommit(repo, commitSha) {
+  const row = get().prepare(`SELECT * FROM reviews WHERE repo = ? AND commit_sha = ?`).get(repo, commitSha);
+  if (!row)
+    return null;
+  return rowToInfo(row);
+}
+function getOrCreate2(repo, commitSha) {
+  const existing = getByRepoAndCommit(repo, commitSha);
+  if (existing)
+    return existing;
+  return create2({ repo, commitSha });
+}
+
+// src/store/patch.ts
+var exports_patch = {};
+__export(exports_patch, {
+  pruneUnreferenced: () => pruneUnreferenced,
+  nextSeq: () => nextSeq,
+  list: () => list2,
+  latest: () => latest2,
+  getOrCreate: () => getOrCreate3,
+  getByHash: () => getByHash,
+  get: () => get3,
+  create: () => create3
+});
+function rowToInfo2(row) {
+  return {
+    id: row.id,
+    review: row.review,
+    seq: row.seq,
+    hash: row.hash,
+    content: row.content,
+    createdAt: row.created_at
+  };
+}
+function create3(input) {
+  const row = get().prepare(`INSERT INTO patches (review, seq, hash, content, created_at)
+       VALUES (?, ?, ?, ?, ?) RETURNING *`).get(input.review, input.seq, input.hash, input.content, Date.now());
+  return rowToInfo2(row);
+}
+function get3(id) {
+  const row = get().prepare(`SELECT * FROM patches WHERE id = ?`).get(id);
+  if (!row)
+    return null;
+  return rowToInfo2(row);
+}
+function getByHash(review, hash) {
+  const row = get().prepare(`SELECT * FROM patches WHERE review = ? AND hash = ?`).get(review, hash);
+  if (!row)
+    return null;
+  return rowToInfo2(row);
+}
+function latest2(review) {
+  const row = get().prepare(`SELECT * FROM patches WHERE review = ? ORDER BY seq DESC LIMIT 1`).get(review);
+  if (!row)
+    return null;
+  return rowToInfo2(row);
+}
+function list2(review) {
+  const rows = get().prepare(`SELECT * FROM patches WHERE review = ? ORDER BY seq ASC`).all(review);
+  return rows.map(rowToInfo2);
+}
+function pruneUnreferenced(review, keepPatchIds = []) {
+  const keep = keepPatchIds.filter((x) => Number.isFinite(x));
+  const keepSql = keep.length > 0 ? ` AND id NOT IN (${keep.map(() => "?").join(",")})` : "";
+  const stmt = get().prepare(`DELETE FROM patches
+       WHERE review = ?
+         AND id NOT IN (
+           SELECT DISTINCT patch_id FROM review_comments WHERE review = ?
+         )${keepSql}`);
+  const result = stmt.run(review, review, ...keep);
+  return Number(result.changes ?? 0);
+}
+function nextSeq(review) {
+  const last = latest2(review);
+  return last ? last.seq + 1 : 0;
+}
+function getOrCreate3(review, content) {
+  const hash = String(Bun.hash(content));
+  const existing = getByHash(review, hash);
+  if (existing)
+    return existing;
+  const seq = nextSeq(review);
+  return create3({ review, seq, hash, content });
+}
+
+// src/store/comment.ts
+var exports_comment = {};
+__export(exports_comment, {
+  list: () => list3,
+  create: () => create4
+});
+function create4(input) {
+  const now = Date.now();
+  const row = get().prepare(`INSERT INTO review_comments (
+         review,
+         note_id,
+         file,
+         patch_id,
+         start_row,
+         end_row,
+         created_at
+       )
+       VALUES (?, ?, ?, ?, ?, ?, ?) RETURNING id`).get(input.review, input.noteId, input.file, input.patchId, input.startRow, input.endRow, now);
+  return {
+    id: row.id,
+    review: input.review,
+    noteId: input.noteId,
+    file: input.file,
+    patchId: input.patchId,
+    startRow: input.startRow,
+    endRow: input.endRow,
+    createdAt: now
+  };
+}
+function list3(review) {
+  const rows = get().prepare(`SELECT * FROM review_comments WHERE review = ? ORDER BY created_at ASC`).all(review);
+  return rows.map((row) => ({
+    id: row.id,
+    review: row.review,
+    noteId: row.note_id,
+    file: row.file,
+    patchId: row.patch_id,
+    startRow: row.start_row,
+    endRow: row.end_row,
+    createdAt: row.created_at
+  }));
+}
+// src/App.tsx
+import { render } from "@opentui/solid";
+import { SliderRenderable, addDefaultParsers } from "@opentui/core";
+import { ErrorBoundary } from "solid-js";
+
+// src/Review.tsx
+import { useKeyboard as useKeyboard3, useTerminalDimensions as useTerminalDimensions2 } from "@opentui/solid";
+import { createSignal as createSignal8, createEffect as createEffect6, createMemo as createMemo4, Show as Show7 } from "solid-js";
+
+// src/components/DiffPanel.tsx
+import { Show, For, createMemo as createMemo2, createEffect, Index } from "solid-js";
+
+// src/lib/diff.ts
+import { parsePatch } from "diff";
+function parseFileDiff(content, file) {
+  if (!content)
+    return { hunks: [], totalRows: 0 };
+  try {
+    const patches = parsePatch(content);
+    if (patches.length === 0 && !content.endsWith(`
+`)) {
+      patches.push(...parsePatch(`${content}
+`));
+    }
+    if (patches.length === 0)
+      return { hunks: [], totalRows: 0 };
+    const rawHunks = patches[0]?.hunks ?? [];
+    const hunks = [];
+    const header = `diff --git a/${file} b/${file}
+--- a/${file}
++++ b/${file}`;
+    let currentRow = 1;
+    for (let i = 0;i < rawHunks.length; i++) {
+      const hunk = rawHunks[i];
+      let skipBefore = 0;
+      if (i > 0) {
+        const prev = rawHunks[i - 1];
+        const prevEnd = prev.oldStart + prev.oldLines;
+        skipBefore = hunk.oldStart - prevEnd;
+      }
+      const hunkHeader = `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`;
+      const diffString = `${header}
+${hunkHeader}
+${hunk.lines.join(`
+`)}`;
+      let lineCount = 0;
+      for (const line of hunk.lines) {
+        const c = line[0];
+        if (c === " " || c === "+" || c === "-")
+          lineCount++;
+      }
+      const startRow = currentRow;
+      const endRow = currentRow + lineCount - 1;
+      currentRow = endRow + 1;
+      hunks.push({
+        diffString,
+        oldStart: hunk.oldStart,
+        oldLines: hunk.oldLines,
+        newStart: hunk.newStart,
+        newLines: hunk.newLines,
+        skipBefore,
+        lineCount,
+        startRow,
+        endRow
+      });
+    }
+    return { hunks, totalRows: Math.max(0, currentRow - 1) };
+  } catch {
+    return { hunks: [], totalRows: 0 };
+  }
+}
+function getHunkIndexForRow(content, file, row) {
+  const { hunks } = parseFileDiff(content, file);
+  for (let i = 0;i < hunks.length; i++) {
+    const hunk = hunks[i];
+    if (row >= hunk.startRow && row <= hunk.endRow)
+      return i;
+  }
+  return null;
+}
+function stripPrefix(path2) {
+  if (!path2)
+    return "";
+  return path2.replace(/^a\//, "").replace(/^b\//, "");
+}
+function parsePatchEntries(content) {
+  if (!content.trim())
+    return [];
+  const chunks = content.trimEnd().split(/\n(?=diff --git )/);
+  const entries = [];
+  for (const chunk of chunks) {
+    if (!chunk.trim())
+      continue;
+    const parsed = parsePatch(chunk);
+    const patch = parsed[0];
+    let file = "";
+    if (patch) {
+      const newName = stripPrefix(patch.newFileName);
+      const oldName = stripPrefix(patch.oldFileName);
+      file = newName !== "/dev/null" ? newName : oldName;
+    }
+    if (!file) {
+      const first = chunk.split(`
+`)[0] ?? "";
+      const match = first.match(/^diff --git a\/(.+?) b\/(.+)$/);
+      if (match)
+        file = match[2] ?? match[1] ?? "";
+    }
+    if (!file)
+      continue;
+    const isNew = patch?.oldFileName === "/dev/null" || chunk.includes(`
+new file mode`);
+    const isDeleted = patch?.newFileName === "/dev/null" || chunk.includes(`
+deleted file mode`);
+    entries.push({ file, content: chunk, isNew, isDeleted });
+  }
+  return entries;
+}
+
+// src/context/theme.tsx
+import {
+  createContext,
+  useContext,
+  createSignal,
+  createMemo
+} from "solid-js";
+import { SyntaxStyle } from "@opentui/core";
+import { jsxDEV } from "@opentui/solid/jsx-dev-runtime";
+var ThemeContext = createContext();
+var defaultTheme = {
+  background: "#0a0a0a",
+  backgroundPanel: "#141414",
+  backgroundElement: "#1e1e1e",
+  text: "#eeeeee",
+  textMuted: "#808080",
+  primary: "#63a088",
+  primaryDark: "#1d2f28",
+  secondary: "#608999",
+  secondaryDark: "#182226",
+  added: "#284036",
+  removed: "#e06c75",
+  modified: "#e5c07b",
+  indicatorDefault: "#4a4a4a",
+  connected: "#73d936",
+  disconnected: "#ff5555",
+  diffAddedBg: "#20303b",
+  diffRemovedBg: "#37222c",
+  diffContextBg: "111111",
+  diffSignAdded: "#b8db87",
+  diffSignRemoved: "#e26a75",
+  diffAddedLineNumberBg: "#1a2a30",
+  diffRemovedLineNumberBg: "#2d1a22",
+  diffLineNumberFg: "#888888",
+  syntaxComment: "#5c6773",
+  syntaxKeyword: "#ff7733",
+  syntaxFunction: "#ffb454",
+  syntaxVariable: "#cbccc6",
+  syntaxString: "#bae67e",
+  syntaxNumber: "#ffcc66",
+  syntaxType: "#73d0ff",
+  syntaxOperator: "#f29e74",
+  syntaxPunctuation: "#cbccc6"
+};
+var systemTheme = {
+  background: "transparent",
+  backgroundPanel: "brightBlack",
+  backgroundElement: "gray",
+  text: "white",
+  textMuted: "brightBlack",
+  primary: "cyan",
+  primaryDark: "blue",
+  secondary: "red",
+  secondaryDark: "magenta",
+  added: "green",
+  removed: "red",
+  modified: "yellow",
+  indicatorDefault: "gray",
+  connected: "brightGreen",
+  disconnected: "brightRed",
+  diffAddedBg: "green",
+  diffRemovedBg: "red",
+  diffContextBg: "transparent",
+  diffSignAdded: "brightGreen",
+  diffSignRemoved: "brightRed",
+  diffAddedLineNumberBg: "green",
+  diffRemovedLineNumberBg: "red",
+  diffLineNumberFg: "brightBlack",
+  syntaxComment: "brightBlack",
+  syntaxKeyword: "magenta",
+  syntaxFunction: "blue",
+  syntaxVariable: "white",
+  syntaxString: "green",
+  syntaxNumber: "yellow",
+  syntaxType: "cyan",
+  syntaxOperator: "white",
+  syntaxPunctuation: "white"
+};
+var themes = {
+  default: defaultTheme,
+  system: systemTheme
+};
+function getSyntaxRules(theme) {
+  return [
+    {
+      scope: ["comment", "comment.documentation"],
+      style: { foreground: theme.syntaxComment, italic: true }
+    },
+    {
+      scope: ["string", "string.special", "character"],
+      style: { foreground: theme.syntaxString }
+    },
+    {
+      scope: ["number", "boolean", "constant"],
+      style: { foreground: theme.syntaxNumber }
+    },
+    {
+      scope: [
+        "keyword",
+        "keyword.return",
+        "keyword.conditional",
+        "keyword.repeat"
+      ],
+      style: { foreground: theme.syntaxKeyword, italic: true }
+    },
+    {
+      scope: ["keyword.function", "keyword.import"],
+      style: { foreground: theme.syntaxKeyword }
+    },
+    {
+      scope: ["function", "function.call", "function.method", "constructor"],
+      style: { foreground: theme.syntaxFunction }
+    },
+    {
+      scope: ["variable", "variable.parameter", "variable.member"],
+      style: { foreground: theme.syntaxVariable }
+    },
+    {
+      scope: ["type", "type.builtin", "module"],
+      style: { foreground: theme.syntaxType }
+    },
+    {
+      scope: ["operator", "keyword.operator"],
+      style: { foreground: theme.syntaxOperator }
+    },
+    {
+      scope: ["punctuation", "punctuation.delimiter", "punctuation.bracket"],
+      style: { foreground: theme.syntaxPunctuation }
+    },
+    {
+      scope: ["property"],
+      style: { foreground: theme.syntaxVariable }
+    },
+    {
+      scope: ["tag", "tag.attribute"],
+      style: { foreground: theme.syntaxKeyword }
+    }
+  ];
+}
+function ThemeProvider(props) {
+  const [themeName, setThemeName] = createSignal("default");
+  const syntax = createMemo(() => {
+    const theme = themes[themeName()];
+    return SyntaxStyle.fromTheme(getSyntaxRules(theme));
+  });
+  const value = {
+    get theme() {
+      return themes[themeName()];
+    },
+    themeName,
+    setTheme: setThemeName,
+    syntax
+  };
+  return /* @__PURE__ */ jsxDEV(ThemeContext.Provider, {
+    value,
+    children: props.children
+  }, undefined, false, undefined, this);
+}
+function useTheme() {
+  const ctx = useContext(ThemeContext);
+  if (!ctx)
+    throw new Error("useTheme must be used within ThemeProvider");
+  return ctx;
+}
+
+// src/components/HalfLineShadow.tsx
+import { jsxDEV as jsxDEV2 } from "@opentui/solid/jsx-dev-runtime";
+var EmptyBorder = {
+  topLeft: "",
+  bottomLeft: "",
+  vertical: "",
+  topRight: "",
+  bottomRight: "",
+  horizontal: " ",
+  bottomT: "",
+  topT: "",
+  cross: "",
+  leftT: "",
+  rightT: ""
+};
+
+// src/components/DiffPanel.tsx
+import { jsxDEV as jsxDEV3, Fragment } from "@opentui/solid/jsx-dev-runtime";
+var LINE_SCROLL_BUFFER = 8;
+function getFiletype(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase() ?? "";
+  const extMap = {
+    ts: "typescript",
+    tsx: "tsx",
+    js: "javascript",
+    jsx: "javascript",
+    mjs: "javascript",
+    cjs: "javascript",
+    html: "html",
+    htm: "html",
+    css: "css",
+    scss: "css",
+    vue: "vue",
+    json: "json",
+    yaml: "yaml",
+    yml: "yaml",
+    toml: "toml",
+    c: "c",
+    h: "c",
+    cpp: "cpp",
+    cc: "cpp",
+    cxx: "cpp",
+    hpp: "cpp",
+    hxx: "cpp",
+    rs: "rust",
+    go: "go",
+    zig: "zig",
+    py: "python",
+    rb: "ruby",
+    lua: "lua",
+    sh: "bash",
+    bash: "bash",
+    zsh: "bash",
+    php: "php",
+    java: "java",
+    kt: "kotlin",
+    kts: "kotlin",
+    scala: "scala",
+    cs: "c_sharp",
+    swift: "swift",
+    m: "objc",
+    mm: "objc",
+    dart: "dart",
+    ex: "elixir",
+    exs: "elixir",
+    elm: "elm",
+    ml: "ocaml",
+    mli: "ocaml",
+    el: "elisp",
+    sql: "ql",
+    erb: "embedded_template",
+    ejs: "embedded_template",
+    md: "markdown",
+    mdx: "markdown"
+  };
+  return extMap[ext] ?? "text";
+}
+function DiffPanel(props) {
+  const { theme, syntax } = useTheme();
+  const title = () => {
+    const entry = props.entry();
+    if (!entry)
+      return "Diff";
+    const hunkCount = props.hunkCount();
+    if (hunkCount === 0)
+      return entry.file;
+    if (props.selectionMode() === "line") {
+      const range = props.selectedRange();
+      if (range && range.startRow !== range.endRow) {
+        return `[lines ${range.startRow}-${range.endRow}]`;
+      }
+      const row = range?.startRow ?? props.cursorRow();
+      return `[line ${row}]`;
+    }
+    if (props.focused()) {
+      return `[hunk ${props.selectedHunkIndex() + 1}/${hunkCount}]`;
+    }
+    return `[${hunkCount} hunk${hunkCount === 1 ? "" : "s"}]`;
+  };
+  return /* @__PURE__ */ jsxDEV3("box", {
+    flexGrow: 1,
+    flexDirection: "column",
+    backgroundColor: theme.backgroundPanel,
+    paddingTop: 1,
+    paddingBottom: 1,
+    paddingLeft: 2,
+    paddingRight: 2,
+    children: [
+      /* @__PURE__ */ jsxDEV3("box", {
+        height: 1,
+        flexDirection: "row",
+        justifyContent: "flex-start",
+        gap: 1,
+        backgroundColor: props.focused() ? theme.primaryDark : theme.backgroundPanel,
+        border: ["left"],
+        borderColor: props.focused() ? theme.primary : theme.indicatorDefault,
+        customBorderChars: {
+          ...EmptyBorder,
+          vertical: "\u258C"
+        },
+        children: /* @__PURE__ */ jsxDEV3("box", {
+          paddingLeft: 1,
+          flexDirection: "row",
+          gap: 1,
+          children: [
+            /* @__PURE__ */ jsxDEV3("text", {
+              children: /* @__PURE__ */ jsxDEV3("span", {
+                style: { italic: true },
+                children: props.entry() ? props.entry().file : "none"
+              }, undefined, false, undefined, this)
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV3("text", {
+              children: /* @__PURE__ */ jsxDEV3("span", {
+                style: { bold: true },
+                children: title()
+              }, undefined, false, undefined, this)
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV3(Show, {
+        when: props.entry(),
+        children: (() => {
+          const entry = props.entry();
+          const model = createMemo2(() => parseFileDiff(entry.content, entry.file));
+          const hunks = createMemo2(() => model().hunks);
+          const filetype = getFiletype(entry.file);
+          let scrollbox = null;
+          createEffect(() => {
+            const hunkIdx = props.selectedHunkIndex();
+            const hunkList = hunks();
+            if (!scrollbox || hunkList.length === 0)
+              return;
+            let scrollLine = 0;
+            if (props.selectionMode() === "line") {
+              const row = props.cursorRow();
+              const rowHunkIndex = getHunkIndexForRow(entry.content, entry.file, row);
+              const separatorOffset2 = rowHunkIndex ? rowHunkIndex : 0;
+              scrollLine = Math.max(0, row - 1 + separatorOffset2);
+              const scrollTop2 = scrollbox.scrollTop;
+              const viewportHeight2 = scrollbox.viewport.height;
+              const topBound = scrollTop2 + LINE_SCROLL_BUFFER;
+              const bottomBound = scrollTop2 + viewportHeight2 - 1 - LINE_SCROLL_BUFFER;
+              if (scrollLine < topBound) {
+                scrollbox.scrollTo(Math.max(0, scrollLine - LINE_SCROLL_BUFFER));
+              } else if (scrollLine > bottomBound) {
+                scrollbox.scrollTo(Math.max(0, scrollLine + LINE_SCROLL_BUFFER - viewportHeight2 + 1));
+              }
+              return;
+            }
+            if (hunkIdx > 0) {
+              const prev = hunkList[Math.min(hunkIdx - 1, hunkList.length - 1)];
+              if (prev)
+                scrollLine = prev.endRow + hunkIdx;
+            }
+            const activeHunk = hunkList[hunkIdx];
+            if (!activeHunk)
+              return;
+            const scrollTop = scrollbox.scrollTop;
+            const viewportHeight = scrollbox.viewport.height;
+            const separatorOffset = hunkIdx;
+            const hunkTop = Math.max(0, activeHunk.startRow - 1 + separatorOffset);
+            const hunkBottom = Math.max(0, activeHunk.endRow - 1 + separatorOffset);
+            const viewportBottom = scrollTop + viewportHeight - 1;
+            if (hunkTop < scrollTop) {
+              scrollbox.scrollTo(hunkTop);
+            } else if (hunkBottom > viewportBottom) {
+              scrollbox.scrollTo(scrollLine);
+            }
+          });
+          return /* @__PURE__ */ jsxDEV3("scrollbox", {
+            ref: (r) => {
+              scrollbox = r;
+            },
+            focused: false,
+            flexGrow: 1,
+            children: /* @__PURE__ */ jsxDEV3("box", {
+              flexDirection: "column",
+              backgroundColor: theme.background,
+              children: /* @__PURE__ */ jsxDEV3(Index, {
+                each: hunks(),
+                children: (hunk, i) => {
+                  const isFocused = () => props.focused() && props.selectedHunkIndex() === i;
+                  const indicatorColor = (row) => {
+                    if (props.selectionMode() === "line") {
+                      const range = props.selectedRange();
+                      if (range && row >= range.startRow && row <= range.endRow) {
+                        return theme.primary;
+                      }
+                      return theme.indicatorDefault;
+                    }
+                    if (isFocused())
+                      return theme.primary;
+                    return theme.indicatorDefault;
+                  };
+                  return /* @__PURE__ */ jsxDEV3(Fragment, {
+                    children: [
+                      /* @__PURE__ */ jsxDEV3(Show, {
+                        when: i > 0,
+                        children: /* @__PURE__ */ jsxDEV3("box", {
+                          height: 1,
+                          backgroundColor: theme.backgroundPanel
+                        }, undefined, false, undefined, this)
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV3("box", {
+                        flexDirection: "row",
+                        children: [
+                          /* @__PURE__ */ jsxDEV3("box", {
+                            flexDirection: "column",
+                            width: 1,
+                            flexShrink: 0,
+                            children: /* @__PURE__ */ jsxDEV3(For, {
+                              each: Array.from({ length: hunk().lineCount }, (_, j) => j),
+                              children: (j) => {
+                                const row = hunk().startRow + j;
+                                return /* @__PURE__ */ jsxDEV3("text", {
+                                  height: 1,
+                                  fg: indicatorColor(row),
+                                  children: "\u258C"
+                                }, undefined, false, undefined, this);
+                              }
+                            }, undefined, false, undefined, this)
+                          }, undefined, false, undefined, this),
+                          /* @__PURE__ */ jsxDEV3("diff", {
+                            diff: hunk().diffString,
+                            view: "unified",
+                            filetype,
+                            syntaxStyle: syntax(),
+                            showLineNumbers: true,
+                            flexGrow: 0,
+                            fg: theme.text,
+                            addedBg: theme.diffAddedBg,
+                            removedBg: theme.diffRemovedBg,
+                            contextBg: theme.diffContextBg,
+                            addedSignColor: theme.diffSignAdded,
+                            removedSignColor: theme.diffSignRemoved,
+                            lineNumberFg: theme.diffLineNumberFg,
+                            lineNumberBg: theme.diffContextBg,
+                            addedLineNumberBg: theme.diffAddedLineNumberBg,
+                            removedLineNumberBg: theme.diffRemovedLineNumberBg
+                          }, undefined, false, undefined, this)
+                        ]
+                      }, undefined, true, undefined, this)
+                    ]
+                  }, undefined, true, undefined, this);
+                }
+              }, undefined, false, undefined, this)
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this);
+        })()
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV3(Show, {
+        when: !props.entry(),
+        children: /* @__PURE__ */ jsxDEV3("box", {
+          padding: 1,
+          flexGrow: 1,
+          children: /* @__PURE__ */ jsxDEV3("text", {
+            children: "Select a file to view diff"
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+// src/components/EditorPanel.tsx
+import { onMount as onMount3 } from "solid-js";
+import { spawn } from "child_process";
+import { writeFileSync, readFileSync } from "fs";
+import { useRenderer } from "@opentui/solid";
+
+// src/context/review.tsx
+import {
+  createContext as createContext3,
+  useContext as useContext3,
+  createSignal as createSignal3,
+  createEffect as createEffect2,
+  onMount as onMount2
+} from "solid-js";
+
+// src/context/server.tsx
+import {
+  createContext as createContext2,
+  useContext as useContext2,
+  createSignal as createSignal2,
+  onMount,
+  onCleanup
+} from "solid-js";
+import { Client } from "@spader/spall-sdk/client";
+import { jsxDEV as jsxDEV4 } from "@opentui/solid/jsx-dev-runtime";
+var ServerContext = createContext2();
+function ServerProvider(props) {
+  const [url, setUrl] = createSignal2(null);
+  const [connected, setConnected] = createSignal2(false);
+  const [client, setClient] = createSignal2(null);
+  let shutdown = false;
+  const controller = new AbortController;
+  onMount(() => {
+    const connect = async () => {
+      while (!shutdown) {
+        try {
+          const c = await Client.connect(controller.signal);
+          const health = await c.health();
+          if (!health?.response?.ok) {
+            throw new Error("Health check failed");
+          }
+          setUrl(health.response.url.replace("/health", ""));
+          setConnected(true);
+          setClient(c);
+          const { stream } = await c.events({
+            onSseError: () => {
+              setConnected(false);
+              setClient(null);
+            },
+            sseMaxRetryAttempts: 0
+          });
+          for await (const event of stream) {}
+        } catch {
+          setConnected(false);
+          setClient(null);
+          setUrl(null);
+          await Bun.sleep(100);
+        }
+      }
+    };
+    connect();
+  });
+  onCleanup(() => {
+    shutdown = true;
+    controller.abort();
+  });
+  const value = {
+    url,
+    connected,
+    client
+  };
+  return /* @__PURE__ */ jsxDEV4(ServerContext.Provider, {
+    value,
+    children: props.children
+  }, undefined, false, undefined, this);
+}
+function useServer() {
+  const ctx = useContext2(ServerContext);
+  if (!ctx)
+    throw new Error("useServer must be used within ServerProvider");
+  return ctx;
+}
+
+// src/context/review.tsx
+import { jsxDEV as jsxDEV5 } from "@opentui/solid/jsx-dev-runtime";
+function pickCommentForRange(list4, preferredPatchId, file, startRow, endRow) {
+  if (preferredPatchId !== null) {
+    const exact = list4.find((c) => c.patchId === preferredPatchId && c.file === file && c.startRow === startRow && c.endRow === endRow) ?? null;
+    if (exact)
+      return exact;
+  }
+  const matches = list4.filter((c) => c.file === file && c.startRow === startRow && c.endRow === endRow);
+  if (matches.length === 0)
+    return null;
+  return matches.reduce((best, c) => c.createdAt > best.createdAt ? c : best);
+}
+var ReviewContext = createContext3();
+function repoName(path2) {
+  const segments = path2.split("/").filter(Boolean);
+  return segments[segments.length - 1] || "unknown";
+}
+var REVIEW_CORPUS_NAME = "spall-review";
+function repoKey(root) {
+  const base = repoName(root).replace(/[^a-zA-Z0-9._-]+/g, "-");
+  const h = Bun.hash(root);
+  const n = typeof h === "bigint" ? Number(h % 0xffffffffn) : h;
+  const suffix = Math.abs(n).toString(36).slice(0, 6);
+  return `${base}-${suffix}`;
+}
+function reviewNotePath(input) {
+  const filePath = input.file.replace(/\\/g, "/");
+  return `review/${repoKey(input.root)}/${input.commitSha}/p${input.patchSeq}/${filePath}__${input.startRow}-${input.endRow}.md`;
+}
+function ReviewProvider(props) {
+  const server = useServer();
+  const [corpusId, setCorpusId] = createSignal3(null);
+  const corpusName = () => REVIEW_CORPUS_NAME;
+  const [repoRoot, setRepoRoot] = createSignal3(null);
+  const [reviewId, setReviewId] = createSignal3(null);
+  const [commitSha, setCommitSha] = createSignal3(null);
+  const [activePatchId, setActivePatchIdState] = createSignal3(null);
+  const [workingTreePatchId, setWorkingTreePatchId] = createSignal3(null);
+  const [workspaceEntries, setWorkspaceEntries] = createSignal3([]);
+  const [workspaceDiff, setWorkspaceDiff] = createSignal3("");
+  const [entries, setEntries] = createSignal3([]);
+  const [loading, setLoading] = createSignal3(true);
+  const ensureReviewId = (root, head) => {
+    const current = reviewId();
+    if (current !== null)
+      return current;
+    const repo = exports_repo.getOrCreate(root);
+    const review = exports_review.getOrCreate(repo.id, head);
+    setReviewId(review.id);
+    return review.id;
+  };
+  const [patches, setPatches] = createSignal3([]);
+  const [patchesLoading, setPatchesLoading] = createSignal3(false);
+  const [comments, setComments] = createSignal3([]);
+  const [commentsLoading, setCommentsLoading] = createSignal3(false);
+  const [selectedFilePath, setSelectedFilePath] = createSignal3(null);
+  const preserveSelectedFilePath = (list4, preferred) => {
+    if (!preferred)
+      return null;
+    return list4.some((e) => e.file === preferred) ? preferred : null;
+  };
+  const setActivePatch = (patchId, preserveFilePath) => {
+    if (patchId === null) {
+      const wt = workingTreePatchId();
+      if (wt !== null) {
+        setActivePatch(wt, preserveFilePath);
+        return;
+      }
+      setActivePatchIdState(null);
+      const ws = parsePatchEntries(workspaceDiff());
+      setEntries(ws);
+      setSelectedFilePath(preserveSelectedFilePath(ws, preserveFilePath ?? selectedFilePath()));
+      return;
+    }
+    const patch = exports_patch.get(patchId);
+    if (!patch)
+      return;
+    setActivePatchIdState(patchId);
+    const newEntries = parsePatchEntries(patch.content);
+    setEntries(newEntries);
+    setSelectedFilePath(preserveSelectedFilePath(newEntries, preserveFilePath ?? selectedFilePath()));
+  };
+  const refreshWorkingTree = async (preserveFilePath) => {
+    const newEntries = await Git.entries(props.repoPath);
+    setWorkspaceEntries(newEntries);
+    const fullDiff = newEntries.map((x) => x.content).join(`
+`);
+    setWorkspaceDiff(fullDiff);
+    const root = repoRoot();
+    const head = commitSha();
+    if (!root || !head) {
+      if (activePatchId() === null) {
+        const ws = parsePatchEntries(fullDiff);
+        setEntries(ws);
+        setSelectedFilePath(preserveSelectedFilePath(ws, preserveFilePath ?? selectedFilePath()));
+      }
+      setWorkingTreePatchId(null);
+      return;
+    }
+    const revId = ensureReviewId(root, head);
+    const patch = exports_patch.getOrCreate(revId, fullDiff);
+    const prevWt = workingTreePatchId();
+    setWorkingTreePatchId(patch.id);
+    setPatches((prev) => {
+      if (prev.some((p) => p.id === patch.id))
+        return prev;
+      return [...prev, patch].sort((a, b) => a.seq - b.seq);
+    });
+    const active = activePatchId();
+    if (active === null || prevWt !== null && active === prevWt) {
+      setActivePatch(patch.id, preserveFilePath);
+    }
+  };
+  const [initialized, setInitialized] = createSignal3(false);
+  let corpusInitInFlight = false;
+  let commentsHydrated = false;
+  createEffect2(() => {
+    const client = server.client();
+    if (!client || !initialized())
+      return;
+    if (corpusId() === null && !corpusInitInFlight) {
+      corpusInitInFlight = true;
+      (async () => {
+        try {
+          const result = await client.corpus.create({
+            name: REVIEW_CORPUS_NAME
+          });
+          if (result.data) {
+            setCorpusId(result.data.id);
+          }
+        } catch {} finally {
+          corpusInitInFlight = false;
+        }
+      })();
+    }
+    if (commentsHydrated)
+      return;
+    const pending = comments().filter((c) => c.notePath === null || c.noteContent === null);
+    if (pending.length === 0) {
+      commentsHydrated = true;
+      return;
+    }
+    commentsHydrated = true;
+    setCommentsLoading(true);
+    (async () => {
+      try {
+        const results = await Promise.all(pending.map(async (comment) => {
+          try {
+            const result = await client.note.getById({
+              id: comment.noteId.toString()
+            });
+            if (!result.data)
+              return null;
+            return {
+              id: comment.id,
+              notePath: result.data.path,
+              noteContent: result.data.content
+            };
+          } catch {
+            return null;
+          }
+        }));
+        const byId = new Map(results.filter(Boolean).map((r) => [r.id, r]));
+        setComments((prev) => prev.map((c) => {
+          const upd = byId.get(c.id);
+          return upd ? { ...c, notePath: upd.notePath, noteContent: upd.noteContent } : c;
+        }));
+      } finally {
+        setCommentsLoading(false);
+      }
+    })();
+  });
+  onMount2(async () => {
+    const root = await Git.root(props.repoPath);
+    setRepoRoot(root);
+    const head = await Git.head(props.repoPath);
+    setCommitSha(head);
+    if (root && head) {
+      ensureReviewId(root, head);
+    }
+    const revId = reviewId();
+    if (revId) {
+      const local = exports_comment.list(revId);
+      setComments(local.map((c) => ({
+        id: c.id,
+        reviewId: c.review,
+        noteId: c.noteId,
+        file: c.file,
+        patchId: c.patchId,
+        startRow: c.startRow,
+        endRow: c.endRow,
+        createdAt: c.createdAt,
+        notePath: null,
+        noteContent: null
+      })));
+      setPatchesLoading(true);
+      setPatches(exports_patch.list(revId));
+      setPatchesLoading(false);
+    }
+    await refreshWorkingTree(selectedFilePath() ?? undefined);
+    if (revId) {
+      const wt = workingTreePatchId();
+      exports_patch.pruneUnreferenced(revId, wt !== null ? [wt] : []);
+      setPatches(exports_patch.list(revId));
+    }
+    setLoading(false);
+    setInitialized(true);
+  });
+  const getCommentById = (commentId) => {
+    return comments().find((c) => c.id === commentId) ?? null;
+  };
+  const getCommentForRange = (file, startRow, endRow) => {
+    const patchId = activePatchId();
+    return pickCommentForRange(comments(), patchId, file, startRow, endRow);
+  };
+  const createComment = async (file, startRow, endRow, content) => {
+    const root = repoRoot();
+    const head = commitSha();
+    const c = server.client();
+    let cid = corpusId();
+    if (!root || !head)
+      return null;
+    if (!content.trim())
+      return null;
+    const repo = exports_repo.getOrCreate(root);
+    let revId = reviewId();
+    if (!revId) {
+      const review = exports_review.getOrCreate(repo.id, head);
+      revId = review.id;
+      setReviewId(revId);
+    }
+    let patch = activePatchId() ? exports_patch.get(activePatchId()) : null;
+    if (!patch) {
+      const wt = workingTreePatchId();
+      patch = wt !== null ? exports_patch.get(wt) : null;
+      if (!patch) {
+        const fullDiff = workspaceDiff();
+        patch = exports_patch.getOrCreate(revId, fullDiff);
+        setWorkingTreePatchId(patch.id);
+        setPatches((prev) => {
+          if (prev.some((p) => p.id === patch.id))
+            return prev;
+          return [...prev, patch].sort((a, b) => a.seq - b.seq);
+        });
+        if (activePatchId() === null)
+          setActivePatch(patch.id);
+      }
+    }
+    if (!patch)
+      return null;
+    if (c) {
+      if (cid === null) {
+        try {
+          const ensured = await c.corpus.create({ name: REVIEW_CORPUS_NAME });
+          if (ensured.data) {
+            cid = ensured.data.id;
+            setCorpusId(cid);
+          }
+        } catch {}
+      }
+      if (cid === null)
+        return null;
+      const path2 = reviewNotePath({
+        root,
+        commitSha: head,
+        patchSeq: patch.seq,
+        file,
+        startRow,
+        endRow
+      });
+      const result = await c.note.upsert({
+        id: cid.toString(),
+        path: path2,
+        content,
+        dupe: true
+      });
+      if (result.error || !result.data) {
+        return null;
+      }
+      const noteId = result.data.id;
+      const localComment = exports_comment.create({
+        review: revId,
+        noteId,
+        file,
+        patchId: patch.id,
+        startRow,
+        endRow
+      });
+      const newComment = {
+        id: localComment.id,
+        reviewId: revId,
+        noteId,
+        file,
+        patchId: localComment.patchId,
+        startRow: localComment.startRow,
+        endRow: localComment.endRow,
+        createdAt: localComment.createdAt,
+        notePath: path2,
+        noteContent: content
+      };
+      setComments((prev) => [...prev, newComment]);
+      return newComment;
+    }
+    return null;
+  };
+  const updateComment = async (commentId, content) => {
+    const c = server.client();
+    if (!c)
+      return;
+    if (!content.trim())
+      return;
+    const comment = comments().find((c2) => c2.id === commentId);
+    if (!comment)
+      return;
+    const result = await c.note.update({
+      id: comment.noteId.toString(),
+      content,
+      dupe: true
+    });
+    if (result.error)
+      return;
+    setComments((prev) => prev.map((c2) => c2.id === commentId ? { ...c2, noteContent: content } : c2));
+  };
+  const value = {
+    corpusId,
+    corpusName,
+    workingTreePatchId,
+    repoRoot,
+    repoPath: () => props.repoPath,
+    reviewId,
+    commitSha,
+    activePatchId,
+    workspaceEntries,
+    entries,
+    loading,
+    patches,
+    patchesLoading,
+    comments,
+    commentsLoading,
+    selectedFilePath,
+    setSelectedFilePath,
+    setActivePatch,
+    refreshWorkingTree,
+    getCommentById,
+    getCommentForRange,
+    createComment,
+    updateComment
+  };
+  return /* @__PURE__ */ jsxDEV5(ReviewContext.Provider, {
+    value,
+    children: props.children
+  }, undefined, false, undefined, this);
+}
+function useReview() {
+  const ctx = useContext3(ReviewContext);
+  if (!ctx)
+    throw new Error("useReview must be used within ReviewProvider");
+  return ctx;
+}
+
+// src/components/EditorPanel.tsx
+import { jsxDEV as jsxDEV6 } from "@opentui/solid/jsx-dev-runtime";
+function EditorPanel(props) {
+  const { theme } = useTheme();
+  const review = useReview();
+  const renderer = useRenderer();
+  let textareaRef = null;
+  let initialized = false;
+  const existingComment = props.commentId ? review.getCommentById(props.commentId) : review.getCommentForRange(props.file, props.startRow, props.endRow);
+  const initialContent = existingComment?.noteContent ?? "";
+  const shortFile = props.file.split("/").pop() ?? props.file;
+  const rangeLabel = `rows-${props.startRow}-${props.endRow}`;
+  const filename = `${shortFile}_${rangeLabel}.md`;
+  onMount3(() => {
+    setTimeout(() => {
+      initialized = true;
+    }, 0);
+  });
+  const submit = async () => {
+    if (!textareaRef)
+      return;
+    const content = textareaRef.editBuffer.getText();
+    if (!content.trim()) {
+      props.onClose();
+      return;
+    }
+    if (existingComment) {
+      await review.updateComment(existingComment.id, content);
+    } else {
+      await review.createComment(props.file, props.startRow, props.endRow, content);
+    }
+    props.onClose();
+  };
+  const openInEditor = async () => {
+    if (!textareaRef)
+      return;
+    const tmpFile = `/tmp/spall-${filename}`;
+    writeFileSync(tmpFile, textareaRef.editBuffer.getText());
+    renderer.suspend();
+    await new Promise((resolve, reject) => {
+      const editor = process.env.EDITOR || "nvim";
+      const child = spawn(editor, [tmpFile], { stdio: "inherit" });
+      child.on("close", (code) => code === 0 ? resolve() : reject(new Error(`exit ${code}`)));
+      child.on("error", reject);
+    });
+    const content = readFileSync(tmpFile, "utf-8");
+    renderer.resume();
+    if (!content.trim()) {
+      props.onClose();
+      return;
+    }
+    if (textareaRef) {
+      textareaRef.editBuffer.setText(content);
+      textareaRef.cursorOffset = content.length;
+    }
+  };
+  const handleKeyDown = (e) => {
+    if (!initialized && (e.name === "c" || e.name === "return")) {
+      e.preventDefault();
+      return;
+    }
+    if (e.name === "escape") {
+      e.preventDefault();
+      props.onClose();
+      return;
+    }
+    if (e.name === "return") {
+      e.preventDefault();
+      submit();
+      return;
+    }
+    if (e.name === "j" && e.ctrl) {
+      e.preventDefault();
+      textareaRef?.editBuffer.newLine();
+      return;
+    }
+    if (e.name === "e" && e.ctrl) {
+      e.preventDefault();
+      openInEditor();
+      return;
+    }
+  };
+  return /* @__PURE__ */ jsxDEV6("box", {
+    flexDirection: "column",
+    backgroundColor: theme.backgroundPanel,
+    flexShrink: 0,
+    children: [
+      /* @__PURE__ */ jsxDEV6("box", {
+        paddingLeft: 1,
+        paddingRight: 1,
+        paddingTop: 1,
+        paddingBottom: 1,
+        children: /* @__PURE__ */ jsxDEV6("textarea", {
+          ref: (r) => {
+            textareaRef = r;
+          },
+          initialValue: initialContent || undefined,
+          focused: true,
+          showCursor: true,
+          wrapMode: "word",
+          minHeight: 1,
+          maxHeight: 6,
+          width: "100%",
+          onKeyDown: handleKeyDown
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV6("box", {
+        height: 1,
+        paddingLeft: 1,
+        children: /* @__PURE__ */ jsxDEV6("text", {
+          fg: theme.textMuted,
+          children: filename
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+// src/components/ErrorFallback.tsx
+import { useKeyboard, useRenderer as useRenderer2 } from "@opentui/solid";
+import { jsxDEV as jsxDEV7 } from "@opentui/solid/jsx-dev-runtime";
+function ErrorFallback(props) {
+  const renderer = useRenderer2();
+  useKeyboard((key) => {
+    if (key.name === "r") {
+      props.reset();
+    }
+    if (key.name === "q" || key.raw === "\x03") {
+      renderer.destroy();
+    }
+  });
+  return /* @__PURE__ */ jsxDEV7("box", {
+    flexDirection: "column",
+    padding: 2,
+    children: [
+      /* @__PURE__ */ jsxDEV7("text", {
+        fg: "red",
+        children: [
+          "Error: ",
+          props.error.message
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV7("text", {}, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV7("text", {
+        fg: "gray",
+        children: "Press 'r' to retry or 'q' to quit"
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+// src/components/CommandPalette.tsx
+import { For as For2, createSignal as createSignal6, createMemo as createMemo3, Show as Show2 } from "solid-js";
+import { useKeyboard as useKeyboard2, useRenderer as useRenderer3, useTerminalDimensions } from "@opentui/solid";
+import { RGBA } from "@opentui/core";
+
+// src/context/command.tsx
+import { createContext as createContext4, useContext as useContext4, createSignal as createSignal4 } from "solid-js";
+import { jsxDEV as jsxDEV8 } from "@opentui/solid/jsx-dev-runtime";
+var CommandContext = createContext4();
+function CommandProvider(props) {
+  const [registrations, setRegistrations] = createSignal4([]);
+  const value = {
+    register: (commands) => {
+      setRegistrations((prev) => [...prev, commands]);
+    },
+    entries: () => registrations().flatMap((r) => r())
+  };
+  return /* @__PURE__ */ jsxDEV8(CommandContext.Provider, {
+    value,
+    children: props.children
+  }, undefined, false, undefined, this);
+}
+function useCommand() {
+  const ctx = useContext4(CommandContext);
+  if (!ctx)
+    throw new Error("useCommand must be used within CommandProvider");
+  return ctx;
+}
+
+// src/context/dialog.tsx
+import { createContext as createContext5, useContext as useContext5, createSignal as createSignal5 } from "solid-js";
+import { jsxDEV as jsxDEV9 } from "@opentui/solid/jsx-dev-runtime";
+var DialogContext = createContext5();
+function DialogProvider(props) {
+  const [content, setContent] = createSignal5(null);
+  const value = {
+    show: (element) => setContent(() => element),
+    clear: () => setContent(null),
+    isOpen: () => content() !== null,
+    content: () => {
+      const c = content();
+      return c ? c() : null;
+    }
+  };
+  return /* @__PURE__ */ jsxDEV9(DialogContext.Provider, {
+    value,
+    children: props.children
+  }, undefined, false, undefined, this);
+}
+function useDialog() {
+  const ctx = useContext5(DialogContext);
+  if (!ctx)
+    throw new Error("useDialog must be used within DialogProvider");
+  return ctx;
+}
+
+// src/lib/keybind.ts
+function matchKey(key, bind) {
+  if (key.name !== bind.name)
+    return false;
+  if ((bind.ctrl ?? false) !== key.ctrl)
+    return false;
+  if ((bind.meta ?? false) !== key.meta)
+    return false;
+  if ((bind.shift ?? false) !== key.shift)
+    return false;
+  return true;
+}
+function matchAny(key, binds) {
+  return binds.some((bind) => matchKey(key, bind));
+}
+function formatKeybind(bind) {
+  const parts = [];
+  if (bind.ctrl)
+    parts.push("C");
+  if (bind.meta)
+    parts.push("M");
+  if (bind.shift)
+    parts.push("S");
+  parts.push(bind.name);
+  return parts.join("-");
+}
+
+// src/components/CommandPalette.tsx
+import { jsxDEV as jsxDEV10, Fragment as Fragment2 } from "@opentui/solid/jsx-dev-runtime";
+var CATEGORY_ORDER = ["movement", "selection", "actions"];
+function CommandPalette() {
+  const dims = useTerminalDimensions();
+  const renderer = useRenderer3();
+  const command = useCommand();
+  const dialog = useDialog();
+  const { theme } = useTheme();
+  const [selectedIndex, setSelectedIndex] = createSignal6(0);
+  const entries = createMemo3(() => {
+    const active = command.entries().filter((cmd) => cmd.isActive());
+    const seen = new Set;
+    return active.filter((cmd) => {
+      if (seen.has(cmd.title))
+        return false;
+      seen.add(cmd.title);
+      return true;
+    });
+  });
+  const groupedEntries = createMemo3(() => {
+    const groups = [];
+    const byCategory = new Map;
+    for (const cmd of entries()) {
+      const list4 = byCategory.get(cmd.category) ?? [];
+      list4.push(cmd);
+      byCategory.set(cmd.category, list4);
+    }
+    for (const cat of CATEGORY_ORDER) {
+      const cmds = byCategory.get(cat);
+      if (cmds && cmds.length > 0) {
+        groups.push({ category: cat, commands: cmds });
+      }
+    }
+    return groups;
+  });
+  const flatEntries = createMemo3(() => {
+    return groupedEntries().flatMap((g) => g.commands);
+  });
+  useKeyboard2((key) => {
+    if (key.ctrl && (key.name === "c" || key.name === "d")) {
+      renderer.destroy();
+      return;
+    }
+    if (key.name === "escape") {
+      dialog.clear();
+      return;
+    }
+    if (key.name === "up" || key.name === "k") {
+      setSelectedIndex((i) => Math.max(0, i - 1));
+      return;
+    }
+    if (key.name === "down" || key.name === "j") {
+      setSelectedIndex((i) => Math.min(flatEntries().length - 1, i + 1));
+      return;
+    }
+    if (key.name === "return") {
+      const entry = flatEntries()[selectedIndex()];
+      if (entry) {
+        dialog.clear();
+        entry.onExecute();
+      }
+      return;
+    }
+  });
+  const width = () => Math.min(40, dims().width - 4);
+  let currentIndex = 0;
+  return /* @__PURE__ */ jsxDEV10("box", {
+    position: "absolute",
+    left: 0,
+    top: 0,
+    width: dims().width,
+    height: dims().height,
+    justifyContent: "center",
+    alignItems: "center",
+    backgroundColor: RGBA.fromInts(0, 0, 0, 150),
+    children: /* @__PURE__ */ jsxDEV10("box", {
+      width: width(),
+      flexDirection: "column",
+      backgroundColor: theme.backgroundPanel,
+      paddingTop: 1,
+      paddingBottom: 1,
+      children: [
+        /* @__PURE__ */ jsxDEV10("box", {
+          height: 1,
+          justifyContent: "center",
+          paddingLeft: 2,
+          paddingRight: 2,
+          children: /* @__PURE__ */ jsxDEV10("text", {
+            children: /* @__PURE__ */ jsxDEV10("span", {
+              style: { bold: true },
+              children: "Commands"
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV10("box", {
+          height: 1
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV10(For2, {
+          each: groupedEntries(),
+          children: (group, groupIndex) => {
+            const startIndex = createMemo3(() => {
+              let idx = 0;
+              const groups = groupedEntries();
+              for (let i = 0;i < groupIndex(); i++) {
+                idx += groups[i].commands.length;
+              }
+              return idx;
+            });
+            return /* @__PURE__ */ jsxDEV10(Fragment2, {
+              children: [
+                /* @__PURE__ */ jsxDEV10(Show2, {
+                  when: groupIndex() > 0,
+                  children: /* @__PURE__ */ jsxDEV10("box", {
+                    height: 1
+                  }, undefined, false, undefined, this)
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV10("box", {
+                  paddingLeft: 2,
+                  paddingRight: 2,
+                  children: /* @__PURE__ */ jsxDEV10("text", {
+                    fg: theme.secondary,
+                    children: /* @__PURE__ */ jsxDEV10("span", {
+                      style: { bold: true },
+                      children: group.category
+                    }, undefined, false, undefined, this)
+                  }, undefined, false, undefined, this)
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV10(For2, {
+                  each: group.commands,
+                  children: (entry, cmdIndex) => {
+                    const globalIndex = () => startIndex() + cmdIndex();
+                    return /* @__PURE__ */ jsxDEV10("box", {
+                      flexDirection: "row",
+                      justifyContent: "space-between",
+                      paddingLeft: 2,
+                      paddingRight: 2,
+                      children: [
+                        /* @__PURE__ */ jsxDEV10("text", {
+                          fg: globalIndex() === selectedIndex() ? theme.primary : undefined,
+                          children: entry.title
+                        }, undefined, false, undefined, this),
+                        /* @__PURE__ */ jsxDEV10("box", {
+                          flexDirection: "row",
+                          gap: 1,
+                          children: /* @__PURE__ */ jsxDEV10(For2, {
+                            each: entry.keybinds,
+                            children: (bind) => /* @__PURE__ */ jsxDEV10("box", {
+                              children: /* @__PURE__ */ jsxDEV10("text", {
+                                fg: theme.textMuted,
+                                children: formatKeybind(bind)
+                              }, undefined, false, undefined, this)
+                            }, undefined, false, undefined, this)
+                          }, undefined, false, undefined, this)
+                        }, undefined, false, undefined, this)
+                      ]
+                    }, undefined, true, undefined, this);
+                  }
+                }, undefined, false, undefined, this)
+              ]
+            }, undefined, true, undefined, this);
+          }
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
+// src/components/sidebar/FileList.tsx
+import { For as For3, Show as Show3, createEffect as createEffect3 } from "solid-js";
+
+// src/context/sidebar.tsx
+import {
+  createContext as createContext6,
+  useContext as useContext6
+} from "solid-js";
+import { jsxDEV as jsxDEV11 } from "@opentui/solid/jsx-dev-runtime";
+var SidebarContext = createContext6();
+function SidebarProvider(props) {
+  const value = {
+    activeSection: props.activeSection,
+    isFocused: props.isFocused
+  };
+  return /* @__PURE__ */ jsxDEV11(SidebarContext.Provider, {
+    value,
+    children: props.children
+  }, undefined, false, undefined, this);
+}
+function useSidebar() {
+  const ctx = useContext6(SidebarContext);
+  if (!ctx)
+    throw new Error("useSidebar must be used within SidebarProvider");
+  return ctx;
+}
+
+// src/components/sidebar/Section.tsx
+import { jsxDEV as jsxDEV12 } from "@opentui/solid/jsx-dev-runtime";
+function SectionTitle(props) {
+  return /* @__PURE__ */ jsxDEV12("box", {
+    flexShrink: 0,
+    children: /* @__PURE__ */ jsxDEV12("text", {
+      children: /* @__PURE__ */ jsxDEV12("span", {
+        style: { bold: true },
+        children: props.title
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+function Title(props) {
+  const { theme } = useTheme();
+  const sidebar = useSidebar();
+  const isActive = () => sidebar.activeSection() === props.section && sidebar.isFocused();
+  const title = () => props.section.charAt(0).toUpperCase() + props.section.slice(1);
+  return /* @__PURE__ */ jsxDEV12("box", {
+    flexShrink: 0,
+    border: ["left"],
+    borderColor: isActive() ? theme.primary : theme.indicatorDefault,
+    backgroundColor: isActive() ? theme.backgroundElement : theme.backgroundPanel,
+    customBorderChars: {
+      ...EmptyBorder,
+      vertical: "\u258C"
+    },
+    children: /* @__PURE__ */ jsxDEV12("text", {
+      children: /* @__PURE__ */ jsxDEV12("span", {
+        style: { bold: true },
+        children: title()
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+function Section(props) {
+  const { theme } = useTheme();
+  return /* @__PURE__ */ jsxDEV12("box", {
+    flexDirection: "column",
+    backgroundColor: theme.backgroundPanel,
+    flexShrink: 0,
+    children: [
+      /* @__PURE__ */ jsxDEV12(SectionTitle, {
+        title: props.title
+      }, undefined, false, undefined, this),
+      props.children
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/sidebar/FileList.tsx
+import { jsxDEV as jsxDEV13 } from "@opentui/solid/jsx-dev-runtime";
+var SCROLL_BUFFER = 2;
+function fileDiffStats(content) {
+  let added = 0;
+  let removed = 0;
+  for (const line of content.split(`
+`)) {
+    if (line.startsWith("+++") || line.startsWith("---"))
+      continue;
+    if (line.startsWith("+"))
+      added++;
+    else if (line.startsWith("-"))
+      removed++;
+  }
+  return { added, removed };
+}
+function FileList(props) {
+  const { theme } = useTheme();
+  let scrollbox = null;
+  const isSelected = (item) => {
+    if (item.node.type !== "file")
+      return false;
+    const selectedEntryIndex = props.fileIndices()[props.selectedFileIndex()];
+    return item.node.entryIndex === selectedEntryIndex;
+  };
+  const getSelectedDisplayIndex = () => {
+    const selectedEntryIndex = props.fileIndices()[props.selectedFileIndex()];
+    return props.displayItems().findIndex((item) => item.node.type === "file" && item.node.entryIndex === selectedEntryIndex);
+  };
+  createEffect3(() => {
+    const displayIndex = getSelectedDisplayIndex();
+    if (displayIndex < 0 || !scrollbox)
+      return;
+    const viewportHeight = scrollbox.viewport.height;
+    const scrollTop = scrollbox.scrollTop;
+    const itemTop = displayIndex;
+    const itemBottom = displayIndex + 1;
+    if (itemTop < scrollTop + SCROLL_BUFFER) {
+      scrollbox.scrollTo(Math.max(0, itemTop - SCROLL_BUFFER));
+    } else if (itemBottom > scrollTop + viewportHeight - SCROLL_BUFFER) {
+      scrollbox.scrollTo(itemBottom - viewportHeight + SCROLL_BUFFER);
+    }
+  });
+  return /* @__PURE__ */ jsxDEV13("box", {
+    flexGrow: 1,
+    flexDirection: "column",
+    backgroundColor: theme.backgroundPanel,
+    children: [
+      /* @__PURE__ */ jsxDEV13(Title, {
+        section: "files"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV13(Show3, {
+        when: props.loading(),
+        children: /* @__PURE__ */ jsxDEV13("box", {
+          children: /* @__PURE__ */ jsxDEV13("text", {
+            children: "Loading..."
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV13(Show3, {
+        when: !props.loading() && props.displayItems().length === 0,
+        children: /* @__PURE__ */ jsxDEV13("box", {
+          children: /* @__PURE__ */ jsxDEV13("text", {
+            children: "No changes found"
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV13(Show3, {
+        when: !props.loading() && props.displayItems().length > 0,
+        children: /* @__PURE__ */ jsxDEV13("scrollbox", {
+          ref: (r) => scrollbox = r,
+          flexGrow: 1,
+          children: /* @__PURE__ */ jsxDEV13(For3, {
+            each: props.displayItems(),
+            children: (item) => {
+              if (item.node.type === "dir") {
+                return /* @__PURE__ */ jsxDEV13("box", {
+                  flexDirection: "row",
+                  children: [
+                    /* @__PURE__ */ jsxDEV13(Show3, {
+                      when: item.depth > 0,
+                      children: /* @__PURE__ */ jsxDEV13("text", {
+                        children: " ".repeat(item.depth)
+                      }, undefined, false, undefined, this)
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV13("text", {
+                      children: "\u25BE "
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV13("text", {
+                      children: item.node.name
+                    }, undefined, false, undefined, this)
+                  ]
+                }, undefined, true, undefined, this);
+              }
+              const textColor = () => isSelected(item) ? theme.primary : undefined;
+              const bgColor = () => isSelected(item) ? theme.backgroundElement : theme.backgroundPanel;
+              const entryIndex = item.node.entryIndex;
+              const entry = typeof entryIndex === "number" ? props.entries()[entryIndex] : undefined;
+              const stats = entry ? fileDiffStats(entry.content) : null;
+              return /* @__PURE__ */ jsxDEV13("box", {
+                flexDirection: "row",
+                gap: 1,
+                backgroundColor: bgColor(),
+                children: [
+                  /* @__PURE__ */ jsxDEV13(Show3, {
+                    when: item.depth > 0,
+                    children: /* @__PURE__ */ jsxDEV13("text", {
+                      children: " ".repeat(item.depth)
+                    }, undefined, false, undefined, this)
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV13("text", {
+                    fg: theme.textMuted,
+                    children: item.node.status
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV13("text", {
+                    fg: textColor(),
+                    children: item.node.name
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV13(Show3, {
+                    when: !!stats && stats.added > 0,
+                    children: /* @__PURE__ */ jsxDEV13("text", {
+                      fg: theme.diffSignAdded,
+                      children: `+${stats.added}`
+                    }, undefined, false, undefined, this)
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV13(Show3, {
+                    when: !!stats && stats.removed > 0,
+                    children: /* @__PURE__ */ jsxDEV13("text", {
+                      fg: theme.diffSignRemoved,
+                      children: `-${stats.removed}`
+                    }, undefined, false, undefined, this)
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this);
+            }
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+// src/components/sidebar/CommentList.tsx
+import { For as For4, Show as Show4, createEffect as createEffect4 } from "solid-js";
+import { jsxDEV as jsxDEV14 } from "@opentui/solid/jsx-dev-runtime";
+var SCROLL_BUFFER2 = 2;
+function getShortFile(file) {
+  const segments = file.split("/");
+  return segments[segments.length - 1] || file;
+}
+function getPatchDisplay(patchId, patches, workingTreePatchId) {
+  if (patchId === null)
+    return "?";
+  if (workingTreePatchId !== null && patchId === workingTreePatchId)
+    return "WT";
+  const patch = patches.find((p) => p.id === patchId);
+  if (!patch)
+    return "?";
+  return `P${patch.seq}`;
+}
+function CommentList(props) {
+  const { theme } = useTheme();
+  const review = useReview();
+  let scrollbox = null;
+  createEffect4(() => {
+    const idx = props.selectedIndex();
+    if (idx < 0 || !scrollbox)
+      return;
+    const viewportHeight = scrollbox.viewport.height;
+    const scrollTop = scrollbox.scrollTop;
+    if (idx < scrollTop + SCROLL_BUFFER2) {
+      scrollbox.scrollTo(Math.max(0, idx - SCROLL_BUFFER2));
+    } else if (idx + 1 > scrollTop + viewportHeight - SCROLL_BUFFER2) {
+      scrollbox.scrollTo(idx - viewportHeight + SCROLL_BUFFER2 + 1);
+    }
+  });
+  const commentCount = () => props.comments().length;
+  return /* @__PURE__ */ jsxDEV14("box", {
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsxDEV14(Title, {
+        section: "comments"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV14(Show4, {
+        when: !props.loading() && commentCount() === 0,
+        children: /* @__PURE__ */ jsxDEV14("box", {
+          children: /* @__PURE__ */ jsxDEV14("text", {
+            fg: theme.textMuted,
+            children: "No comments"
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV14(Show4, {
+        when: !props.loading() && commentCount() > 0,
+        children: /* @__PURE__ */ jsxDEV14("scrollbox", {
+          ref: (r) => scrollbox = r,
+          flexGrow: 1,
+          children: /* @__PURE__ */ jsxDEV14(For4, {
+            each: props.comments(),
+            children: (comment, index) => {
+              const isSelected = () => index() === props.selectedIndex();
+              const textColor = () => isSelected() && props.focused() ? theme.primary : undefined;
+              const bgColor = () => isSelected() && props.focused() ? theme.backgroundElement : theme.backgroundPanel;
+              return /* @__PURE__ */ jsxDEV14("box", {
+                flexDirection: "row",
+                justifyContent: "space-between",
+                backgroundColor: bgColor(),
+                children: [
+                  /* @__PURE__ */ jsxDEV14("box", {
+                    flexDirection: "row",
+                    gap: 1,
+                    children: [
+                      /* @__PURE__ */ jsxDEV14("text", {
+                        fg: textColor(),
+                        children: getShortFile(comment.file)
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV14("text", {
+                        fg: theme.textMuted,
+                        children: `${comment.startRow}:${comment.endRow}`
+                      }, undefined, false, undefined, this)
+                    ]
+                  }, undefined, true, undefined, this),
+                  /* @__PURE__ */ jsxDEV14("text", {
+                    fg: theme.textMuted,
+                    children: getPatchDisplay(comment.patchId, review.patches(), review.workingTreePatchId())
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this);
+            }
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+// src/components/sidebar/PatchList.tsx
+import {
+  For as For5,
+  Show as Show5,
+  createEffect as createEffect5,
+  createSignal as createSignal7,
+  onCleanup as onCleanup2,
+  onMount as onMount4
+} from "solid-js";
+import { jsxDEV as jsxDEV15, Fragment as Fragment3 } from "@opentui/solid/jsx-dev-runtime";
+var SCROLL_BUFFER3 = 2;
+function formatTime(timestamp) {
+  const date = new Date(timestamp);
+  return date.toLocaleTimeString([], { hour: "numeric", minute: "2-digit" });
+}
+function diffStats(content) {
+  let added = 0;
+  let removed = 0;
+  for (const line of content.split(`
+`)) {
+    if (line.startsWith("+++") || line.startsWith("---"))
+      continue;
+    if (line.startsWith("+"))
+      added++;
+    else if (line.startsWith("-"))
+      removed++;
+  }
+  return { added, removed };
+}
+function sumEntryStats(entries) {
+  let added = 0;
+  let removed = 0;
+  for (const e of entries) {
+    const s = diffStats(e.content);
+    added += s.added;
+    removed += s.removed;
+  }
+  return { added, removed };
+}
+function PatchList(props) {
+  const { theme } = useTheme();
+  let scrollbox = null;
+  const [now, setNow] = createSignal7(Date.now());
+  onMount4(() => {
+    let interval = null;
+    const start = () => {
+      const ms = Date.now();
+      const nextMinute = Math.ceil(ms / 60000) * 60000;
+      const delay = Math.max(0, nextMinute - ms);
+      const timeout = setTimeout(() => {
+        setNow(Date.now());
+        interval = setInterval(() => setNow(Date.now()), 60000);
+      }, delay);
+      onCleanup2(() => clearTimeout(timeout));
+    };
+    start();
+    onCleanup2(() => {
+      if (interval)
+        clearInterval(interval);
+    });
+  });
+  createEffect5(() => {
+    const idx = props.selectedIndex();
+    if (idx < 0 || !scrollbox)
+      return;
+    const viewportHeight = scrollbox.viewport.height;
+    const scrollTop = scrollbox.scrollTop;
+    if (idx < scrollTop + SCROLL_BUFFER3) {
+      scrollbox.scrollTo(Math.max(0, idx - SCROLL_BUFFER3));
+    } else if (idx + 1 > scrollTop + viewportHeight - SCROLL_BUFFER3) {
+      scrollbox.scrollTo(idx - viewportHeight + SCROLL_BUFFER3 + 1);
+    }
+  });
+  const items = () => {
+    const patchList = props.patches();
+    const wt = props.workingTreePatchId();
+    return [
+      { type: "workspace", id: wt, seq: -1, createdAt: now() },
+      ...patchList.slice().filter((p) => wt === null ? true : p.id !== wt).sort((a, b) => b.seq - a.seq).map((p) => ({ type: "patch", ...p }))
+    ];
+  };
+  const patchCount = () => {
+    const wt = props.workingTreePatchId();
+    const list4 = props.patches();
+    return wt === null ? list4.length : list4.filter((p) => p.id !== wt).length;
+  };
+  return /* @__PURE__ */ jsxDEV15("box", {
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsxDEV15(Title, {
+        section: "patches"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV15(Show5, {
+        when: props.loading(),
+        children: /* @__PURE__ */ jsxDEV15("box", {
+          children: /* @__PURE__ */ jsxDEV15("text", {
+            fg: theme.textMuted,
+            children: "Loading..."
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV15(Show5, {
+        when: !props.loading() && patchCount() === 0,
+        children: /* @__PURE__ */ jsxDEV15("box", {
+          children: /* @__PURE__ */ jsxDEV15("box", {
+            flexDirection: "row",
+            justifyContent: "space-between",
+            children: [
+              /* @__PURE__ */ jsxDEV15("box", {
+                flexDirection: "row",
+                gap: 1,
+                children: [
+                  /* @__PURE__ */ jsxDEV15(Show5, {
+                    when: props.workingTreePatchId() !== null && props.activePatchId() === props.workingTreePatchId(),
+                    children: /* @__PURE__ */ jsxDEV15("text", {
+                      fg: theme.primary,
+                      children: "\u25B8"
+                    }, undefined, false, undefined, this)
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV15(Show5, {
+                    when: props.workingTreePatchId() === null || props.activePatchId() !== props.workingTreePatchId(),
+                    children: /* @__PURE__ */ jsxDEV15("text", {
+                      fg: theme.textMuted,
+                      children: " "
+                    }, undefined, false, undefined, this)
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV15("text", {
+                    fg: props.focused() ? theme.primary : undefined,
+                    children: "Working tree"
+                  }, undefined, false, undefined, this),
+                  (() => {
+                    const s = sumEntryStats(props.workspaceEntries());
+                    if (s.added === 0 && s.removed === 0)
+                      return null;
+                    return /* @__PURE__ */ jsxDEV15(Fragment3, {
+                      children: [
+                        /* @__PURE__ */ jsxDEV15("text", {
+                          fg: theme.diffSignAdded,
+                          children: "+"
+                        }, undefined, false, undefined, this),
+                        /* @__PURE__ */ jsxDEV15("text", {
+                          fg: theme.textMuted,
+                          children: s.added
+                        }, undefined, false, undefined, this),
+                        /* @__PURE__ */ jsxDEV15("text", {
+                          fg: theme.diffSignRemoved,
+                          children: "-"
+                        }, undefined, false, undefined, this),
+                        /* @__PURE__ */ jsxDEV15("text", {
+                          fg: theme.textMuted,
+                          children: s.removed
+                        }, undefined, false, undefined, this)
+                      ]
+                    }, undefined, true, undefined, this);
+                  })()
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsxDEV15("text", {
+                fg: theme.textMuted,
+                children: formatTime(now())
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV15(Show5, {
+        when: !props.loading() && patchCount() > 0,
+        children: /* @__PURE__ */ jsxDEV15("scrollbox", {
+          ref: (r) => scrollbox = r,
+          flexGrow: 1,
+          children: /* @__PURE__ */ jsxDEV15(For5, {
+            each: items(),
+            children: (item, index) => {
+              const isSelected = () => index() === props.selectedIndex();
+              const isActive = () => {
+                if (item.type === "workspace")
+                  return item.id !== null && props.activePatchId() === item.id;
+                return props.activePatchId() === item.id;
+              };
+              const textColor = () => isActive() ? theme.primary : undefined;
+              const bgColor = () => isSelected() && props.focused() ? theme.backgroundElement : theme.backgroundPanel;
+              const label = () => item.type === "workspace" ? "Working tree" : `P${item.seq}`;
+              const delta = () => item.type === "workspace" ? sumEntryStats(props.workspaceEntries()) : diffStats(item.content);
+              return /* @__PURE__ */ jsxDEV15("box", {
+                flexDirection: "row",
+                justifyContent: "space-between",
+                backgroundColor: bgColor(),
+                children: [
+                  /* @__PURE__ */ jsxDEV15("box", {
+                    flexDirection: "row",
+                    gap: 1,
+                    children: [
+                      /* @__PURE__ */ jsxDEV15("text", {
+                        fg: textColor(),
+                        children: label()
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV15(Show5, {
+                        when: delta() && (delta().added > 0 || delta().removed > 0),
+                        children: [
+                          /* @__PURE__ */ jsxDEV15("text", {
+                            fg: theme.diffSignAdded,
+                            children: [
+                              "+",
+                              delta().added
+                            ]
+                          }, undefined, true, undefined, this),
+                          /* @__PURE__ */ jsxDEV15("text", {
+                            fg: theme.diffSignRemoved,
+                            children: [
+                              "-",
+                              delta().removed
+                            ]
+                          }, undefined, true, undefined, this)
+                        ]
+                      }, undefined, true, undefined, this)
+                    ]
+                  }, undefined, true, undefined, this),
+                  /* @__PURE__ */ jsxDEV15("text", {
+                    fg: theme.textMuted,
+                    children: formatTime(item.createdAt)
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this);
+            }
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+// src/components/sidebar/ServerStatus.tsx
+import { jsxDEV as jsxDEV16 } from "@opentui/solid/jsx-dev-runtime";
+function ServerStatus() {
+  const { theme } = useTheme();
+  const server = useServer();
+  return /* @__PURE__ */ jsxDEV16(Section, {
+    title: "Server",
+    children: /* @__PURE__ */ jsxDEV16("box", {
+      flexDirection: "row",
+      gap: 1,
+      backgroundColor: theme.backgroundPanel,
+      height: 1,
+      children: [
+        /* @__PURE__ */ jsxDEV16("text", {
+          fg: server.connected() ? theme.connected : theme.disconnected,
+          children: "\u2022"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV16("text", {
+          fg: server.connected() ? theme.text : theme.textMuted,
+          children: server.url() ?? "disconnected"
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
+// src/components/sidebar/ProjectStatus.tsx
+import { Show as Show6 } from "solid-js";
+import { basename, dirname as dirname2 } from "path";
+import { jsxDEV as jsxDEV17 } from "@opentui/solid/jsx-dev-runtime";
+function ProjectStatus(props) {
+  const { theme } = useTheme();
+  const displayName = () => {
+    const root = props.repoRoot();
+    return root ? basename(root) : null;
+  };
+  return /* @__PURE__ */ jsxDEV17(Section, {
+    title: "Review",
+    children: [
+      /* @__PURE__ */ jsxDEV17(Show6, {
+        when: displayName(),
+        children: /* @__PURE__ */ jsxDEV17("box", {
+          flexDirection: "row",
+          flexShrink: 0,
+          children: [
+            /* @__PURE__ */ jsxDEV17("text", {
+              fg: theme.text,
+              children: displayName()
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV17("text", {
+              fg: theme.textMuted,
+              children: [
+                " (",
+                props.commentCount(),
+                " comments)"
+              ]
+            }, undefined, true, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV17(Show6, {
+        when: props.repoRoot(),
+        children: /* @__PURE__ */ jsxDEV17("box", {
+          flexDirection: "row",
+          flexShrink: 0,
+          children: [
+            /* @__PURE__ */ jsxDEV17("text", {
+              fg: theme.textMuted,
+              children: [
+                dirname2(props.repoRoot()),
+                "/"
+              ]
+            }, undefined, true, undefined, this),
+            /* @__PURE__ */ jsxDEV17("text", {
+              fg: theme.text,
+              children: basename(props.repoRoot())
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+// src/lib/tree.ts
+function buildFileTree(entries) {
+  const root = [];
+  for (let i = 0;i < entries.length; i++) {
+    const entry = entries[i];
+    const parts = entry.file.split("/");
+    insertPath(root, parts, 0, entry, i);
+  }
+  sortTree(root);
+  return root;
+}
+function insertPath(nodes, parts, partIndex, entry, entryIndex) {
+  if (partIndex >= parts.length)
+    return;
+  const name = parts[partIndex];
+  const isLastPart = partIndex === parts.length - 1;
+  const fullPath = parts.slice(0, partIndex + 1).join("/");
+  let node = nodes.find((n) => n.name === name);
+  if (!node) {
+    node = {
+      name,
+      path: fullPath,
+      type: isLastPart ? "file" : "dir",
+      children: []
+    };
+    if (isLastPart) {
+      node.status = entry.isDeleted ? "D" : entry.isNew ? "A" : "M";
+      node.entryIndex = entryIndex;
+    }
+    nodes.push(node);
+  }
+  if (!isLastPart && node) {
+    insertPath(node.children, parts, partIndex + 1, entry, entryIndex);
+  }
+}
+function sortTree(nodes) {
+  nodes.sort((a, b) => {
+    if (a.type !== b.type) {
+      return a.type === "dir" ? -1 : 1;
+    }
+    return a.name.localeCompare(b.name);
+  });
+  for (const node of nodes) {
+    if (node.children.length > 0) {
+      sortTree(node.children);
+    }
+  }
+}
+function flattenTree(nodes) {
+  const items = [];
+  flattenNodes(nodes, 0, items);
+  return items;
+}
+function flattenNodes(nodes, depth, items) {
+  for (const node of nodes) {
+    if (node.type === "dir") {
+      const collapsed = collapseDir(node);
+      items.push({ node: collapsed, depth });
+      flattenNodes(collapsed.children, depth + 1, items);
+    } else {
+      items.push({ node, depth });
+    }
+  }
+}
+function collapseDir(node) {
+  let current = node;
+  const nameParts = [current.name];
+  while (current.children.length === 1 && current.children[0].type === "dir") {
+    current = current.children[0];
+    nameParts.push(current.name);
+  }
+  if (nameParts.length === 1) {
+    return node;
+  }
+  return {
+    name: nameParts.join("/"),
+    path: current.path,
+    type: "dir",
+    children: current.children
+  };
+}
+function getFileIndices(items) {
+  const indices = [];
+  for (const item of items) {
+    if (item.node.type === "file" && item.node.entryIndex !== undefined) {
+      indices.push(item.node.entryIndex);
+    }
+  }
+  return indices;
+}
+
+// src/context/exit.tsx
+import { createContext as createContext7, useContext as useContext7 } from "solid-js";
+import { useRenderer as useRenderer4 } from "@opentui/solid";
+import { jsxDEV as jsxDEV18 } from "@opentui/solid/jsx-dev-runtime";
+var ExitContext = createContext7();
+function ExitProvider(props) {
+  const renderer = useRenderer4();
+  const cleanupFns = [];
+  const registerCleanup = (fn) => {
+    cleanupFns.push(fn);
+  };
+  const exit = async (reason) => {
+    for (const fn of cleanupFns) {
+      try {
+        await fn();
+      } catch {}
+    }
+    renderer.destroy();
+    if (reason) {
+      const message = reason instanceof Error ? reason.message : String(reason);
+      process.stderr.write(message + `
+`);
+    }
+    process.exit(0);
+  };
+  return /* @__PURE__ */ jsxDEV18(ExitContext.Provider, {
+    value: { exit, registerCleanup },
+    children: props.children
+  }, undefined, false, undefined, this);
+}
+function useExit() {
+  const ctx = useContext7(ExitContext);
+  if (!ctx)
+    throw new Error("useExit must be used within ExitProvider");
+  return ctx;
+}
+
+// src/Review.tsx
+import { jsxDEV as jsxDEV19 } from "@opentui/solid/jsx-dev-runtime";
+function Review(props = {}) {
+  const repoPath = props.repoPath ?? process.argv[2] ?? ".";
+  return /* @__PURE__ */ jsxDEV19(ThemeProvider, {
+    children: /* @__PURE__ */ jsxDEV19(ExitProvider, {
+      children: /* @__PURE__ */ jsxDEV19(ServerProvider, {
+        children: /* @__PURE__ */ jsxDEV19(ReviewProvider, {
+          repoPath,
+          children: /* @__PURE__ */ jsxDEV19(DialogProvider, {
+            children: /* @__PURE__ */ jsxDEV19(CommandProvider, {
+              children: /* @__PURE__ */ jsxDEV19(App, {
+                repoPath
+              }, undefined, false, undefined, this)
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+function App(props) {
+  const dims = useTerminalDimensions2();
+  const dialog = useDialog();
+  const command = useCommand();
+  const { theme } = useTheme();
+  const { exit } = useExit();
+  const review = useReview();
+  const displayItems = createMemo4(() => {
+    const e = review.entries();
+    if (e.length === 0)
+      return [];
+    const tree = buildFileTree(e);
+    return flattenTree(tree);
+  });
+  const fileIndices = createMemo4(() => getFileIndices(displayItems()));
+  createEffect6(() => {
+    const indices = fileIndices();
+    const entries = review.entries();
+    const current = review.selectedFilePath();
+    if (indices.length === 0) {
+      review.setSelectedFilePath(null);
+      return;
+    }
+    if (!current || !entries.some((e) => e.file === current)) {
+      const firstEntryIndex = indices[0];
+      review.setSelectedFilePath(entries[firstEntryIndex]?.file ?? null);
+    }
+  });
+  const [focusPanel, setFocusPanel] = createSignal8("sidebar");
+  const [sidebarMode, setSidebarMode] = createSignal8("files");
+  const [selectedHunkIndex, setSelectedHunkIndex] = createSignal8(0);
+  const [selectionMode, setSelectionMode] = createSignal8("hunk");
+  const [selectedRange, setSelectedRange] = createSignal8(null);
+  const [cursorRow, setCursorRow] = createSignal8(1);
+  const [editorAnchor, setEditorAnchor] = createSignal8(null);
+  const [selectedCommentIndex, setSelectedCommentIndex] = createSignal8(0);
+  const [selectedPatchIndex, setSelectedPatchIndex] = createSignal8(0);
+  const selectedFileNavIndex = createMemo4(() => {
+    const indices = fileIndices();
+    if (indices.length === 0)
+      return 0;
+    const entries = review.entries();
+    const path2 = review.selectedFilePath();
+    if (!path2)
+      return 0;
+    const entryIndex = entries.findIndex((e) => e.file === path2);
+    if (entryIndex === -1)
+      return 0;
+    const navIndex = indices.indexOf(entryIndex);
+    return navIndex === -1 ? 0 : navIndex;
+  });
+  const selectedEntry = () => {
+    const entries = review.entries();
+    if (entries.length === 0)
+      return;
+    const path2 = review.selectedFilePath();
+    if (path2) {
+      const found = entries.find((e) => e.file === path2);
+      if (found)
+        return found;
+    }
+    const firstEntryIndex = fileIndices()[0];
+    if (firstEntryIndex !== undefined)
+      return entries[firstEntryIndex];
+    return entries[0];
+  };
+  const diffModel = createMemo4(() => {
+    const entry = selectedEntry();
+    if (!entry)
+      return { hunks: [], totalRows: 0 };
+    return parseFileDiff(entry.content, entry.file);
+  });
+  const hunkCount = createMemo4(() => diffModel().hunks.length);
+  const totalRows = createMemo4(() => diffModel().totalRows);
+  const selectedHunkRange = createMemo4(() => {
+    const entry = selectedEntry();
+    if (!entry)
+      return null;
+    const hunk = diffModel().hunks[selectedHunkIndex()];
+    if (!hunk)
+      return null;
+    return { startRow: hunk.startRow, endRow: hunk.endRow };
+  });
+  const [previousFile, setPreviousFile] = createSignal8(null);
+  createEffect6(() => {
+    review.selectedFilePath();
+    review.activePatchId();
+    const currentFile = selectedEntry()?.file ?? null;
+    const prevFile = previousFile();
+    if (currentFile !== prevFile) {
+      setSelectedHunkIndex(0);
+      setSelectionMode("hunk");
+      setSelectedRange(null);
+      setCursorRow(1);
+    } else if (currentFile !== null) {
+      const maxHunk = Math.max(0, hunkCount() - 1);
+      setSelectedHunkIndex((i) => Math.min(i, maxHunk));
+      const maxRow = totalRows();
+      if (maxRow > 0) {
+        setSelectedRange((range) => {
+          if (!range)
+            return null;
+          const clippedStart = Math.min(range.startRow, maxRow);
+          const clippedEnd = Math.min(range.endRow, maxRow);
+          if (clippedStart === clippedEnd && clippedStart === maxRow && maxRow > 1) {
+            return { startRow: maxRow - 1, endRow: maxRow };
+          }
+          return { startRow: clippedStart, endRow: clippedEnd };
+        });
+        setCursorRow((r) => Math.min(Math.max(1, r), maxRow));
+      }
+    }
+    setPreviousFile(currentFile);
+  });
+  const clampRow = (row) => {
+    const max = Math.max(1, totalRows());
+    return Math.min(Math.max(1, row), max);
+  };
+  const setSelectedNavIndex = (navIndex) => {
+    const entryIndex = fileIndices()[navIndex];
+    const entry = entryIndex !== undefined ? review.entries()[entryIndex] : null;
+    review.setSelectedFilePath(entry?.file ?? null);
+  };
+  const navigateUp = () => {
+    const panel = focusPanel();
+    if (panel === "sidebar") {
+      if (sidebarMode() === "files") {
+        setSelectedNavIndex(Math.max(0, selectedFileNavIndex() - 1));
+      } else if (sidebarMode() === "patches") {
+        setSelectedPatchIndex((i) => Math.max(0, i - 1));
+      } else {
+        setSelectedCommentIndex((i) => Math.max(0, i - 1));
+      }
+      return;
+    }
+    if (panel === "diff" && selectionMode() === "line") {
+      const next = clampRow(cursorRow() - 1);
+      setCursorRow(next);
+      setSelectedRange({ startRow: next, endRow: next });
+      return;
+    }
+    if (panel === "diff") {
+      setSelectedHunkIndex((i) => Math.max(0, i - 1));
+    }
+  };
+  const navigateDown = () => {
+    const panel = focusPanel();
+    if (panel === "sidebar") {
+      if (sidebarMode() === "files") {
+        setSelectedNavIndex(Math.min(fileIndices().length - 1, selectedFileNavIndex() + 1));
+      } else if (sidebarMode() === "patches") {
+        const wt = review.workingTreePatchId();
+        const patchCount = (wt === null ? review.patches().length : review.patches().filter((p) => p.id !== wt).length) + 1;
+        setSelectedPatchIndex((i) => Math.min(patchCount - 1, i + 1));
+      } else {
+        const maxIndex = review.comments().length - 1;
+        setSelectedCommentIndex((i) => Math.min(maxIndex, i + 1));
+      }
+      return;
+    }
+    if (panel === "diff" && selectionMode() === "line") {
+      const next = clampRow(cursorRow() + 1);
+      setCursorRow(next);
+      setSelectedRange({ startRow: next, endRow: next });
+      return;
+    }
+    if (panel === "diff") {
+      setSelectedHunkIndex((i) => Math.min(hunkCount() - 1, i + 1));
+    }
+  };
+  const openCommentEditor = () => {
+    const entry = selectedEntry();
+    const range = selectionMode() === "line" ? selectedRange() : selectedHunkRange();
+    if (!entry || !range)
+      return;
+    const existing = review.getCommentForRange(entry.file, range.startRow, range.endRow);
+    setEditorAnchor({
+      file: entry.file,
+      startRow: range.startRow,
+      endRow: range.endRow,
+      commentId: existing?.id
+    });
+    setFocusPanel("editor");
+  };
+  const toggleSidebarMode = () => {
+    setSidebarMode((m) => {
+      if (m === "files")
+        return "patches";
+      if (m === "patches")
+        return "comments";
+      return "files";
+    });
+  };
+  const toggleHunkSelection = () => {
+    const range = selectedHunkRange();
+    if (!range)
+      return;
+    if (selectedRange()) {
+      setSelectedRange(null);
+      return;
+    }
+    setSelectionMode("hunk");
+    setSelectedRange(range);
+  };
+  const toggleLineMode = () => {
+    if (totalRows() === 0)
+      return;
+    if (selectionMode() === "hunk") {
+      const range2 = selectedRange() ?? selectedHunkRange();
+      const row = clampRow(range2?.startRow ?? 1);
+      setSelectionMode("line");
+      setCursorRow(row);
+      setSelectedRange({ startRow: row, endRow: row });
+      return;
+    }
+    const entry = selectedEntry();
+    const range = selectedRange();
+    if (entry && range) {
+      const hunkIndex = getHunkIndexForRow(entry.content, entry.file, range.startRow) ?? 0;
+      setSelectedHunkIndex(hunkIndex);
+    }
+    setSelectionMode("hunk");
+    setSelectedRange(null);
+  };
+  const extendSelectionDown = () => {
+    if (selectionMode() !== "line")
+      return;
+    const range = selectedRange() ?? {
+      startRow: cursorRow(),
+      endRow: cursorRow()
+    };
+    const next = clampRow(range.endRow + 1);
+    setSelectedRange({ startRow: range.startRow, endRow: next });
+    setCursorRow(next);
+  };
+  const extendSelectionUp = () => {
+    if (selectionMode() !== "line")
+      return;
+    const range = selectedRange() ?? {
+      startRow: cursorRow(),
+      endRow: cursorRow()
+    };
+    const next = clampRow(range.startRow - 1);
+    setSelectedRange({ startRow: next, endRow: range.endRow });
+    setCursorRow(next);
+  };
+  const commands = () => [
+    {
+      id: "up",
+      title: "up",
+      category: "movement",
+      keybinds: [{ name: "up" }, { name: "k" }],
+      isActive: () => focusPanel() !== "editor",
+      onExecute: navigateUp
+    },
+    {
+      id: "down",
+      title: "down",
+      category: "movement",
+      keybinds: [{ name: "down" }, { name: "j" }],
+      isActive: () => focusPanel() !== "editor",
+      onExecute: navigateDown
+    },
+    {
+      id: "back-from-diff",
+      title: "back",
+      category: "movement",
+      keybinds: [{ name: "escape" }],
+      isActive: () => focusPanel() === "diff",
+      onExecute: () => {
+        setFocusPanel("sidebar");
+        setSelectedHunkIndex(0);
+      }
+    },
+    {
+      id: "quit",
+      title: "quit",
+      category: "movement",
+      keybinds: [
+        { name: "c", ctrl: true },
+        { name: "d", ctrl: true },
+        { name: "q", ctrl: true }
+      ],
+      isActive: () => focusPanel() !== "editor",
+      onExecute: () => exit()
+    },
+    {
+      id: "refresh-working-tree",
+      title: "refresh working tree",
+      category: "movement",
+      keybinds: [{ name: "r", ctrl: true }],
+      isActive: () => focusPanel() !== "editor",
+      onExecute: () => {
+        const preserve = selectedEntry()?.file ?? review.selectedFilePath();
+        review.refreshWorkingTree(preserve ?? undefined);
+      }
+    },
+    {
+      id: "cycle-forward",
+      title: "cycle forward",
+      category: "movement",
+      keybinds: [{ name: "tab" }],
+      isActive: () => focusPanel() !== "editor",
+      onExecute: () => {
+        if (focusPanel() === "sidebar") {
+          if (sidebarMode() === "files") {
+            setSidebarMode("patches");
+          } else if (sidebarMode() === "patches") {
+            setSidebarMode("comments");
+          } else {
+            setFocusPanel("diff");
+            setSelectedHunkIndex(0);
+          }
+        } else if (focusPanel() === "diff") {
+          setFocusPanel("sidebar");
+          setSidebarMode("files");
+        }
+      }
+    },
+    {
+      id: "cycle-backward",
+      title: "cycle backward",
+      category: "movement",
+      keybinds: [{ name: "tab", shift: true }],
+      isActive: () => focusPanel() !== "editor",
+      onExecute: () => {
+        if (focusPanel() === "sidebar") {
+          if (sidebarMode() === "files") {
+            setFocusPanel("diff");
+            setSelectedHunkIndex(0);
+          } else if (sidebarMode() === "patches") {
+            setSidebarMode("files");
+          } else {
+            setSidebarMode("patches");
+          }
+        } else if (focusPanel() === "diff") {
+          setFocusPanel("sidebar");
+          setSidebarMode("comments");
+        }
+      }
+    },
+    {
+      id: "select-hunks",
+      title: "select hunks",
+      category: "selection",
+      keybinds: [{ name: "return" }],
+      isActive: () => focusPanel() === "sidebar" && sidebarMode() === "files" && !!selectedEntry() && hunkCount() > 0,
+      onExecute: () => {
+        setFocusPanel("diff");
+        setSelectedHunkIndex(0);
+        setSelectionMode("hunk");
+        setSelectedRange(null);
+      }
+    },
+    {
+      id: "select-lines",
+      title: "select by lines",
+      category: "selection",
+      keybinds: [{ name: "a" }],
+      isActive: () => focusPanel() === "diff" && totalRows() > 0,
+      onExecute: toggleLineMode
+    },
+    {
+      id: "toggle-hunk-selection",
+      title: "toggle hunk selection",
+      category: "selection",
+      keybinds: [{ name: "space" }],
+      isActive: () => focusPanel() === "diff" && selectionMode() === "hunk" && selectedHunkRange() !== null,
+      onExecute: toggleHunkSelection
+    },
+    {
+      id: "extend-down",
+      title: "extend selection down",
+      category: "selection",
+      keybinds: [
+        { name: "j", shift: true },
+        { name: "down", shift: true }
+      ],
+      isActive: () => focusPanel() === "diff" && selectionMode() === "line",
+      onExecute: extendSelectionDown
+    },
+    {
+      id: "extend-up",
+      title: "extend selection up",
+      category: "selection",
+      keybinds: [
+        { name: "k", shift: true },
+        { name: "up", shift: true }
+      ],
+      isActive: () => focusPanel() === "diff" && selectionMode() === "line",
+      onExecute: extendSelectionUp
+    },
+    {
+      id: "open-comment",
+      title: "open comment",
+      category: "selection",
+      keybinds: [{ name: "return" }],
+      isActive: () => focusPanel() === "sidebar" && sidebarMode() === "comments" && review.comments().length > 0,
+      onExecute: () => {
+        const comments = review.comments();
+        const idx = selectedCommentIndex();
+        const comment = comments[idx];
+        if (!comment)
+          return;
+        review.setActivePatch(comment.patchId, comment.file);
+        review.setSelectedFilePath(comment.file);
+        const entry = review.entries().find((e) => e.file === comment.file);
+        const hunkIndex = entry ? getHunkIndexForRow(entry.content, entry.file, comment.startRow) ?? 0 : 0;
+        setSelectedHunkIndex(hunkIndex);
+        setEditorAnchor({
+          file: comment.file,
+          startRow: comment.startRow,
+          endRow: comment.endRow,
+          commentId: comment.id
+        });
+        setFocusPanel("editor");
+      }
+    },
+    {
+      id: "select-patch",
+      title: "select patch",
+      category: "selection",
+      keybinds: [{ name: "return" }],
+      isActive: () => focusPanel() === "sidebar" && sidebarMode() === "patches" && review.patches().length > 0,
+      onExecute: () => {
+        const wt = review.workingTreePatchId();
+        const patches = review.patches().slice().filter((p) => wt === null ? true : p.id !== wt).sort((a, b) => b.seq - a.seq);
+        const idx = selectedPatchIndex();
+        const currentEntry = selectedEntry();
+        const currentFile = currentEntry?.file;
+        if (idx === 0) {
+          if (wt !== null)
+            review.setActivePatch(wt, currentFile);
+        } else {
+          const patch = patches[idx - 1];
+          if (patch) {
+            review.setActivePatch(patch.id, currentFile);
+          }
+        }
+      }
+    },
+    {
+      id: "comment",
+      title: "comment",
+      category: "actions",
+      keybinds: [{ name: "c" }],
+      isActive: () => focusPanel() === "diff" && (selectionMode() === "hunk" && selectedHunkRange() !== null || selectionMode() === "line" && selectedRange() !== null),
+      onExecute: openCommentEditor
+    }
+  ];
+  command.register(commands);
+  useKeyboard3((key) => {
+    if (key.ctrl && key.name === "p") {
+      dialog.show(() => /* @__PURE__ */ jsxDEV19(CommandPalette, {}, undefined, false, undefined, this));
+      return;
+    }
+    if (dialog.isOpen())
+      return;
+    for (const cmd of commands()) {
+      if (cmd.isActive() && matchAny(key, cmd.keybinds)) {
+        cmd.onExecute();
+        return;
+      }
+    }
+  });
+  const Footer = () => /* @__PURE__ */ jsxDEV19("box", {
+    height: 1,
+    paddingLeft: 1,
+    flexDirection: "row",
+    gap: 2,
+    children: [
+      /* @__PURE__ */ jsxDEV19("box", {
+        flexDirection: "row",
+        children: [
+          /* @__PURE__ */ jsxDEV19("text", {
+            children: "j/k "
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV19("text", {
+            fg: "brightBlack",
+            children: "navigate"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV19(Show7, {
+        when: focusPanel() === "sidebar",
+        children: /* @__PURE__ */ jsxDEV19("box", {
+          flexDirection: "row",
+          children: [
+            /* @__PURE__ */ jsxDEV19("text", {
+              children: "tab "
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV19("text", {
+              fg: "brightBlack",
+              children: "switch"
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV19(Show7, {
+        when: focusPanel() === "diff" && (selectionMode() === "hunk" && selectedHunkRange() !== null || selectionMode() === "line" && selectedRange()),
+        children: /* @__PURE__ */ jsxDEV19("box", {
+          flexDirection: "row",
+          children: [
+            /* @__PURE__ */ jsxDEV19("text", {
+              children: "c "
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV19("text", {
+              fg: "brightBlack",
+              children: "comment"
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV19(Show7, {
+        when: focusPanel() === "editor",
+        children: [
+          /* @__PURE__ */ jsxDEV19("box", {
+            flexDirection: "row",
+            children: [
+              /* @__PURE__ */ jsxDEV19("text", {
+                children: "enter "
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV19("text", {
+                fg: "brightBlack",
+                children: "submit"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV19("box", {
+            flexDirection: "row",
+            children: [
+              /* @__PURE__ */ jsxDEV19("text", {
+                children: "C-j "
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV19("text", {
+                fg: "brightBlack",
+                children: "newline"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV19("box", {
+            flexDirection: "row",
+            children: [
+              /* @__PURE__ */ jsxDEV19("text", {
+                children: "C-e "
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV19("text", {
+                fg: "brightBlack",
+                children: "editor"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV19("box", {
+            flexDirection: "row",
+            children: [
+              /* @__PURE__ */ jsxDEV19("text", {
+                children: "esc "
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV19("text", {
+                fg: "brightBlack",
+                children: "cancel"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV19(Show7, {
+        when: focusPanel() !== "editor",
+        children: /* @__PURE__ */ jsxDEV19("box", {
+          flexDirection: "row",
+          children: [
+            /* @__PURE__ */ jsxDEV19("text", {
+              children: "esc "
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV19("text", {
+              fg: "brightBlack",
+              children: "back"
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV19(Show7, {
+        when: focusPanel() !== "editor",
+        children: /* @__PURE__ */ jsxDEV19("box", {
+          flexDirection: "row",
+          children: [
+            /* @__PURE__ */ jsxDEV19("text", {
+              children: "C-r "
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV19("text", {
+              fg: "brightBlack",
+              children: "refresh"
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV19(Show7, {
+        when: focusPanel() !== "editor",
+        children: /* @__PURE__ */ jsxDEV19("box", {
+          flexDirection: "row",
+          children: [
+            /* @__PURE__ */ jsxDEV19("text", {
+              children: "C-q "
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV19("text", {
+              fg: "brightBlack",
+              children: "quit"
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+  return /* @__PURE__ */ jsxDEV19("box", {
+    flexDirection: "column",
+    width: dims().width,
+    height: dims().height,
+    backgroundColor: theme.background,
+    children: [
+      /* @__PURE__ */ jsxDEV19("box", {
+        flexGrow: 1,
+        flexDirection: "row",
+        gap: 1,
+        children: [
+          /* @__PURE__ */ jsxDEV19("box", {
+            width: 40,
+            flexDirection: "column",
+            gap: 1,
+            paddingTop: 1,
+            paddingBottom: 1,
+            paddingLeft: 2,
+            paddingRight: 2,
+            backgroundColor: theme.backgroundPanel,
+            children: [
+              /* @__PURE__ */ jsxDEV19(ServerStatus, {}, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV19(ProjectStatus, {
+                repoRoot: review.repoRoot,
+                commentCount: () => review.comments().length
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV19(SidebarProvider, {
+                activeSection: sidebarMode,
+                isFocused: () => focusPanel() === "sidebar",
+                children: /* @__PURE__ */ jsxDEV19("box", {
+                  flexGrow: 1,
+                  flexDirection: "column",
+                  overflow: "hidden",
+                  gap: 1,
+                  children: [
+                    /* @__PURE__ */ jsxDEV19("box", {
+                      flexGrow: 1,
+                      children: /* @__PURE__ */ jsxDEV19(FileList, {
+                        displayItems,
+                        selectedFileIndex: selectedFileNavIndex,
+                        fileIndices,
+                        entries: review.entries,
+                        loading: review.loading,
+                        focused: () => focusPanel() === "sidebar" && sidebarMode() === "files"
+                      }, undefined, false, undefined, this)
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV19("box", {
+                      flexGrow: 1,
+                      flexDirection: "column",
+                      children: /* @__PURE__ */ jsxDEV19(PatchList, {
+                        patches: review.patches,
+                        activePatchId: review.activePatchId,
+                        workingTreePatchId: review.workingTreePatchId,
+                        workspaceEntries: review.workspaceEntries,
+                        loading: review.patchesLoading,
+                        selectedIndex: selectedPatchIndex,
+                        focused: () => focusPanel() === "sidebar" && sidebarMode() === "patches"
+                      }, undefined, false, undefined, this)
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV19("box", {
+                      flexGrow: 1,
+                      flexDirection: "column",
+                      children: /* @__PURE__ */ jsxDEV19(CommentList, {
+                        comments: review.comments,
+                        loading: review.commentsLoading,
+                        selectedIndex: selectedCommentIndex,
+                        focused: () => focusPanel() === "sidebar" && sidebarMode() === "comments"
+                      }, undefined, false, undefined, this)
+                    }, undefined, false, undefined, this)
+                  ]
+                }, undefined, true, undefined, this)
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV19("box", {
+            flexGrow: 1,
+            flexDirection: "column",
+            gap: 1,
+            children: [
+              /* @__PURE__ */ jsxDEV19(DiffPanel, {
+                entry: selectedEntry,
+                hunkCount,
+                selectedHunkIndex,
+                selectionMode,
+                selectedRange,
+                cursorRow,
+                focused: () => focusPanel() === "diff"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV19(Show7, {
+                when: focusPanel() === "editor" && editorAnchor(),
+                children: /* @__PURE__ */ jsxDEV19(EditorPanel, {
+                  file: editorAnchor().file,
+                  startRow: editorAnchor().startRow,
+                  endRow: editorAnchor().endRow,
+                  commentId: editorAnchor().commentId,
+                  onClose: () => {
+                    setFocusPanel("diff");
+                    setEditorAnchor(null);
+                  }
+                }, undefined, false, undefined, this)
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV19(Footer, {}, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV19(Show7, {
+        when: dialog.isOpen(),
+        children: dialog.content()
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/App.tsx
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+
+// parsers/index.ts
+import bash_wasm from "tree-sitter-wasms/out/tree-sitter-bash.wasm" with { type: "file" };
+import c_wasm from "tree-sitter-wasms/out/tree-sitter-c.wasm" with { type: "file" };
+import cpp_wasm from "tree-sitter-wasms/out/tree-sitter-cpp.wasm" with { type: "file" };
+import c_sharp_wasm from "tree-sitter-wasms/out/tree-sitter-c_sharp.wasm" with { type: "file" };
+import css_wasm from "tree-sitter-wasms/out/tree-sitter-css.wasm" with { type: "file" };
+import dart_wasm from "tree-sitter-wasms/out/tree-sitter-dart.wasm" with { type: "file" };
+import elisp_wasm from "tree-sitter-wasms/out/tree-sitter-elisp.wasm" with { type: "file" };
+import elixir_wasm from "tree-sitter-wasms/out/tree-sitter-elixir.wasm" with { type: "file" };
+import elm_wasm from "tree-sitter-wasms/out/tree-sitter-elm.wasm" with { type: "file" };
+import embedded_template_wasm from "tree-sitter-wasms/out/tree-sitter-embedded_template.wasm" with { type: "file" };
+import go_wasm from "tree-sitter-wasms/out/tree-sitter-go.wasm" with { type: "file" };
+import html_wasm from "tree-sitter-wasms/out/tree-sitter-html.wasm" with { type: "file" };
+import java_wasm from "tree-sitter-wasms/out/tree-sitter-java.wasm" with { type: "file" };
+import javascript_wasm from "tree-sitter-wasms/out/tree-sitter-javascript.wasm" with { type: "file" };
+import json_wasm from "tree-sitter-wasms/out/tree-sitter-json.wasm" with { type: "file" };
+import kotlin_wasm from "tree-sitter-wasms/out/tree-sitter-kotlin.wasm" with { type: "file" };
+import lua_wasm from "tree-sitter-wasms/out/tree-sitter-lua.wasm" with { type: "file" };
+import objc_wasm from "tree-sitter-wasms/out/tree-sitter-objc.wasm" with { type: "file" };
+import ocaml_wasm from "tree-sitter-wasms/out/tree-sitter-ocaml.wasm" with { type: "file" };
+import php_wasm from "tree-sitter-wasms/out/tree-sitter-php.wasm" with { type: "file" };
+import python_wasm from "tree-sitter-wasms/out/tree-sitter-python.wasm" with { type: "file" };
+import ql_wasm from "tree-sitter-wasms/out/tree-sitter-ql.wasm" with { type: "file" };
+import ruby_wasm from "tree-sitter-wasms/out/tree-sitter-ruby.wasm" with { type: "file" };
+import rust_wasm from "tree-sitter-wasms/out/tree-sitter-rust.wasm" with { type: "file" };
+import scala_wasm from "tree-sitter-wasms/out/tree-sitter-scala.wasm" with { type: "file" };
+import swift_wasm from "tree-sitter-wasms/out/tree-sitter-swift.wasm" with { type: "file" };
+import toml_wasm from "tree-sitter-wasms/out/tree-sitter-toml.wasm" with { type: "file" };
+import tsx_wasm from "tree-sitter-wasms/out/tree-sitter-tsx.wasm" with { type: "file" };
+import typescript_wasm from "tree-sitter-wasms/out/tree-sitter-typescript.wasm" with { type: "file" };
+import vue_wasm from "tree-sitter-wasms/out/tree-sitter-vue.wasm" with { type: "file" };
+import yaml_wasm from "tree-sitter-wasms/out/tree-sitter-yaml.wasm" with { type: "file" };
+import zig_wasm from "tree-sitter-wasms/out/tree-sitter-zig.wasm" with { type: "file" };
+
+// parsers/queries/bash.scm
+var bash_default = "./bash-nbhfht5r.scm";
+
+// parsers/queries/c.scm
+var c_default = "./c-4zy7d3fw.scm";
+
+// parsers/queries/cpp.scm
+var cpp_default = "./cpp-stxr9ffp.scm";
+
+// parsers/queries/c_sharp.scm
+var c_sharp_default = "./c_sharp-tb7n62t2.scm";
+
+// parsers/queries/css.scm
+var css_default = "./css-b1p1h6ys.scm";
+
+// parsers/queries/dart.scm
+var dart_default = "./dart-t89b32ej.scm";
+
+// parsers/queries/elisp.scm
+var elisp_default = "./elisp-ax9wx1b9.scm";
+
+// parsers/queries/elixir.scm
+var elixir_default = "./elixir-77300bss.scm";
+
+// parsers/queries/elm.scm
+var elm_default = "./elm-k2q5knqb.scm";
+
+// parsers/queries/embedded_template.scm
+var embedded_template_default = "./embedded_template-k7ypjkba.scm";
+
+// parsers/queries/go.scm
+var go_default = "./go-9wx8m64k.scm";
+
+// parsers/queries/html.scm
+var html_default = "./html-g95aq3vw.scm";
+
+// parsers/queries/java.scm
+var java_default = "./java-wasz6t7a.scm";
+
+// parsers/queries/javascript.scm
+var javascript_default = "./javascript-cswtymww.scm";
+
+// parsers/queries/json.scm
+var json_default = "./json-pf4aw8w1.scm";
+
+// parsers/queries/kotlin.scm
+var kotlin_default = "./kotlin-m6cj2y7m.scm";
+
+// parsers/queries/lua.scm
+var lua_default = "./lua-7h6jk3pd.scm";
+
+// parsers/queries/objc.scm
+var objc_default = "./objc-6yjdwy1z.scm";
+
+// parsers/queries/ocaml.scm
+var ocaml_default = "./ocaml-jfj520qk.scm";
+
+// parsers/queries/php.scm
+var php_default = "./php-bds7v5h1.scm";
+
+// parsers/queries/python.scm
+var python_default = "./python-k2cbtg72.scm";
+
+// parsers/queries/ql.scm
+var ql_default = "./ql-qs2vxbeq.scm";
+
+// parsers/queries/ruby.scm
+var ruby_default = "./ruby-3ybh5bp2.scm";
+
+// parsers/queries/rust.scm
+var rust_default = "./rust-edtnatpk.scm";
+
+// parsers/queries/scala.scm
+var scala_default = "./scala-91f2sb1z.scm";
+
+// parsers/queries/swift.scm
+var swift_default = "./swift-a4tt704b.scm";
+
+// parsers/queries/toml.scm
+var toml_default = "./toml-hcqfz0bg.scm";
+
+// parsers/queries/tsx.scm
+var tsx_default = "./tsx-c3k3mmc9.scm";
+
+// parsers/queries/typescript.scm
+var typescript_default = "./typescript-hz4pg6ze.scm";
+
+// parsers/queries/vue.scm
+var vue_default = "./vue-xbeea1aj.scm";
+
+// parsers/queries/yaml.scm
+var yaml_default = "./yaml-mbfb25g0.scm";
+
+// parsers/queries/zig.scm
+var zig_default = "./zig-ds3q8m26.scm";
+
+// parsers/index.ts
+var parsers = [
+  {
+    filetype: "bash",
+    wasm: bash_wasm,
+    queries: { highlights: [bash_default] }
+  },
+  { filetype: "c", wasm: c_wasm, queries: { highlights: [c_default] } },
+  {
+    filetype: "cpp",
+    wasm: cpp_wasm,
+    queries: { highlights: [cpp_default] }
+  },
+  {
+    filetype: "c_sharp",
+    wasm: c_sharp_wasm,
+    queries: { highlights: [c_sharp_default] }
+  },
+  {
+    filetype: "css",
+    wasm: css_wasm,
+    queries: { highlights: [css_default] }
+  },
+  {
+    filetype: "dart",
+    wasm: dart_wasm,
+    queries: { highlights: [dart_default] }
+  },
+  {
+    filetype: "elisp",
+    wasm: elisp_wasm,
+    queries: { highlights: [elisp_default] }
+  },
+  {
+    filetype: "elixir",
+    wasm: elixir_wasm,
+    queries: { highlights: [elixir_default] }
+  },
+  {
+    filetype: "elm",
+    wasm: elm_wasm,
+    queries: { highlights: [elm_default] }
+  },
+  {
+    filetype: "embedded_template",
+    wasm: embedded_template_wasm,
+    queries: { highlights: [embedded_template_default] }
+  },
+  { filetype: "go", wasm: go_wasm, queries: { highlights: [go_default] } },
+  {
+    filetype: "html",
+    wasm: html_wasm,
+    queries: { highlights: [html_default] }
+  },
+  {
+    filetype: "java",
+    wasm: java_wasm,
+    queries: { highlights: [java_default] }
+  },
+  {
+    filetype: "javascript",
+    wasm: javascript_wasm,
+    queries: { highlights: [javascript_default] }
+  },
+  {
+    filetype: "json",
+    wasm: json_wasm,
+    queries: { highlights: [json_default] }
+  },
+  {
+    filetype: "kotlin",
+    wasm: kotlin_wasm,
+    queries: { highlights: [kotlin_default] }
+  },
+  {
+    filetype: "lua",
+    wasm: lua_wasm,
+    queries: { highlights: [lua_default] }
+  },
+  {
+    filetype: "objc",
+    wasm: objc_wasm,
+    queries: { highlights: [objc_default] }
+  },
+  {
+    filetype: "ocaml",
+    wasm: ocaml_wasm,
+    queries: { highlights: [ocaml_default] }
+  },
+  {
+    filetype: "php",
+    wasm: php_wasm,
+    queries: { highlights: [php_default] }
+  },
+  {
+    filetype: "python",
+    wasm: python_wasm,
+    queries: { highlights: [python_default] }
+  },
+  { filetype: "ql", wasm: ql_wasm, queries: { highlights: [ql_default] } },
+  {
+    filetype: "ruby",
+    wasm: ruby_wasm,
+    queries: { highlights: [ruby_default] }
+  },
+  {
+    filetype: "rust",
+    wasm: rust_wasm,
+    queries: { highlights: [rust_default] }
+  },
+  {
+    filetype: "scala",
+    wasm: scala_wasm,
+    queries: { highlights: [scala_default] }
+  },
+  {
+    filetype: "swift",
+    wasm: swift_wasm,
+    queries: { highlights: [swift_default] }
+  },
+  {
+    filetype: "toml",
+    wasm: toml_wasm,
+    queries: { highlights: [toml_default] }
+  },
+  {
+    filetype: "tsx",
+    wasm: tsx_wasm,
+    queries: { highlights: [tsx_default] }
+  },
+  {
+    filetype: "typescript",
+    wasm: typescript_wasm,
+    queries: { highlights: [typescript_default] }
+  },
+  {
+    filetype: "vue",
+    wasm: vue_wasm,
+    queries: { highlights: [vue_default] }
+  },
+  {
+    filetype: "yaml",
+    wasm: yaml_wasm,
+    queries: { highlights: [yaml_default] }
+  },
+  {
+    filetype: "zig",
+    wasm: zig_wasm,
+    queries: { highlights: [zig_default] }
+  }
+];
+
+// src/App.tsx
+import { jsxDEV as jsxDEV20 } from "@opentui/solid/jsx-dev-runtime";
+exports_db.init();
+addDefaultParsers(parsers);
+var originalSliderRenderSelf = SliderRenderable.prototype.renderSelf;
+SliderRenderable.prototype.renderSelf = function(buffer) {
+  if (this.width <= 0 || this.height <= 0)
+    return;
+  if (this.orientation === "vertical" && this.height <= 1)
+    return;
+  if (this.orientation === "horizontal" && this.width <= 1)
+    return;
+  originalSliderRenderSelf.call(this, buffer);
+};
+var RECORD_FRAMES = process.env.RECORD_FRAMES === "1";
+var frameNumber = 0;
+var decoder = new TextDecoder;
+async function tui(options = {}) {
+  const repoPath = options.repoPath ?? process.cwd();
+  await render(() => /* @__PURE__ */ jsxDEV20(ErrorBoundary, {
+    fallback: (err, reset) => /* @__PURE__ */ jsxDEV20(ErrorFallback, {
+      error: err,
+      reset
+    }, undefined, false, undefined, this),
+    children: /* @__PURE__ */ jsxDEV20(Review, {
+      repoPath
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this), {
+    exitOnCtrlC: false,
+    useKittyKeyboard: {},
+    postProcessFns: RECORD_FRAMES ? [
+      (buffer) => {
+        const frameBytes = buffer.getRealCharBytes(true);
+        const frame = decoder.decode(frameBytes);
+        mkdirSync2("frames", { recursive: true });
+        writeFileSync2(`frames/frame-${String(frameNumber++).padStart(5, "0")}.txt`, frame);
+      }
+    ] : undefined
+  });
+}
+if (import.meta.main) {
+  tui();
+}
+export {
+  tui
+};
+
+//# debugId=D41DC668FD4D6FC664756E2164756E21