@oscbacon/tungsten 0.0.1

package/src/app.tsx

@@ -0,0 +1,287 @@
+import type { ScrollBoxRenderable } from "@opentui/core"
+import { useKeyboard, useRenderer, useTerminalDimensions } from "@opentui/react"
+import { spawn } from "node:child_process"
+import { useCallback, useEffect, useMemo, useRef, useState } from "react"
+import type { Bucket, PR, State, Status } from "./data"
+import { repoLabel, type Repo } from "./repo"
+
+const C = {
+  bg: "#1c1d21", border: "#34353b", borderActive: "#7b8cff", selected: "#2b2d3a",
+  text: "#ececef", muted: "#9a9ba2", faint: "#6c6d74",
+  green: "#5fb865", red: "#e5534b", blue: "#7b8cff", purple: "#8e6bf2", orange: "#e3a23b",
+}
+
+const STATUS: Record<Status, [string, string]> = {
+  pass: ["✓", C.green], fail: ["✗", C.red], pending: ["◷", C.faint], running: ["●", C.orange], merged: ["◆", C.purple],
+}
+const STATE: Record<State, [string, string]> = {
+  review: ["◷", C.muted], approved: ["✓", C.green], draft: ["✎", C.muted], merged: ["◆", C.purple], author: ["↩", C.orange],
+}
+
+// Navigation walks one flat list: bucket headers plus the rows of open buckets.
+// Headers stay in the list so a collapsed bucket can still be reached and reopened.
+type Item =
+  | { kind: "bucket"; id: string; bucket: number }
+  | { kind: "pr"; id: string; bucket: number; pr: PR }
+
+const bucketId = (i: number) => `bucket-${i}`
+const bucketBoxId = (i: number) => `bucket-box-${i}`
+// Scoped to the bucket: one PR can sit in two buckets (say review-requested and open),
+// and each copy needs its own id to be selectable and scrollable on its own.
+const prId = (bucket: number, pr: PR) => `pr-${bucket}-${pr.number}`
+
+function openInBrowser(url: string) {
+  const [cmd, args] =
+    process.platform === "darwin" ? ["open", [url]] :
+    process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] :
+    process.env.WSL_DISTRO_NAME ? ["wslview", [url]] :
+    ["xdg-open", [url]]
+  spawn(cmd, args, { stdio: "ignore", detached: true }).unref()
+}
+
+const fit = (s: string, n: number) => (s.length > n ? s.slice(0, Math.max(0, n - 1)) + "…" : s.padEnd(n))
+
+// Fixed-width columns are padded strings, so rows line up without per-cell layout.
+const AUTHOR_W = 20, CHANGES_W = 11, UPDATED_W = 4
+const FIXED = 7 + 2 + AUTHOR_W + 2 + 1 + 2 + 1 + 2 + CHANGES_W + 2 + UPDATED_W
+const CHROME = 2 + 2 + 1 // bucket border, row padding, scrollbar
+
+// Each resolves to a success message or rejects with the error to show.
+export interface Actions {
+  checkout(pr: PR): Promise<string>
+  worktree(pr: PR): Promise<string>
+}
+
+const printable = (s: string) => s.length > 0 && !/[\x00-\x1f\x7f]/.test(s)
+
+export function App({ repo, load, actions }: { repo: Repo; load: (search?: string) => Promise<Bucket[]>; actions: Actions }) {
+  const renderer = useRenderer()
+  const { width } = useTerminalDimensions()
+  const scroll = useRef<ScrollBoxRenderable>(null)
+  const [buckets, setBuckets] = useState<Bucket[]>([])
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<string>()
+  // By name, so a bucket stays collapsed across refreshes and searches that change the bucket list.
+  const [collapsed, setCollapsed] = useState<ReadonlySet<string>>(new Set())
+  const [cursorId, setCursorId] = useState<string>()
+  const lastIndex = useRef(0)
+  const [search, setSearch] = useState("") // applied: loads and refreshes use it
+  // The search being typed, while the "/" prompt is open. Keys can arrive faster than renders
+  // (typing fast, pasting), so each one reads and writes the ref, not a stale render's value.
+  const [input, setInputState] = useState<string>()
+  const inputRef = useRef<string>(undefined)
+  const setInput = (v: string | undefined) => { inputRef.current = v; setInputState(v) }
+  const [notice, setNotice] = useState<{ text: string; color: string }>()
+  const [busy, setBusy] = useState(false)
+
+  // The last unsearched buckets, so clearing a search puts them back without a fetch; r refreshes them.
+  const home = useRef<Bucket[]>(undefined)
+
+  // A failed refresh keeps the last good data on screen. Only the latest load lands,
+  // so a slow one can't overwrite the results of a newer search.
+  const latest = useRef(0)
+  const refresh = useCallback((search: string) => {
+    const id = ++latest.current
+    setLoading(true)
+    load(search || undefined)
+      .then(b => {
+        if (id !== latest.current) return
+        setBuckets(b)
+        setError(undefined)
+        if (!search) home.current = b
+      }, (e: unknown) => { if (id === latest.current) setError(e instanceof Error ? e.message : String(e)) })
+      .finally(() => { if (id === latest.current) setLoading(false) })
+  }, [load])
+  useEffect(() => refresh(""), [refresh])
+
+  const applySearch = (next: string) => {
+    if (next === search) return
+    setSearch(next)
+    setCursorId(undefined) // new results: start from the top
+    lastIndex.current = 0
+    if (next || !home.current) return refresh(next)
+    latest.current++ // drop a search still loading
+    setBuckets(home.current)
+    setError(undefined)
+    setLoading(false)
+  }
+
+  const items = useMemo<Item[]>(() => buckets.flatMap((b, i) => [
+    { kind: "bucket" as const, id: bucketId(i), bucket: i },
+    ...(collapsed.has(b.name) ? [] : b.prs.map(pr => ({ kind: "pr" as const, id: prId(i, pr), bucket: i, pr }))),
+  ]), [buckets, collapsed])
+
+  // The cursor follows an id so it stays on the same PR across refreshes;
+  // if that PR is gone, it keeps its position instead.
+  const found = items.findIndex(it => it.id === cursorId)
+  const index = found >= 0 ? found : Math.min(lastIndex.current, items.length - 1)
+  lastIndex.current = Math.max(0, index)
+  const current = items[index]
+
+  useEffect(() => {
+    const box = scroll.current
+    if (!box || !current) return
+    // At a bucket's edge, first reveal the whole bucket so its bottom border isn't clipped.
+    const bucket = buckets[current.bucket]!
+    const rows = collapsed.has(bucket.name) ? [] : bucket.prs
+    const atBucketEnd = rows.length === 0 || (current.kind === "pr" && current.pr === rows.at(-1))
+    if (atBucketEnd) box.scrollChildIntoView(bucketBoxId(current.bucket))
+    box.scrollChildIntoView(current.id)
+  }, [current?.id, buckets, collapsed])
+
+  const move = (delta: number) => {
+    const next = items[Math.min(items.length - 1, Math.max(0, index + delta))]
+    if (next) setCursorId(next.id)
+  }
+
+  const toggle = (bucket: number) => {
+    const name = buckets[bucket]!.name
+    setCollapsed(prev => {
+      const next = new Set(prev)
+      next.has(name) ? next.delete(name) : next.add(name)
+      return next
+    })
+    // Park the cursor on the header: the rows below it may vanish.
+    setCursorId(bucketId(bucket))
+  }
+
+  const runAction = (fn: (pr: PR) => Promise<string>, pending: string) => {
+    if (busy || current?.kind !== "pr") return
+    setBusy(true)
+    setNotice({ text: `${pending} PR #${current.pr.number}…`, color: C.muted })
+    fn(current.pr)
+      .then(text => setNotice({ text: `✓ ${text}`, color: C.green }),
+        (e: unknown) => setNotice({ text: `✗ ${e instanceof Error ? e.message : String(e)}`, color: C.red }))
+      .finally(() => setBusy(false))
+  }
+
+  useKeyboard(key => {
+    // While typing a search, keys are text; only enter and esc leave the prompt.
+    const input = inputRef.current
+    if (input !== undefined) {
+      if (key.name === "escape") { setInput(undefined); applySearch("") }
+      else if (key.name === "return") { setInput(undefined); applySearch(input.trim()) }
+      else if (key.name === "backspace") setInput(input.slice(0, -1))
+      else if (!key.ctrl && !key.meta && printable(key.sequence)) setInput(input + key.sequence)
+      return
+    }
+    if (key.ctrl || key.meta) return
+    if (key.sequence === "/") return setInput(search)
+    switch (key.name) {
+      case "up":
+      case "k":
+        move(-1)
+        break
+      case "down":
+      case "j":
+        move(1)
+        break
+      case "t":
+        if (current) toggle(current.bucket)
+        break
+      case "return":
+        if (current?.kind === "pr") openInBrowser(current.pr.url)
+        else if (current) toggle(current.bucket)
+        break
+      case "c":
+        runAction(actions.checkout, "Checking out")
+        break
+      case "w":
+        runAction(actions.worktree, "Opening a worktree for")
+        break
+      case "escape":
+        applySearch("")
+        break
+      case "r":
+        if (!loading) refresh(search)
+        break
+      case "q":
+        renderer.destroy()
+        process.exit(0)
+    }
+  })
+
+  const titleW = Math.max(12, width - FIXED - CHROME)
+
+  return (
+    <box style={{ flexDirection: "column", width: "100%", height: "100%", backgroundColor: C.bg }}>
+      <box style={{ height: 1, paddingLeft: 1, flexDirection: "row", justifyContent: "space-between", paddingRight: 1 }}>
+        <text fg={C.text}><b>Inbox</b>{search && <span fg={C.muted}>{fit(`  / ${search}`, Math.max(0, width - repoLabel(repo).length - 20))}</span>}</text>
+        <text fg={C.muted}>{loading && <span fg={C.faint}>loading…  </span>}{repoLabel(repo)}</text>
+      </box>
+
+      {(error || notice) && (
+        <box style={{ height: 1, paddingLeft: 1, paddingRight: 1 }}>
+          <text fg={error ? C.red : notice!.color}>{fit(error ? `✗ ${error}` : notice!.text, Math.max(0, width - 2))}</text>
+        </box>
+      )}
+
+      <scrollbox ref={scroll} style={{ flexGrow: 1 }}>
+        {buckets.length === 0 && (
+          <box style={{ height: 1, paddingLeft: 1 }}>
+            <text fg={C.faint}>{loading ? "Loading pull requests…" : "No pull requests loaded. Press r to retry."}</text>
+          </box>
+        )}
+        {buckets.map((b, i) => {
+          const count = b.total ?? b.prs.length
+          const open = !collapsed.has(b.name)
+          const onHeader = current?.id === bucketId(i)
+          return (
+            <box
+              key={b.name}
+              id={bucketBoxId(i)}
+              border
+              borderStyle="rounded"
+              borderColor={current?.bucket === i ? C.borderActive : C.border}
+              style={{ flexDirection: "column" }}
+            >
+              <box id={bucketId(i)} style={{ height: 1, paddingLeft: 1, backgroundColor: onHeader ? C.selected : C.bg }}>
+                <text fg={C.text}>
+                  <span fg={C.muted}>{count === 0 ? " " : open ? "▾" : "▸"}</span> {b.name}{" "}
+                  <span fg={C.faint}>{count === 0 ? "- No pull requests" : String(count)}</span>
+                </text>
+              </box>
+              {open && b.prs.map(pr => (
+                <PrRow key={pr.number} id={prId(i, pr)} pr={pr} titleW={titleW} selected={current?.id === prId(i, pr)} />
+              ))}
+            </box>
+          )
+        })}
+      </scrollbox>
+
+      <box style={{ height: 1, paddingLeft: 1 }}>
+        {input !== undefined ? (
+          <text fg={C.faint}>
+            <span fg={C.text}>/ {input}█</span>   <span fg={C.text}>enter</span> search   <span fg={C.text}>esc</span> clear   words match titles, @login authors, #123 numbers
+          </text>
+        ) : (
+          <text fg={C.faint}>
+            {search && <><span fg={C.text}>esc</span> clear search   </>}<span fg={C.text}>↑↓</span> move   <span fg={C.text}>t</span> toggle bucket   <span fg={C.text}>enter</span> open PR   {!search && <><span fg={C.text}>/</span> search   </>}<span fg={C.text}>c</span> checkout   <span fg={C.text}>w</span> worktree   <span fg={C.text}>r</span> refresh   <span fg={C.text}>q</span> quit
+          </text>
+        )}
+      </box>
+    </box>
+  )
+}
+
+function PrRow({ id, pr, titleW, selected }: { id: string; pr: PR; titleW: number; selected: boolean }) {
+  const [stateGlyph, stateColor] = STATE[pr.state]
+  const [ciGlyph, ciColor] = STATUS[pr.ci]
+  const [revGlyph, revColor] = STATUS[pr.review]
+  const add = `+${pr.additions}`, del = `-${pr.deletions}`
+  const changesPad = " ".repeat(Math.max(0, CHANGES_W - add.length - del.length - 1))
+
+  return (
+    <box id={id} style={{ height: 1, paddingLeft: 1, paddingRight: 1, backgroundColor: selected ? C.selected : C.bg }}>
+      <text fg={C.text}>
+        <span fg={C.blue}>{selected ? "▌" : " "}</span> <span fg={C.blue}>•</span> <span fg={stateColor}>{stateGlyph}</span>
+        {"  "}{selected ? <b>{fit(pr.title, titleW)}</b> : fit(pr.title, titleW)}
+        {"  "}<span fg={C.muted}>{fit(`${pr.author} #${pr.number}`, AUTHOR_W)}</span>
+        {"  "}<span fg={ciColor}>{ciGlyph}</span>
+        {"  "}<span fg={revColor}>{revGlyph}</span>
+        {"  "}{changesPad}<span fg={C.green}>{add}</span><span fg={C.muted}>/</span><span fg={C.red}>{del}</span>
+        {"  "}<span fg={pr.stale ? C.red : C.text}>{pr.updated.padStart(UPDATED_W)}</span>
+      </text>
+    </box>
+  )
+}

package/src/checkout.test.ts

@@ -0,0 +1,145 @@
+import { expect, test } from "bun:test"
+import { checkoutPr, findWorktree, needsPrompt, openWorktree, worktreeDir } from "./checkout"
+import { demoBuckets, type PR } from "./data"
+import { parseRepo } from "./repo"
+import type { Run, RunResult } from "./run"
+
+const repo = parseRepo("cli/cli")
+const home = "/home/me"
+const pr: PR = { ...demoBuckets(repo)[0]!.prs[0]!, number: 42, branch: "babakks/fix-tokens" }
+
+// A fake `run` that records every command and answers from a table keyed by "cmd arg1 arg2...".
+// Nothing is ever executed, so no branch is checked out and no worktree is created.
+function fakeRun(answers: Record<string, Partial<RunResult>> = {}) {
+  const calls: { cmd: string; interactive: boolean }[] = []
+  const run: Run = async (cmd, args, opts) => {
+    const line = [cmd, ...args].join(" ")
+    calls.push({ cmd: line, interactive: !!opts?.interactive })
+    return { code: 0, stdout: "", stderr: "", ...answers[line] }
+  }
+  return { run, calls, cmds: () => calls.map(c => c.cmd) }
+}
+
+const porcelain = `worktree /home/me/src/cli
+HEAD 1111111111111111111111111111111111111111
+branch refs/heads/trunk
+
+worktree /home/me/worktrees/cli/babakks-fix-tokens
+HEAD 2222222222222222222222222222222222222222
+branch refs/heads/babakks/fix-tokens
+
+worktree /home/me/worktrees/cli/detached
+HEAD 3333333333333333333333333333333333333333
+detached
+`
+
+const NEW_GH = { stdout: "Flags:\n  -b, --branch string\n      --worktree path   Check out the pull request into a worktree\n" }
+const OLD_GH = { stdout: "Flags:\n  -b, --branch string\n  -f, --force\n" }
+const CHECKOUT = "gh pr checkout 42 -R github.com/cli/cli --worktree=/home/me/worktrees/cli/babakks-fix-tokens --branch=babakks/fix-tokens"
+
+test("worktreeDir flattens the branch like `wa`, under the repo's name", () => {
+  expect(worktreeDir(repo, "babakks/fix/tokens", home)).toBe("/home/me/worktrees/cli/babakks-fix-tokens")
+  expect(worktreeDir(repo, "main", home)).toBe("/home/me/worktrees/cli/main")
+})
+
+test("findWorktree matches the exact branch", () => {
+  expect(findWorktree(porcelain, "trunk")).toBe("/home/me/src/cli")
+  expect(findWorktree(porcelain, "babakks/fix-tokens")).toBe("/home/me/worktrees/cli/babakks-fix-tokens")
+  expect(findWorktree(porcelain, "babakks/fix")).toBeUndefined()
+  expect(findWorktree("", "trunk")).toBeUndefined()
+})
+
+test("c runs gh pr checkout against the repo on screen, with the terminal", async () => {
+  const f = fakeRun()
+  expect(await checkoutPr(pr, repo, f.run)).toBe("Checked out PR #42")
+  expect(f.calls).toEqual([{ cmd: "gh pr checkout 42 -R github.com/cli/cli", interactive: true }])
+})
+
+test("c reports git's error line, not its fetch progress", async () => {
+  const stderr = [
+    "From github.com:cli/cli",
+    " * [new ref]  refs/pull/42/head -> babakks/fix-tokens",
+    "error: Your local changes to the following files would be overwritten by checkout:",
+    "\tREADME.md",
+    "Aborting",
+    "failed to run git: exit status 1",
+  ].join("\n")
+  const f = fakeRun({ "gh pr checkout 42 -R github.com/cli/cli": { code: 1, stderr } })
+  await expect(checkoutPr(pr, repo, f.run)).rejects.toThrow(/^error: Your local changes/)
+
+  const bare = fakeRun({ "gh pr checkout 42 -R github.com/cli/cli": { code: 1 } })
+  await expect(checkoutPr(pr, repo, bare.run)).rejects.toThrow("gh pr checkout exited with code 1")
+})
+
+test("c reports the prompt it couldn't show, so the error can point at --show-git-prompt", async () => {
+  const stderr = [
+    "git@github.com: Permission denied (publickey).",
+    "fatal: Could not read from remote repository.",
+    "",
+    "Please make sure you have the correct access rights",
+    "failed to run git: exit status 128",
+  ].join("\n")
+  const f = fakeRun({ "gh pr checkout 42 -R github.com/cli/cli": { code: 1, stderr } })
+  await expect(checkoutPr(pr, repo, f.run)).rejects.toThrow("git@github.com: Permission denied (publickey).")
+
+  for (const msg of ["Host key verification failed.", "fatal: could not read Username for 'https://github.com': terminal prompts disabled"]) {
+    expect(needsPrompt(msg)).toBe(true)
+  }
+  expect(needsPrompt("fatal: not a git repository")).toBe(false)
+})
+
+test("c without gh installed says so", async () => {
+  const run: Run = async () => { throw Object.assign(new Error("spawn gh ENOENT"), { code: "ENOENT" }) }
+  await expect(checkoutPr(pr, repo, run)).rejects.toThrow("gh is not installed")
+})
+
+test("w creates the worktree with gh and reports where, outside tmux", async () => {
+  const f = fakeRun({ "git worktree list --porcelain": { stdout: porcelain.split("\n\n")[0] }, "gh pr checkout --help": NEW_GH })
+  expect(await openWorktree(pr, repo, { run: f.run, tmux: false, home })).toBe("Worktree at ~/worktrees/cli/babakks-fix-tokens")
+  expect(f.calls).toEqual([
+    { cmd: "git worktree list --porcelain", interactive: false },
+    { cmd: "gh pr checkout --help", interactive: false },
+    { cmd: CHECKOUT, interactive: true },
+  ])
+})
+
+test("w inside tmux opens a window in the new worktree", async () => {
+  const f = fakeRun({ "gh pr checkout --help": NEW_GH })
+  expect(await openWorktree(pr, repo, { run: f.run, tmux: true, home })).toBe("Opened ~/worktrees/cli/babakks-fix-tokens in a new tmux window")
+  expect(f.cmds().slice(-2)).toEqual([CHECKOUT, "tmux new-window -c /home/me/worktrees/cli/babakks-fix-tokens"])
+})
+
+test("w reuses a worktree that already has the branch, wherever it is", async () => {
+  const f = fakeRun({ "git worktree list --porcelain": { stdout: porcelain } })
+  expect(await openWorktree(pr, repo, { run: f.run, tmux: true, home })).toBe("Opened ~/worktrees/cli/babakks-fix-tokens in a new tmux window")
+  expect(f.cmds()).toEqual(["git worktree list --porcelain", "tmux new-window -c /home/me/worktrees/cli/babakks-fix-tokens"])
+
+  // The branch checked out in the main clone, outside ~/worktrees.
+  const main = fakeRun({ "git worktree list --porcelain": { stdout: porcelain } })
+  expect(await openWorktree({ ...pr, branch: "trunk" }, repo, { run: main.run, tmux: false, home })).toBe("Worktree already at ~/src/cli")
+  expect(main.cmds()).toEqual(["git worktree list --porcelain"])
+})
+
+test("w passes gh the branch name from the PR (a fork's may carry an owner prefix)", async () => {
+  const f = fakeRun({ "gh pr checkout --help": NEW_GH })
+  await openWorktree({ ...pr, branch: "octo/trunk" }, repo, { run: f.run, tmux: false, home })
+  expect(f.cmds().at(-1)).toBe("gh pr checkout 42 -R github.com/cli/cli --worktree=/home/me/worktrees/cli/octo-trunk --branch=octo/trunk")
+})
+
+test("w needs gh 2.98+, and runs nothing when gh is older", async () => {
+  const f = fakeRun({ "gh pr checkout --help": OLD_GH })
+  await expect(openWorktree(pr, repo, { run: f.run, tmux: true, home })).rejects.toThrow("w needs gh 2.98 or newer")
+  expect(f.cmds()).toEqual(["git worktree list --porcelain", "gh pr checkout --help"])
+})
+
+test("w surfaces gh, git and tmux failures", async () => {
+  const gitFails = fakeRun({ "git worktree list --porcelain": { code: 128, stderr: "fatal: not a git repository (or any of the parent directories): .git" } })
+  await expect(openWorktree(pr, repo, { run: gitFails.run, tmux: false, home })).rejects.toThrow("fatal: not a git repository")
+
+  const ghFails = fakeRun({ "gh pr checkout --help": NEW_GH, [CHECKOUT]: { code: 1, stderr: "--worktree path must be a directory: /home/me/worktrees/cli/babakks-fix-tokens\n" } })
+  await expect(openWorktree(pr, repo, { run: ghFails.run, tmux: true, home })).rejects.toThrow("--worktree path must be a directory")
+  expect(ghFails.cmds()).not.toContain("tmux new-window -c /home/me/worktrees/cli/babakks-fix-tokens")
+
+  const tmuxFails = fakeRun({ "git worktree list --porcelain": { stdout: porcelain }, "tmux new-window -c /home/me/worktrees/cli/babakks-fix-tokens": { code: 1, stderr: "no server running on /tmp/tmux-1000/default" } })
+  await expect(openWorktree(pr, repo, { run: tmuxFails.run, tmux: true, home })).rejects.toThrow("no server running")
+})

package/src/checkout.ts

@@ -0,0 +1,83 @@
+import { homedir } from "node:os"
+import { join } from "node:path"
+import type { PR } from "./data"
+import type { Repo } from "./repo"
+import type { Run, RunResult } from "./run"
+
+// Both keys delegate to `gh pr checkout`, which already handles forks, remotes and upstream config
+// (cli/cli pkg/cmd/pr/checkout). This module only decides what to ask it for.
+
+const repoArg = (r: Repo) => `${r.host}/${r.owner}/${r.name}`
+
+// ~/worktrees/<repo>/<branch>, with slashes in the branch flattened like the `wa` shell function.
+export const worktreeDir = (repo: Repo, branch: string, home = homedir()) =>
+  join(home, "worktrees", repo.name, branch.replaceAll("/", "-"))
+
+// The path of the worktree that has `branch` checked out, from `git worktree list --porcelain`.
+export function findWorktree(porcelain: string, branch: string): string | undefined {
+  for (const block of porcelain.split("\n\n")) {
+    const lines = block.split("\n")
+    if (lines.includes(`branch refs/heads/${branch}`)) return lines.find(l => l.startsWith("worktree "))?.slice("worktree ".length)
+  }
+}
+
+// What ssh and git print when they needed to prompt but couldn't (see RunOptions.noPrompts).
+const PROMPT_NEEDED = /Permission denied \(publickey|Host key verification failed|terminal prompts disabled|can't open \/dev\/tty/
+export const needsPrompt = (message: string) => PROMPT_NEEDED.test(message)
+
+// git's fetch progress goes to stderr too, so prefer the line that explains the failure over the first one.
+function failure(r: RunResult, what: string): Error {
+  const lines = r.stderr.split("\n").map(l => l.trim()).filter(Boolean)
+  const line = lines.find(needsPrompt) ?? lines.find(l => /^(error|fatal):/.test(l)) ?? lines.at(-1)
+  return new Error(line ?? `${what} exited with code ${r.code}`)
+}
+
+async function gh(run: Run, args: string[], interactive = false) {
+  try {
+    return await run("gh", args, { interactive })
+  } catch (e) {
+    if ((e as NodeJS.ErrnoException).code === "ENOENT") throw new Error("gh is not installed (https://cli.github.com)")
+    throw e
+  }
+}
+
+export async function checkoutPr(pr: PR, repo: Repo, run: Run): Promise<string> {
+  const r = await gh(run, ["pr", "checkout", String(pr.number), "-R", repoArg(repo)], true)
+  if (r.code !== 0) throw failure(r, "gh pr checkout")
+  return `Checked out PR #${pr.number}`
+}
+
+export interface WorktreeEnv {
+  run: Run
+  tmux: boolean // inside a tmux session ($TMUX is set)
+  home?: string
+}
+
+// Reuses the worktree that already has the PR's branch, or creates one; then opens a tmux window there.
+export async function openWorktree(pr: PR, repo: Repo, { run, tmux, home = homedir() }: WorktreeEnv): Promise<string> {
+  const list = await run("git", ["worktree", "list", "--porcelain"])
+  if (list.code !== 0) throw failure(list, "git worktree list")
+
+  // gh doesn't check this, and `git worktree add` refuses a branch that's checked out elsewhere.
+  let dir = findWorktree(list.stdout, pr.branch)
+  const existed = dir !== undefined
+  if (dir === undefined) {
+    const help = await gh(run, ["pr", "checkout", "--help"])
+    if (!`${help.stdout}${help.stderr}`.includes("--worktree")) {
+      throw new Error("w needs gh 2.98 or newer (for gh pr checkout --worktree); please upgrade gh")
+    }
+    dir = worktreeDir(repo, pr.branch, home)
+    // --branch pins the name we looked up above; `=` keeps a leading "-" from reading as a flag.
+    const args = ["pr", "checkout", String(pr.number), "-R", repoArg(repo), `--worktree=${dir}`, `--branch=${pr.branch}`]
+    const r = await gh(run, args, true)
+    if (r.code !== 0) throw failure(r, "gh pr checkout")
+  }
+
+  const shown = dir === home || dir.startsWith(home + "/") ? "~" + dir.slice(home.length) : dir
+  if (tmux) {
+    const t = await run("tmux", ["new-window", "-c", dir])
+    if (t.code !== 0) throw failure(t, "tmux new-window")
+    return `Opened ${shown} in a new tmux window`
+  }
+  return existed ? `Worktree already at ${shown}` : `Worktree at ${shown}`
+}

package/src/data.ts

@@ -0,0 +1,57 @@
+import type { Repo } from "./repo"
+
+export type Status = "pass" | "fail" | "pending" | "running" | "merged"
+export type State = "review" | "approved" | "draft" | "merged" | "author"
+
+export interface PR {
+  number: number
+  title: string
+  author: string
+  state: State
+  ci: Status
+  review: Status
+  additions: number
+  deletions: number
+  updated: string
+  stale?: boolean
+  url: string
+  branch: string // local branch name for checkouts; see localBranch() in github.ts
+}
+
+export interface Bucket {
+  name: string
+  total?: number // server-side count when only a page of PRs is loaded
+  prs: PR[]
+}
+
+// Sample data for --demo and tests; the UI only depends on these shapes.
+export function demoBuckets(repo: Repo): Bucket[] {
+  // Swap for your Graphite PR link format if you'd rather open PRs there.
+  const url = (n: number) => `https://${repo.host}/${repo.owner}/${repo.name}/pull/${n}`
+  const pr = (p: Omit<PR, "url" | "branch">): PR => ({ ...p, url: url(p.number), branch: `${p.author}/pr-${p.number}` })
+
+  return [
+    { name: "Needs your review", prs: [
+      pr({ number: 21325, title: "fix: only find upstack PRs for MQ after self", author: "aryamannaik", state: "review", ci: "fail", review: "pass", additions: 84, deletions: 3, updated: "7m" }),
+      pr({ number: 21324, title: "refactor: add logic to fetch MQ entries after self into helper", author: "aryamannaik", state: "review", ci: "pending", review: "pass", additions: 104, deletions: 20, updated: "7m" }),
+      pr({ number: 21100, title: "feat: set the location of the upstack blame modal when clicking on the upstack", author: "ZiyaoWei", state: "review", ci: "fail", review: "fail", additions: 186, deletions: 2, updated: "7m" }),
+    ] },
+    { name: "Returned to you", prs: [] },
+    { name: "Approved", prs: [
+      pr({ number: 20967, title: "[Snyk] Security upgrade @withgraphite/retype from 0.0.0-use.local to 0.3.15", author: "gregoryfoster", state: "approved", ci: "fail", review: "pass", additions: 1, deletions: 1, updated: "18h" }),
+      pr({ number: 20673, title: "fix(auth): fix edge case in repo membership", author: "gregoryfoster", state: "approved", ci: "fail", review: "pass", additions: 31, deletions: 4, updated: "18h" }),
+    ] },
+    { name: "Waiting for reviewers", prs: [] },
+    { name: "Drafts", prs: [
+      pr({ number: 19965, title: "experiment(pr_perf): explore using cached PRs on pr page", author: "gregoryfoster", state: "draft", ci: "running", review: "fail", additions: 54, deletions: 23, updated: "21d", stale: true }),
+    ] },
+    { name: "Open", total: 42, prs: [
+      pr({ number: 21330, title: "chore(deps): bump @opentelemetry/api from 1.9.0 to 1.9.1", author: "dependabot", state: "review", ci: "pass", review: "pending", additions: 3, deletions: 3, updated: "2m" }),
+      pr({ number: 21318, title: "feat(mq): show estimated merge time in queue sidebar", author: "ZiyaoWei", state: "approved", ci: "running", review: "pass", additions: 212, deletions: 41, updated: "1h" }),
+      pr({ number: 21102, title: "docs: document stack submit flags", author: "aryamannaik", state: "author", ci: "pass", review: "fail", additions: 58, deletions: 12, updated: "16d", stale: true }),
+    ] },
+    { name: "Recently merged", total: 318, prs: [
+      pr({ number: 21305, title: "fix: throw when we hit a merge conflict when rebasing stack for draft PRs", author: "aryamannaik", state: "merged", ci: "pass", review: "merged", additions: 10, deletions: 0, updated: "3m" }),
+    ] },
+  ]
+}