@oscbacon/tungsten 0.0.1 → 0.1.0

package/README.md

@@ -15,17 +15,30 @@ Lists a repo's PRs by bucket, and allow you to open the PR in your browser
 
 ## Install
 
-    git clone git@github.com:OscBacon/tungsten.git
-    cd tungsten
-    bun install
-    bun link    # links `tungsten` into ~/.bun/bin; make sure that's on your PATH
+```bash
+npm i -g @oscbacon/tungsten
+```
+
+Or from the source:
+
+```bash
+git clone git@github.com:OscBacon/tungsten.git
+cd tungsten
+bun install
+bun link    # links `tungsten` into ~/.bun/bin; make sure that's on your PATH
+```
+
 
 ## Usage
 
-    tungsten                 # repo from the current clone's git remotes, like gh
-    tungsten -R cli/cli      # or pick one: [HOST/]OWNER/REPO
-    tungsten --demo          # sample data, no clone or network
-    tungsten --show-git-prompt  # let c and w ask for ssh passphrases or credentials
+```bash
+tungsten                 # repo from the current clone's git remotes, like gh
+tungsten -R cli/cli      # or pick one: [HOST/]OWNER/REPO
+tungsten -R cli/cli,cli/go-gh   # or several, listed together (repeating -R works too)
+tungsten --demo          # sample data, no clone or network
+tungsten --demo-multiple # sample data from several repos
+tungsten --show-git-prompt  # let c and w ask for ssh passphrases or credentials
+```
 
 ## Buckets
 
@@ -37,7 +50,8 @@ Lists a repo's PRs by bucket, and allow you to open the PR in your browser
 - Open
 - Recently merged
 
-Each shows up to 25 PRs and the total count.
+Each shows up to 25 PRs and the total count. With several repos, each bucket holds all of
+their PRs, newest first, and each row names its repo next to the author.
 
 ## Keys
 
@@ -59,11 +73,12 @@ PRs from before it without refetching them (`r` refreshes them).
 
     fix token      words in the title
     @login         PRs by that author (several @logins: any of them)
-    #123           that PR, looked up directly
+    #123           that PR, looked up directly (in every repo shown)
+    go-gh#123      that PR in one repo; cli/go-gh#123 works too
 
 ## Checking out
 
-Both keys work from a clone of the repo on screen, and hand the PR to `gh pr checkout`,
+Both keys work from a clone of the PR's repo, and hand the PR to `gh pr checkout`,
 so forks and remotes behave as they do there.
 
 - `c` checks the PR out in the current clone.

package/package.json

@@ -1,10 +1,36 @@
 {
   "name": "@oscbacon/tungsten",
   "type": "module",
-  "version": "0.0.1",
+  "version": "0.1.0",
+  "description": "A terminal inbox for a GitHub repo's pull requests",
+  "keywords": [
+    "github",
+    "pull-requests",
+    "tui",
+    "terminal",
+    "cli"
+  ],
+  "license": "MIT",
+  "author": "Oscar Baracos",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OscBacon/tungsten.git"
+  },
+  "homepage": "https://github.com/OscBacon/tungsten#readme",
+  "bugs": {
+    "url": "https://github.com/OscBacon/tungsten/issues"
+  },
   "bin": {
     "tungsten": "src/index.tsx"
   },
+  "files": [
+    "src",
+    "!src/**/*.test.*",
+    "tsconfig.json"
+  ],
+  "engines": {
+    "bun": ">=1.0.0"
+  },
   "devDependencies": {
     "@types/bun": "^1.4.2",
     "@types/react": "^19.3.0"

package/src/app.tsx

@@ -28,7 +28,9 @@ 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}`
+// The repo too: with several repos, two PRs can share a number.
+const prKey = (pr: PR) => `${repoLabel(pr.repo)}#${pr.number}`
+const prId = (bucket: number, pr: PR) => `pr-${bucket}-${prKey(pr)}`
 
 function openInBrowser(url: string) {
   const [cmd, args] =
@@ -42,10 +44,18 @@ function openInBrowser(url: string) {
 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
+// With several repos the author column also names the PR's repo, so it's wider.
+const AUTHOR_W = 20, AUTHOR_REPO_W = 36, CHANGES_W = 11, UPDATED_W = 4
+const fixed = (authorW: number) => 7 + 2 + authorW + 2 + 1 + 2 + 1 + 2 + CHANGES_W + 2 + UPDATED_W
 const CHROME = 2 + 2 + 1 // bucket border, row padding, scrollbar
 
+// How a row names its repo: just REPO, unless two of the repos share that name.
+function repoTags(repos: Repo[]): (r: Repo) => string {
+  const name = (r: Repo) => r.name.toLowerCase()
+  const clash = (r: Repo) => repos.filter(o => name(o) === name(r)).length > 1
+  return r => (clash(r) ? `${r.owner}/${r.name}` : r.name)
+}
+
 // Each resolves to a success message or rejects with the error to show.
 export interface Actions {
   checkout(pr: PR): Promise<string>
@@ -54,7 +64,7 @@ export interface Actions {
 
 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 }) {
+export function App({ repos, load, actions }: { repos: Repo[]; load: (search?: string) => Promise<Bucket[]>; actions: Actions }) {
   const renderer = useRenderer()
   const { width } = useTerminalDimensions()
   const scroll = useRef<ScrollBoxRenderable>(null)
@@ -201,13 +211,18 @@ export function App({ repo, load, actions }: { repo: Repo; load: (search?: strin
     }
   })
 
-  const titleW = Math.max(12, width - FIXED - CHROME)
+  const multi = repos.length > 1
+  const authorW = multi ? AUTHOR_REPO_W : AUTHOR_W
+  const tag = useMemo(() => repoTags(repos), [repos])
+  const titleW = Math.max(12, width - fixed(authorW) - CHROME)
+  const all = repos.map(repoLabel).join(", ")
+  const label = all.length <= width / 2 ? all : `${repos.length} repos`
 
   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>
+        <text fg={C.text}><b>Inbox</b>{search && <span fg={C.muted}>{fit(`  / ${search}`, Math.max(0, width - label.length - 20))}</span>}</text>
+        <text fg={C.muted}>{loading && <span fg={C.faint}>loading…  </span>}{label}</text>
       </box>
 
       {(error || notice) && (
@@ -242,7 +257,7 @@ export function App({ repo, load, actions }: { repo: Repo; load: (search?: strin
                 </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)} />
+                <PrRow key={prKey(pr)} id={prId(i, pr)} pr={pr} repoTag={multi ? tag(pr.repo) : undefined} authorW={authorW} titleW={titleW} selected={current?.id === prId(i, pr)} />
               ))}
             </box>
           )
@@ -264,7 +279,7 @@ export function App({ repo, load, actions }: { repo: Repo; load: (search?: strin
   )
 }
 
-function PrRow({ id, pr, titleW, selected }: { id: string; pr: PR; titleW: number; selected: boolean }) {
+function PrRow({ id, pr, repoTag, authorW, titleW, selected }: { id: string; pr: PR; repoTag?: string; authorW: number; titleW: number; selected: boolean }) {
   const [stateGlyph, stateColor] = STATE[pr.state]
   const [ciGlyph, ciColor] = STATUS[pr.ci]
   const [revGlyph, revColor] = STATUS[pr.review]
@@ -276,7 +291,7 @@ function PrRow({ id, pr, titleW, selected }: { id: string; pr: PR; titleW: numbe
       <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={C.muted}>{fit(`${pr.author} ${repoTag ?? ""}#${pr.number}`, authorW)}</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>

package/src/data.ts

@@ -15,6 +15,7 @@ export interface PR {
   updated: string
   stale?: boolean
   url: string
+  repo: Repo // the repo it was opened against
   branch: string // local branch name for checkouts; see localBranch() in github.ts
 }
 
@@ -25,10 +26,15 @@ export interface Bucket {
 }
 
 // Sample data for --demo and tests; the UI only depends on these shapes.
-export function demoBuckets(repo: Repo): Bucket[] {
+// With several repos, the PRs are dealt out across them in turn.
+export function demoBuckets(...repos: Repo[]): Bucket[] {
+  let next = 0
   // 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}` })
+  const url = (r: Repo, n: number) => `https://${r.host}/${r.owner}/${r.name}/pull/${n}`
+  const pr = (p: Omit<PR, "url" | "repo" | "branch">): PR => {
+    const repo = repos[next++ % repos.length]!
+    return { ...p, url: url(repo, p.number), repo, branch: `${p.author}/pr-${p.number}` }
+  }
 
   return [
     { name: "Needs your review", prs: [

package/src/github.ts

@@ -1,5 +1,5 @@
 import type { Bucket, PR, State, Status } from "./data"
-import type { Repo } from "./repo"
+import { normalizeHost, type Repo } from "./repo"
 import { run } from "./run"
 
 export const PAGE_SIZE = 25
@@ -22,23 +22,38 @@ export const BUCKETS = [
 export interface Search {
   words: string[]
   authors: string[]
-  numbers: number[]
+  numbers: PrRef[]
+}
+
+// #123 is that number in any repo shown; REPO#123 or OWNER/REPO#123 only in that one.
+export interface PrRef {
+  number: number
+  repo?: string
 }
 
 export function parseSearch(input: string): Search {
   const search: Search = { words: [], authors: [], numbers: [] }
   for (const term of input.trim().split(/\s+/).filter(Boolean)) {
+    const ref = term.match(/^([\w.-]+(?:\/[\w.-]+)?)?#(\d+)$/)
     if (/^@[^@\s]+$/.test(term)) search.authors.push(term.slice(1))
-    else if (/^#\d+$/.test(term)) search.numbers.push(Number(term.slice(1)))
+    else if (ref) search.numbers.push(ref[1] ? { number: Number(ref[2]), repo: ref[1] } : { number: Number(ref[2]) })
     else search.words.push(term)
   }
   return search
 }
 
+// Whether a REPO or OWNER/REPO typed in a search names this repo.
+export function repoMatches(repo: Repo, typed: string): boolean {
+  const t = typed.toLowerCase()
+  return t === (t.includes("/") ? `${repo.owner}/${repo.name}` : repo.name).toLowerCase()
+}
+
+const refMatches = (ref: PrRef, repo: Repo, number: number) => ref.number === number && (!ref.repo || repoMatches(repo, ref.repo))
+
 // The same test done locally, for --demo and for PRs looked up by number.
 export function matches(pr: PR, s: Search): boolean {
   const title = pr.title.toLowerCase(), author = pr.author.toLowerCase()
-  return (s.numbers.length === 0 || s.numbers.includes(pr.number))
+  return (s.numbers.length === 0 || s.numbers.some(ref => refMatches(ref, pr.repo, pr.number)))
     && s.words.every(w => title.includes(w.toLowerCase()))
     && (s.authors.length === 0 || s.authors.some(a => author === a.toLowerCase()))
 }
@@ -53,10 +68,11 @@ function searchTerms(s: Search, mine: boolean): string {
   return [...s.words, ...(s.words.length ? ["in:title"] : []), ...authors].join(" ")
 }
 
-export const searchQuery = (repo: Repo, i: number, search?: Search) =>
-  [`repo:${repo.owner}/${repo.name} is:pr sort:updated-desc ${BUCKETS[i]!.query}`, search && searchTerms(search, isMine(i))].filter(Boolean).join(" ")
+// GitHub ORs repo: qualifiers, so one search covers every repo, sorted and counted together.
+export const searchQuery = (repos: Repo[], i: number, search?: Search) =>
+  [`${repos.map(r => `repo:${r.owner}/${r.name}`).join(" ")} is:pr sort:updated-desc ${BUCKETS[i]!.query}`, search && searchTerms(search, isMine(i))].filter(Boolean).join(" ")
 
-const FIELDS = `number title url isDraft state additions deletions updatedAt reviewDecision
+const FIELDS = `number title url repository { name owner { login } } isDraft state additions deletions updatedAt reviewDecision
   author { login } commits(last: 1) { nodes { commit { statusCheckRollup { state } } } }
   headRefName isCrossRepository headRepositoryOwner { login } baseRepository { defaultBranchRef { name } }`
 
@@ -67,16 +83,26 @@ export function buildQuery(): string {
   return `fragment pr on PullRequest { ${FIELDS} }\nquery(${vars}) {\n  viewer { login }\n  ${searches.join("\n  ")}\n}`
 }
 
-// Search doesn't match PR numbers, so #123 looks each one up directly.
-export function buildNumbersQuery(numbers: number[]): string {
-  const prs = numbers.map(n => `n${n}: pullRequest(number: ${n}) { ...pr }`)
-  return `fragment pr on PullRequest { ${FIELDS} }\nquery($owner: String!, $name: String!) {\n  repository(owner: $owner, name: $name) { ${prs.join(" ")} }\n}`
+// The numbers to look up in each repo; repos with none are left out.
+export function numberLookups(repos: Repo[], refs: PrRef[]): { repo: Repo; numbers: number[] }[] {
+  return repos
+    .map(repo => ({ repo, numbers: [...new Set(refs.filter(r => !r.repo || repoMatches(repo, r.repo)).map(r => r.number))] }))
+    .filter(l => l.numbers.length > 0)
+}
+
+// Search doesn't match PR numbers, so #123 looks each one up directly, in every repo it may be in.
+export function buildNumbersQuery(lookups: { numbers: number[] }[]): string {
+  const vars = lookups.map((_, i) => `$owner${i}: String!, $name${i}: String!`).join(", ")
+  const repos = lookups.map(({ numbers }, i) =>
+    `r${i}: repository(owner: $owner${i}, name: $name${i}) { ${numbers.map(n => `n${n}: pullRequest(number: ${n}) { ...pr }`).join(" ")} }`)
+  return `fragment pr on PullRequest { ${FIELDS} }\nquery(${vars}) {\n  ${repos.join("\n  ")}\n}`
 }
 
 interface PrNode {
   number: number
   title: string
   url: string
+  repository: { name: string; owner: { login: string } }
   isDraft: boolean
   state: string // OPEN | CLOSED | MERGED
   additions: number
@@ -102,7 +128,7 @@ export interface SearchResponse {
 }
 
 export interface NumbersResponse {
-  data?: { repository: Record<string, unknown> | null } | null
+  data?: Record<string, Record<string, unknown> | null> | null // r0, r1, ... holding n<number>
   errors?: { message: string; type?: string }[]
 }
 
@@ -154,6 +180,8 @@ function toPR(n: PrNode, now: Date): PR {
     updated: relativeTime(n.updatedAt, now),
     stale: !merged && now.getTime() - Date.parse(n.updatedAt) > STALE_DAYS * 86400_000,
     url: n.url,
+    // The API host isn't in the response, but it's the one in the PR's url.
+    repo: { host: normalizeHost(new URL(n.url).hostname), owner: n.repository.owner.login, name: n.repository.name },
     branch: localBranch(n),
   }
 }
@@ -174,8 +202,8 @@ export function toNumbersBucket(res: NumbersResponse, search: Search, now = new
   // A missing number is a NOT_FOUND error next to the PRs that were found.
   const errors = res.errors?.filter(e => e.type !== "NOT_FOUND") ?? []
   if (errors.length) throw new Error(errors.map(e => e.message).join("; "))
-  const prs = search.numbers
-    .map(n => res.data?.repository?.[`n${n}`])
+  const prs = Object.values(res.data ?? {})
+    .flatMap(repo => Object.values(repo ?? {}))
     .filter(isPrNode)
     .map(n => toPR(n, now))
     .filter(pr => matches(pr, search))
@@ -192,9 +220,9 @@ async function gh(args: string[]) {
 }
 
 // gh handles auth and the API host, so no token ever passes through here.
-async function graphql<T extends { errors?: unknown[] }>(repo: Repo, fields: Record<string, string>): Promise<T> {
+async function graphql<T extends { errors?: unknown[] }>(host: string, fields: Record<string, string>): Promise<T> {
   const { code, stdout, stderr } = await gh([
-    "api", "graphql", "--hostname", repo.host,
+    "api", "graphql", "--hostname", host,
     ...Object.entries(fields).flatMap(([k, v]) => ["-f", `${k}=${v}`]),
   ])
 
@@ -209,14 +237,21 @@ async function graphql<T extends { errors?: unknown[] }>(repo: Repo, fields: Rec
   throw new Error(stderr.trim().split("\n")[0] || `gh exited with code ${code}`)
 }
 
-export async function fetchBuckets(repo: Repo, search?: Search): Promise<Bucket[]> {
+// The repos all share a host (see index.tsx), so one request covers them.
+export async function fetchBuckets(repos: Repo[], search?: Search): Promise<Bucket[]> {
+  const host = repos[0]!.host
   if (search?.numbers.length) {
-    const res = await graphql<NumbersResponse>(repo, { query: buildNumbersQuery(search.numbers), owner: repo.owner, name: repo.name })
+    const lookups = numberLookups(repos, search.numbers)
+    if (lookups.length === 0) return [{ name: "Search results", prs: [] }]
+    const res = await graphql<NumbersResponse>(host, {
+      query: buildNumbersQuery(lookups),
+      ...Object.fromEntries(lookups.flatMap(({ repo }, i) => [[`owner${i}`, repo.owner], [`name${i}`, repo.name]])),
+    })
     return [toNumbersBucket(res, search)]
   }
-  const res = await graphql<SearchResponse>(repo, {
+  const res = await graphql<SearchResponse>(host, {
     query: buildQuery(),
-    ...Object.fromEntries(BUCKETS.map((_, i) => [`q${i}`, searchQuery(repo, i, search)])),
+    ...Object.fromEntries(BUCKETS.map((_, i) => [`q${i}`, searchQuery(repos, i, search)])),
   })
   return toBuckets(res, new Date(), search)
 }

package/src/index.tsx

@@ -4,7 +4,7 @@ import { createRoot } from "@opentui/react"
 import { parseArgs } from "node:util"
 import { App, type Actions } from "./app"
 import { checkoutPr, needsPrompt, openWorktree } from "./checkout"
-import { demoBuckets } from "./data"
+import { demoBuckets, type PR } from "./data"
 import { fetchBuckets, matches, parseSearch } from "./github"
 import { detectRepo, ghHosts, parseRepo, repoLabel, type Repo } from "./repo"
 import { run, type Run } from "./run"
@@ -12,21 +12,26 @@ import { run, type Run } from "./run"
 const USAGE = `Usage: tungsten [flags]
 
 Flags:
-  -R, --repo [HOST/]OWNER/REPO   Select another repository using the [HOST/]OWNER/REPO format
+  -R, --repo [HOST/]OWNER/REPO   Select another repository using the [HOST/]OWNER/REPO format;
+                                 repeat it or separate repos with commas to list them together
       --demo                     Show sample data instead of fetching from GitHub
+      --demo-multiple            Like --demo, with PRs from several repos
       --show-git-prompt          Let c and w show git's prompts (ssh passphrase, credentials);
                                  the app is hidden while they run
   -h, --help                     Show help`
 
-let repo: Repo
+const key = (r: Repo) => `${r.host}/${r.owner}/${r.name}`.toLowerCase()
+
+let repos: Repo[]
 let demo: boolean
 let showGitPrompt: boolean
-let notLocal: string | undefined // why c and w can't work from here
+let here: Repo | undefined // the repo cloned in the current folder, where c and w work
 try {
   const { values } = parseArgs({
     options: {
-      repo: { type: "string", short: "R" },
+      repo: { type: "string", short: "R", multiple: true },
       demo: { type: "boolean" },
+      "demo-multiple": { type: "boolean" },
       "show-git-prompt": { type: "boolean" },
       help: { type: "boolean", short: "h" },
     },
@@ -35,24 +40,23 @@ try {
     console.log(USAGE)
     process.exit(0)
   }
-  demo = values.demo ?? false
+  const demoMultiple = values["demo-multiple"] ?? false
+  demo = (values.demo ?? false) || demoMultiple
   showGitPrompt = values["show-git-prompt"] ?? false
   // Like gh: OWNER/REPO uses gh's default host, and no flag means the current folder's git remotes.
-  // --demo shouldn't need a clone, so it falls back to a sample repo.
+  // --demo shouldn't need a clone, so it falls back to sample repos.
   const hosts = ghHosts()
-  repo =
-    values.repo ? parseRepo(values.repo, hosts.defaultHost) :
-    demo ? parseRepo("withgraphite/monologue") :
-    detectRepo(process.cwd(), hosts)
-  // Checkouts happen in the current folder, so it has to be a clone of the repo on screen.
-  if (demo) notLocal = "not available with --demo"
-  else if (values.repo) {
-    const key = (r: Repo) => `${r.host}/${r.owner}/${r.name}`.toLowerCase()
-    let here: Repo | undefined
-    try { here = detectRepo(process.cwd(), hosts) } catch {}
-    if (!here || key(here) !== key(repo)) {
-      notLocal = `run tungsten from a clone of ${repoLabel(repo)} to check out its PRs`
-    }
+  const named = (values.repo ?? []).flatMap(v => v.split(",")).map(v => v.trim()).filter(Boolean)
+  repos =
+    named.length ? named.map(r => parseRepo(r, hosts.defaultHost)).filter((r, i, all) => all.findIndex(o => key(o) === key(r)) === i) :
+    demoMultiple ? ["withgraphite/monologue", "withgraphite/graphite-cli", "withgraphite/retype"].map(r => parseRepo(r)) :
+    demo ? [parseRepo("withgraphite/monologue")] :
+    [detectRepo(process.cwd(), hosts)]
+  // One GraphQL request serves every repo, and it goes to a single host.
+  if (new Set(repos.map(r => r.host)).size > 1) throw new Error("all repos must be on the same GitHub host")
+  if (!demo) {
+    if (!named.length) here = repos[0]
+    else try { here = detectRepo(process.cwd(), hosts) } catch {}
   }
 } catch (e) {
   console.error(`${(e as Error).message}\n\n${USAGE}`)
@@ -61,8 +65,8 @@ try {
 
 const load = async (search?: string) => {
   const s = search ? parseSearch(search) : undefined
-  if (!demo) return fetchBuckets(repo, s)
-  const buckets = demoBuckets(repo)
+  if (!demo) return fetchBuckets(repos, s)
+  const buckets = demoBuckets(...repos)
   return s ? buckets.map(b => ({ name: b.name, prs: b.prs.filter(pr => matches(pr, s)) })) : buckets
 }
 
@@ -85,11 +89,15 @@ const withHint = (p: Promise<string>) => p.catch((e: Error) => {
   throw showGitPrompt || !needsPrompt(e.message) ? e : new Error(`${e.message} (run with --show-git-prompt to answer git's prompts)`)
 })
 
-const actions: Actions = notLocal
-  ? { checkout: () => Promise.reject(new Error(notLocal)), worktree: () => Promise.reject(new Error(notLocal)) }
-  : {
-      checkout: pr => withHint(checkoutPr(pr, repo, runGit)),
-      worktree: pr => withHint(openWorktree(pr, repo, { run: runGit, tmux: !!process.env.TMUX })),
-    }
+// Checkouts happen in the current folder, so it has to be a clone of the PR's repo.
+const local = (pr: PR, fn: () => Promise<string>) =>
+  demo ? Promise.reject(new Error("not available with --demo")) :
+  !here || key(here) !== key(pr.repo) ? Promise.reject(new Error(`run tungsten from a clone of ${repoLabel(pr.repo)} to check out its PRs`)) :
+  withHint(fn())
+
+const actions: Actions = {
+  checkout: pr => local(pr, () => checkoutPr(pr, pr.repo, runGit)),
+  worktree: pr => local(pr, () => openWorktree(pr, pr.repo, { run: runGit, tmux: !!process.env.TMUX })),
+}
 
-createRoot(renderer).render(<App repo={repo} load={load} actions={actions} />)
+createRoot(renderer).render(<App repos={repos} load={load} actions={actions} />)

package/src/repo.ts

@@ -15,7 +15,7 @@ export interface Repo {
 
 export const DEFAULT_HOST = "github.com"
 
-const normalizeHost = (h: string) => h.toLowerCase().replace(/^www\./, "")
+export const normalizeHost = (h: string) => h.toLowerCase().replace(/^www\./, "")
 
 // Accepts gh's [HOST/]OWNER/REPO format.
 export function parseRepo(s: string, fallbackHost = DEFAULT_HOST): Repo {

package/bun.lock

@@ -1,85 +0,0 @@
-{
-  "lockfileVersion": 1,
-  "configVersion": 1,
-  "workspaces": {
-    "": {
-      "name": "tungsten",
-      "dependencies": {
-        "@opentui/core": "^0.5.11",
-        "@opentui/react": "^0.5.11",
-        "react": "^19.3.0",
-      },
-      "devDependencies": {
-        "@types/bun": "^1.4.2",
-        "@types/react": "^19.3.0",
-      },
-    },
-  },
-  "packages": {
-    "@opentui/core": ["@opentui/core@0.5.11", "", { "dependencies": { "bun-ffi-structs": "0.3.1", "diff": "9.0.0", "marked": "17.0.1", "string-width": "7.2.0", "strip-ansi": "7.1.2" }, "optionalDependencies": { "@opentui/core-darwin-arm64": "0.5.11", "@opentui/core-darwin-x64": "0.5.11", "@opentui/core-linux-arm64": "0.5.11", "@opentui/core-linux-arm64-musl": "0.5.11", "@opentui/core-linux-x64": "0.5.11", "@opentui/core-linux-x64-musl": "0.5.11", "@opentui/core-win32-arm64": "0.5.11", "@opentui/core-win32-x64": "0.5.11" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-pImMfjCNx7JUp9Df1LRZBDLisWqgzOLXZKXO+hh3jA9ujBFPQnZOqbG+/N5uVAAX8IZGaqhYSQRwSZIFBmcfbQ=="],
-
-    "@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.5.11", "", { "os": "darwin", "cpu": "arm64" }, "sha512-DRXY5ioq+n1ZNAMAcaFaBunr0cmi2gqucjbTW7lgFp8t9uN3fNZnLTDOqkCTQtT2XhrU4GXqySaPSQ4qFG/EAQ=="],
-
-    "@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.5.11", "", { "os": "darwin", "cpu": "x64" }, "sha512-yP/8GliJDiJNm8YYJKvgWuy6xyCEd8d4GwBVOIzCFOI7ZIbGP8GOTvmwIjRW4Paw20pTttWMWyRoQiCvOXvH2g=="],
-
-    "@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.5.11", "", { "os": "linux", "cpu": "arm64" }, "sha512-zBIsRFHlLUYFNhapRSNt9dz4mC8gZ4Wxcfy3A+2AwqsgCipcr2FkIuAXYqN08q+IvqFX7DfqgIFGWDNedHTPUg=="],
-
-    "@opentui/core-linux-arm64-musl": ["@opentui/core-linux-arm64-musl@0.5.11", "", { "os": "linux", "cpu": "arm64" }, "sha512-x+xeR2LYibvIi/qQetRjJR008sFRve60QuDcO8ItxUwzFeKTDzl5CEiZpBXfm5I4FhRNuyuj0TSPIFadMvrjFQ=="],
-
-    "@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.5.11", "", { "os": "linux", "cpu": "x64" }, "sha512-pSOXqOADrv+zINOgR3FDFA9zVRaim3zl8/yhtO+X9rEJ6f34z3gDund0Gf88hNJSMpZK5xWtipEVm28RY5VF8w=="],
-
-    "@opentui/core-linux-x64-musl": ["@opentui/core-linux-x64-musl@0.5.11", "", { "os": "linux", "cpu": "x64" }, "sha512-MyqOnSs8pTYG2xmFr1xt6xZIuHu2Xu4pkle9my9JdE+WClmusHf0YN9Eas6jQLAq5XUi34r22wMeK0juk93zyw=="],
-
-    "@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.5.11", "", { "os": "win32", "cpu": "arm64" }, "sha512-MGGRXIDJ//HyaqC5ndSr7/CUl+ICdYEAMcjbA00UWsthh4ZO/rYhPkyqOaTn5ck6+G4ca3/+M76J+jImMYTjNg=="],
-
-    "@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.5.11", "", { "os": "win32", "cpu": "x64" }, "sha512-sMEGX9rhiPd1gBa190jzj5uIdzKCMImxHmr22hJLxIRWqejxWvqGnRBkW68wT8NfMViDiMtZWavgWL7GgmYCAQ=="],
-
-    "@opentui/react": ["@opentui/react@0.5.11", "", { "dependencies": { "@opentui/core": "0.5.11", "react-reconciler": "^0.33.0" }, "peerDependencies": { "react": ">=19.2.0", "react-devtools-core": "^7.0.1", "ws": "^8.18.0" } }, "sha512-ACH6Kpl3/O1zdNL0sZtzrnxfw0+auJu4eefIbPTAPuNEessyuhd2xvV4agrdWRJCeogywS7er5k7uS/8YRWnZg=="],
-
-    "@types/bun": ["@types/bun@1.4.2", "", { "dependencies": { "bun-types": "1.4.2" } }, "sha512-GimotNn7+ZV0uVArItBbriZsR1oNf0+WTzPkdcFrzShI7k2norL0uzEaJT8T33dWr7O/c9ZDuAFQrctKCi72oQ=="],
-
-    "@types/node": ["@types/node@26.5.1", "", { "dependencies": { "undici-types": "~8.9.0" } }, "sha512-CzNm2FezW4VR/LjG6yUdiEgLE/rAQ9Slj5gCu/C2VrdcW7I0ahNZ8DRbHT7zOZ6r3ONgd/bsQIeSaoDGrd1C6g=="],
-
-    "@types/react": ["@types/react@19.3.0", "", { "dependencies": { "csstype": "^3.2.2" } }, "sha512-N0rFCuH9YoxG9/m61l9MfpJKfmLOVU0em7ipIz6TRgSSkvReLB9vL85GB+yr8Bs5leqpvg96JSwF4ZS1s4viQg=="],
-
-    "ansi-regex": ["ansi-regex@6.3.0", "", {}, "sha512-WpDfL7NO6j7tH88IDBNVdUJxDh9nmCteAVW9dsep846XdwF4naCBK+/tGLX3KJgcpgMRXCFlTM2hKGoK9FsdrQ=="],
-
-    "bun-ffi-structs": ["bun-ffi-structs@0.3.1", "", { "peerDependencies": { "typescript": "^5" } }, "sha512-3gM7PpVWLyrwxWjcilSiGuhWanhZivvo6l0u573NziPH6f/gwk6McbaYgn7oJWov6pKGRTDbrg94W5DcJsKTtQ=="],
-
-    "bun-types": ["bun-types@1.4.2", "", { "dependencies": { "@types/node": "*" } }, "sha512-bxV1FgK7yBIzjRe5zBozIM4Bem11ZJcCXSrjWRG3YWLt8yFDePu4cLjpebO8OvPeIE9trbyPF4fuj3Cia4Fj3w=="],
-
-    "csstype": ["csstype@3.2.3", "", {}, "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ=="],
-
-    "diff": ["diff@9.0.0", "", {}, "sha512-svtcdpS8CgJyqAjEQIXdb3OjhFVVYjzGAPO8WGCmRbrml64SPw/jJD4GoE98aR7r25A0XcgrK3F02yw9R/vhQw=="],
-
-    "emoji-regex": ["emoji-regex@10.6.0", "", {}, "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A=="],
-
-    "get-east-asian-width": ["get-east-asian-width@1.6.0", "", {}, "sha512-QRbvDIbx6YklUe6RxeTeleMR0yv3cYH6PsPZHcnVn7xv7zO1BHN8r0XETu8n6Ye3Q+ahtSarc3WgtNWmehIBfA=="],
-
-    "marked": ["marked@17.0.1", "", { "bin": { "marked": "bin/marked.js" } }, "sha512-boeBdiS0ghpWcSwoNm/jJBwdpFaMnZWRzjA6SkUMYb40SVaN1x7mmfGKp0jvexGcx+7y2La5zRZsYFZI6Qpypg=="],
-
-    "react": ["react@19.3.0", "", {}, "sha512-E8LUcbtBWt20bbl2YoHfx4ZDBdxVTfOKtCZn9cDSJ4l6/nuoApcpIBcj47t2wZoVX8g2ZHuMHbiShgCR1T5Sog=="],
-
-    "react-devtools-core": ["react-devtools-core@7.0.1", "", { "dependencies": { "shell-quote": "^1.6.1", "ws": "^7" } }, "sha512-C3yNvRHaizlpiASzy7b9vbnBGLrhvdhl1CbdU6EnZgxPNbai60szdLtl+VL76UNOt5bOoVTOz5rNWZxgGt+Gsw=="],
-
-    "react-reconciler": ["react-reconciler@0.33.0", "", { "dependencies": { "scheduler": "^0.27.0" }, "peerDependencies": { "react": "^19.2.0" } }, "sha512-KetWRytFv1epdpJc3J4G75I4WrplZE5jOL7Yq0p34+OVOKF4Se7WrdIdVC45XsSSmUTlht2FM/fM1FZb1mfQeA=="],
-
-    "scheduler": ["scheduler@0.27.0", "", {}, "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q=="],
-
-    "shell-quote": ["shell-quote@1.10.0", "", {}, "sha512-w1aiOKwKuRgtwAReIIj89puqg+I7GvX4IbLrvmhXbzQsj1+Zwi4VO3+fa6ZF91TWSjIxoEkKnMeHcLEODK5ZXA=="],
-
-    "string-width": ["string-width@7.2.0", "", { "dependencies": { "emoji-regex": "^10.3.0", "get-east-asian-width": "^1.0.0", "strip-ansi": "^7.1.0" } }, "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ=="],
-
-    "strip-ansi": ["strip-ansi@7.1.2", "", { "dependencies": { "ansi-regex": "^6.0.1" } }, "sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA=="],
-
-    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
-
-    "undici-types": ["undici-types@8.9.0", "", {}, "sha512-KTDyRTYX8sWmKXAikPHHSyc63CRPETMctyjKFupcC6OBLXT3xsN0e9aF7m+mIXutFWpUXuedtowG7iLOzp0kQg=="],
-
-    "web-tree-sitter": ["web-tree-sitter@0.25.10", "", { "peerDependencies": { "@types/emscripten": "^1.40.0" }, "optionalPeers": ["@types/emscripten"] }, "sha512-Y09sF44/13XvgVKgO2cNDw5rGk6s26MgoZPXLESvMXeefBf7i6/73eFurre0IsTW6E14Y0ArIzhUMmjoc7xyzA=="],
-
-    "ws": ["ws@8.21.3", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-201TZ/kPWxoPr/OKWjquZR1SWKXcvxdH+e1xrx89b3YbmzLMFCLfnaG1HFIgWzJOEWZ7MvpK++odZufgYR50Rw=="],
-
-    "react-devtools-core/ws": ["ws@7.5.13", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": "^5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-rsKI6xDBFVf4r/x8XyChGK04QR/XHroxs/jUcoWvtEZM8TPU/X/uIY9B1CsSzYws9ZJb/6bbBu7dPhFW00CAoA=="],
-  }
-}

package/src/app.test.tsx

@@ -1,287 +0,0 @@
-import { expect, test } from "bun:test"
-import { testRender } from "@opentui/react/test-utils"
-import { act } from "react"
-import { App, type Actions } from "./app"
-import { demoBuckets, type Bucket } from "./data"
-import { parseRepo } from "./repo"
-
-const press = async (s: Awaited<ReturnType<typeof testRender>>, fn: () => unknown = () => {}) => {
-  await act(async () => { await fn(); await new Promise(r => setTimeout(r, 10)) })
-  await s.renderOnce()
-}
-
-// A lone ESC is only reported once the input parser gives up waiting for a longer sequence.
-const escape = async (s: Awaited<ReturnType<typeof testRender>>) => {
-  await press(s, () => s.mockInput.pressEscape())
-  await press(s)
-}
-
-const repo = parseRepo("withgraphite/monologue")
-const noActions: Actions = { checkout: async () => "", worktree: async () => "" }
-
-test("arrows move, t collapses the current bucket, cursor lands on its header", async () => {
-  const s = await testRender(<App repo={repo} load={async () => demoBuckets(repo)} actions={noActions} />, { width: 110, height: 20 })
-  try {
-    await press(s) // let the load resolve
-    await press(s, () => s.mockInput.pressArrow("down"))
-    await press(s, () => s.mockInput.pressArrow("down"))
-    expect(s.captureCharFrame()).toMatch(/▌ • ◷  refactor/)
-    await press(s, () => s.mockInput.pressKey("t"))
-    let frame = s.captureCharFrame()
-    expect(frame).toContain("▸ Needs your review")
-    expect(frame).not.toContain("refactor")
-    await press(s, () => s.mockInput.pressArrow("down"))   // header -> "Returned to you"
-    await press(s, () => s.mockInput.pressArrow("down"))   // -> "Approved" header
-    await press(s, () => s.mockInput.pressArrow("down"))   // -> first approved PR
-    expect(s.captureCharFrame()).toMatch(/▌ • ✓  \[Snyk\]/)
-    // scroll: walk to the bottom of a short viewport
-    for (let i = 0; i < 12; i++) await press(s, () => s.mockInput.pressArrow("down"))
-    frame = s.captureCharFrame()
-    console.log(frame)
-    expect(frame).toMatch(/▌ • ◆  fix: throw/)
-    expect(frame.trimEnd().split("\n").at(-2)).toMatch(/^╰/) // last bucket fully visible
-  } finally { s.renderer.destroy() }
-})
-
-test("r refreshes: loading state, cursor follows its PR, a failed refresh keeps the last data", async () => {
-  const withoutFirstPr = (): Bucket[] => {
-    const b = demoBuckets(repo)
-    b[0]!.prs.shift()
-    return b
-  }
-  let release!: (b: Bucket[]) => void
-  const loads: (() => Promise<Bucket[]>)[] = [
-    () => new Promise(r => (release = r)),
-    async () => withoutFirstPr(),
-    async () => { throw new Error("HTTP 401: Bad credentials") },
-  ]
-  let calls = 0
-  const load = () => loads[calls++]!()
-
-  const s = await testRender(<App repo={repo} load={load} actions={noActions} />, { width: 110, height: 20 })
-  try {
-    await press(s)
-    expect(s.captureCharFrame()).toContain("Loading pull requests…")
-    await press(s, () => release(demoBuckets(repo)))
-    await press(s, () => s.mockInput.pressArrow("down"))
-    await press(s, () => s.mockInput.pressArrow("down"))
-    expect(s.captureCharFrame()).toMatch(/▌ • ◷  refactor/)
-
-    await press(s, () => s.mockInput.pressKey("r"))
-    let frame = s.captureCharFrame()
-    expect(frame).not.toContain("only find upstack")
-    expect(frame).toMatch(/▌ • ◷  refactor/) // same PR, now the first row
-
-    await press(s, () => s.mockInput.pressKey("r"))
-    frame = s.captureCharFrame()
-    expect(frame).toContain("✗ HTTP 401: Bad credentials")
-    expect(frame).toMatch(/▌ • ◷  refactor/)
-    expect(calls).toBe(3)
-  } finally { s.renderer.destroy() }
-})
-
-test("a PR listed in two buckets selects and moves from the copy the cursor is on", async () => {
-  const dup = demoBuckets(repo)[0]!.prs[0]!
-  const buckets: Bucket[] = [
-    { name: "Needs your review", prs: [dup] },
-    { name: "Open", prs: [dup, { ...dup, number: 999, title: "second open pull request" }] },
-  ]
-  const s = await testRender(<App repo={repo} load={async () => buckets} actions={noActions} />, { width: 110, height: 20 })
-  try {
-    await press(s)
-    // header -> the copy in "Needs your review" -> "Open" header -> the copy in "Open"
-    for (let i = 0; i < 3; i++) await press(s, () => s.mockInput.pressArrow("down"))
-    const lines = s.captureCharFrame().split("\n")
-    const openHeader = lines.findIndex(l => l.includes("▾ Open"))
-    expect(lines[openHeader + 1]).toContain("▌") // the copy under Open, not the one above
-    expect(lines.slice(0, openHeader).join("\n")).not.toContain("▌")
-
-    await press(s, () => s.mockInput.pressArrow("down"))
-    expect(s.captureCharFrame()).toMatch(/▌ • ◷  second open pull request/)
-  } finally { s.renderer.destroy() }
-})
-
-test("footer lists / c w between enter and r", async () => {
-  const s = await testRender(<App repo={repo} load={async () => demoBuckets(repo)} actions={noActions} />, { width: 110, height: 20 })
-  try {
-    await press(s)
-    expect(s.captureCharFrame().trimEnd().split("\n").at(-1)).toMatch(/enter open PR {3}\/ search {3}c checkout {3}w worktree {3}r refresh {3}q quit/)
-  } finally { s.renderer.destroy() }
-})
-
-test("/ types a search that only loads on enter; esc clears it", async () => {
-  const searches: (string | undefined)[] = []
-  const load = async (search?: string) => {
-    searches.push(search)
-    return search ? [{ name: "Open", prs: demoBuckets(repo)[0]!.prs.slice(1, 2) }] : demoBuckets(repo)
-  }
-  const s = await testRender(<App repo={repo} load={load} actions={noActions} />, { width: 110, height: 20 })
-  try {
-    await press(s)
-    await press(s, () => s.mockInput.pressKey("/"))
-    await press(s, () => s.mockInput.typeText("refactor rtq"))
-    await press(s, () => s.mockInput.pressBackspace())
-    let frame = s.captureCharFrame()
-    expect(frame).toContain("/ refactor rt█")
-    expect(frame).toContain("only find upstack") // nothing filtered while typing
-    expect(searches).toEqual([undefined]) // and r, t, q were text, not keys
-
-    await press(s, () => s.mockInput.pressEnter())
-    frame = s.captureCharFrame()
-    expect(searches).toEqual([undefined, "refactor rt"])
-    expect(frame).toMatch(/Inbox {2}\/ refactor rt/)
-    expect(frame).not.toContain("only find upstack")
-    expect(frame).toContain("refactor: add logic")
-    // The footer is back, with a way out in place of "/ search".
-    expect(frame.trimEnd().split("\n").at(-1)).toMatch(/^ esc clear search {3}↑↓ move .* enter open PR {3}c checkout .* q quit/)
-
-    await press(s, () => s.mockInput.pressKey("r")) // refresh keeps the search
-    expect(searches.at(-1)).toBe("refactor rt")
-
-    await press(s, () => s.mockInput.pressEscape())
-    await press(s)
-    expect(searches).toEqual([undefined, "refactor rt", "refactor rt"]) // cleared without a fetch
-    frame = s.captureCharFrame()
-    expect(frame).toContain("only find upstack")
-    expect(frame.trimEnd().split("\n").at(-1)).toMatch(/^ ↑↓ move .* enter open PR {3}\/ search {3}c checkout/)
-
-    // esc in the prompt also clears an applied search
-    await press(s, () => s.mockInput.pressKey("/"))
-    await press(s, () => s.mockInput.typeText("@someone"))
-    await press(s, () => s.mockInput.pressEnter())
-    expect(searches.at(-1)).toBe("@someone")
-    await press(s, () => s.mockInput.pressKey("/"))
-    expect(s.captureCharFrame()).toContain("/ @someone█") // reopens with the current search
-    await press(s, () => s.mockInput.pressEscape())
-    await press(s)
-    expect(searches.at(-1)).toBe("@someone")
-    expect(s.captureCharFrame()).toContain("only find upstack")
-  } finally { s.renderer.destroy() }
-})
-
-// A load per call that the test resolves by hand, recording what each was for.
-function manualLoads() {
-  const calls: { search?: string; resolve: (b: Bucket[]) => void }[] = []
-  const load = (search?: string) => new Promise<Bucket[]>(resolve => calls.push({ search, resolve }))
-  return { load, calls }
-}
-const titled = (title: string): Bucket[] => {
-  const b = demoBuckets(repo)
-  b[0]!.prs[0] = { ...b[0]!.prs[0]!, title }
-  return b
-}
-const results = (title: string): Bucket[] => [{ name: "Search results", prs: [{ ...demoBuckets(repo)[0]!.prs[1]!, title }] }]
-
-test("clearing a search shows the last unsearched data at once, from the top; r refetches it", async () => {
-  const { load, calls } = manualLoads()
-  const s = await testRender(<App repo={repo} load={load} actions={noActions} />, { width: 110, height: 20 })
-  const search = async (q: string) => {
-    await press(s, () => s.mockInput.pressKey("/"))
-    await press(s, () => s.mockInput.typeText(q))
-    await press(s, () => s.mockInput.pressEnter())
-  }
-  try {
-    await press(s, () => calls[0]!.resolve(titled("first unsearched load")))
-    await press(s, () => s.mockInput.pressArrow("down"))
-    await press(s, () => s.mockInput.pressArrow("down"))
-    expect(s.captureCharFrame()).toMatch(/▌ • ◷  refactor/)
-
-    await search("docs")
-    await press(s, () => calls[1]!.resolve(results("docs result")))
-    expect(s.captureCharFrame()).toContain("docs result")
-
-    await escape(s)
-    let frame = s.captureCharFrame()
-    expect(calls.length).toBe(2)
-    expect(frame).toContain("first unsearched load")
-    expect(frame).not.toContain("loading…")
-    expect(frame).not.toContain("▌") // back at the top, on the first header
-
-    // A search still loading when it's cleared can't land afterwards.
-    await search("slow")
-    await escape(s)
-    await press(s, () => calls[2]!.resolve(results("late search result")))
-    frame = s.captureCharFrame()
-    expect(frame).toContain("first unsearched load")
-    expect(frame).not.toContain("late search result")
-
-    await press(s, () => s.mockInput.pressKey("r"))
-    expect(calls.map(c => c.search)).toEqual([undefined, "docs", "slow", undefined])
-    await press(s, () => calls[3]!.resolve(titled("refreshed unsearched load")))
-    expect(s.captureCharFrame()).toContain("refreshed unsearched load")
-  } finally { s.renderer.destroy() }
-})
-
-test("an unsearched load still running when a search starts is dropped, so clearing fetches", async () => {
-  const { load, calls } = manualLoads()
-  const s = await testRender(<App repo={repo} load={load} actions={noActions} />, { width: 110, height: 20 })
-  try {
-    await press(s)
-    await press(s, () => s.mockInput.pressKey("/"))
-    await press(s, () => s.mockInput.typeText("docs"))
-    await press(s, () => s.mockInput.pressEnter())
-    await press(s, () => calls[0]!.resolve(titled("dropped unsearched load")))
-    await press(s, () => calls[1]!.resolve(results("docs result")))
-    expect(s.captureCharFrame()).not.toContain("dropped unsearched load")
-
-    await escape(s)
-    expect(calls.map(c => c.search)).toEqual([undefined, "docs", undefined])
-    await press(s, () => calls[2]!.resolve(titled("fresh unsearched load")))
-    expect(s.captureCharFrame()).toContain("fresh unsearched load")
-  } finally { s.renderer.destroy() }
-})
-
-test("collapsed buckets are tracked by name across searches", async () => {
-  const load = async (search?: string) => (search ? results("docs result") : demoBuckets(repo))
-  const s = await testRender(<App repo={repo} load={load} actions={noActions} />, { width: 110, height: 30 })
-  try {
-    await press(s)
-    for (let i = 0; i < 5; i++) await press(s, () => s.mockInput.pressArrow("down")) // "Approved" header
-    await press(s, () => s.mockInput.pressKey("t"))
-    expect(s.captureCharFrame()).toContain("▸ Approved")
-
-    await press(s, () => s.mockInput.pressKey("/"))
-    await press(s, () => s.mockInput.typeText("docs"))
-    await press(s, () => s.mockInput.pressEnter())
-    await press(s, () => s.mockInput.pressKey("t")) // collapse "Search results", the first bucket
-    expect(s.captureCharFrame()).toContain("▸ Search results")
-
-    await escape(s)
-    const frame = s.captureCharFrame()
-    expect(frame).toContain("▾ Needs your review") // not collapsed by position
-    expect(frame).toContain("▸ Approved")
-  } finally { s.renderer.destroy() }
-})
-
-test("c and w act on the PR under the cursor and show the outcome", async () => {
-  const calls: string[] = []
-  let finish!: () => void
-  const actions: Actions = {
-    checkout: async pr => {
-      calls.push(`checkout #${pr.number}`)
-      await new Promise<void>(r => (finish = r))
-      return `Checked out PR #${pr.number}`
-    },
-    worktree: async pr => { calls.push(`worktree #${pr.number}`); throw new Error("w needs gh 2.98 or newer") },
-  }
-  const s = await testRender(<App repo={repo} load={async () => demoBuckets(repo)} actions={actions} />, { width: 110, height: 20 })
-  try {
-    await press(s)
-    await press(s, () => s.mockInput.pressKey("c")) // on a bucket header: nothing to check out
-    expect(calls).toEqual([])
-
-    await press(s, () => s.mockInput.pressArrow("down"))
-    await press(s, () => s.mockInput.pressKey("c"))
-    expect(s.captureCharFrame()).toContain("Checking out PR #21325…") // the app stays up meanwhile
-    await press(s, () => s.mockInput.pressKey("c")) // ignored while busy
-    expect(calls).toEqual(["checkout #21325"])
-    await press(s, () => finish())
-    expect(s.captureCharFrame()).toContain("✓ Checked out PR #21325")
-
-    await press(s, () => s.mockInput.pressArrow("down"))
-    await press(s, () => s.mockInput.pressKey("w"))
-    await press(s)
-    expect(calls).toEqual(["checkout #21325", "worktree #21324"])
-    expect(s.captureCharFrame()).toContain("✗ w needs gh 2.98 or newer")
-  } finally { s.renderer.destroy() }
-})

package/src/checkout.test.ts

@@ -1,145 +0,0 @@
-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/github.test.ts

@@ -1,121 +0,0 @@
-import { expect, test } from "bun:test"
-import { BUCKETS, buildNumbersQuery, buildQuery, localBranch, parseSearch, relativeTime, searchQuery, toBuckets, toNumbersBucket } from "./github"
-import { parseRepo } from "./repo"
-
-const now = new Date("2026-09-15T15:00:00Z")
-
-// Shaped like a real node from `gh api graphql` against cli/cli.
-const node = (over: Record<string, unknown> = {}) => ({
-  number: 14456,
-  title: "Refreshable tokens (7/7): guided end-to-end verification scripts",
-  url: "https://github.com/cli/cli/pull/14456",
-  isDraft: false,
-  state: "OPEN",
-  additions: 1118,
-  deletions: 0,
-  updatedAt: "2026-09-15T01:49:02Z",
-  reviewDecision: "REVIEW_REQUIRED",
-  author: { login: "babakks" },
-  commits: { nodes: [{ commit: { statusCheckRollup: { state: "SUCCESS" } } }] },
-  headRefName: "babakks/refreshable-tokens-7",
-  isCrossRepository: false,
-  headRepositoryOwner: { login: "cli" },
-  baseRepository: { defaultBranchRef: { name: "trunk" } },
-  ...over,
-})
-const rollup = (state: string | null) => ({ nodes: [{ commit: { statusCheckRollup: state && { state } } }] })
-const search = (...nodes: object[]) => ({ issueCount: 318, nodes })
-
-test("buildQuery searches every bucket in one request", () => {
-  const q = buildQuery()
-  expect(q).toContain("fragment pr on PullRequest")
-  BUCKETS.forEach((_, i) => expect(q).toContain(`b${i}: search(query: $q${i}, type: ISSUE, first: 25)`))
-  expect(searchQuery(parseRepo("cli/cli"), 0)).toBe("repo:cli/cli is:pr sort:updated-desc is:open user-review-requested:@me")
-})
-
-test("toBuckets maps search results onto PR rows", () => {
-  const buckets = toBuckets({
-    data: {
-      b0: search(node(), {}), // {} is a non-PR search hit
-      b1: search(node({ reviewDecision: "CHANGES_REQUESTED", author: null, commits: rollup("FAILURE") })),
-      b2: search(node({ reviewDecision: "APPROVED", commits: { nodes: [] } })),
-      b3: search(node({ reviewDecision: null, updatedAt: "2026-08-26T15:00:00Z", commits: rollup("PENDING") })),
-      b4: search(node({ isDraft: true, commits: rollup("EXPECTED") })),
-      b5: search(node({ author: { login: "someone-else" } })),
-      b6: search(node({ state: "MERGED", reviewDecision: "APPROVED", updatedAt: "2025-01-01T00:00:00Z" })),
-    },
-  }, now)
-
-  expect(buckets.map(b => b.name)).toEqual(BUCKETS.map(b => b.name))
-  expect(buckets[0]).toEqual({
-    name: "Needs your review",
-    total: 318,
-    prs: [{
-      number: 14456, title: "Refreshable tokens (7/7): guided end-to-end verification scripts", author: "babakks",
-      state: "review", ci: "pass", review: "pending", additions: 1118, deletions: 0, updated: "13h", stale: false,
-      url: "https://github.com/cli/cli/pull/14456", branch: "babakks/refreshable-tokens-7",
-    }],
-  })
-  const row = (i: number) => buckets[i]!.prs[0]!
-  expect(row(1)).toMatchObject({ state: "author", ci: "fail", review: "fail", author: "ghost" })
-  expect(row(2)).toMatchObject({ state: "approved", ci: "pending", review: "pass" })
-  expect(row(3)).toMatchObject({ state: "review", ci: "running", review: "pending", updated: "20d", stale: true })
-  expect(row(4)).toMatchObject({ state: "draft", ci: "pending" })
-  expect(buckets[5]!.name).toBe("Open")
-  expect(row(5)).toMatchObject({ state: "review", author: "someone-else" })
-  expect(row(6)).toMatchObject({ state: "merged", ci: "pass", review: "merged", updated: "1y", stale: false })
-})
-
-test("toBuckets: missing searches are empty, GraphQL errors throw", () => {
-  expect(toBuckets({ data: {} }, now).every(b => b.total === 0 && b.prs.length === 0)).toBe(true)
-  expect(() => toBuckets({ errors: [{ message: "Field 'bogus' doesn't exist on type 'Query'" }] }, now)).toThrow("Field 'bogus'")
-})
-
-test("relativeTime", () => {
-  const ago = (s: number) => relativeTime(new Date(now.getTime() - s * 1000).toISOString(), now)
-  expect([ago(5), ago(59 * 60), ago(3600), ago(23 * 3600), ago(86400), ago(400 * 86400), ago(-30)])
-    .toEqual(["now", "59m", "1h", "23h", "1d", "1y", "now"])
-})
-
-test("localBranch follows gh: a fork's branch named like the default branch gets the owner as a prefix", () => {
-  const pr = (over: object) => ({ headRefName: "fix", isCrossRepository: false, headRepositoryOwner: { login: "cli" }, baseRepository: { defaultBranchRef: { name: "trunk" } }, ...over })
-  expect(localBranch(pr({}))).toBe("fix")
-  expect(localBranch(pr({ isCrossRepository: true, headRepositoryOwner: { login: "octo" } }))).toBe("fix")
-  expect(localBranch(pr({ isCrossRepository: true, headRefName: "trunk", headRepositoryOwner: { login: "octo" } }))).toBe("octo/trunk")
-  expect(localBranch(pr({ isCrossRepository: true, headRefName: "trunk", headRepositoryOwner: null }))).toBe("ghost/trunk")
-})
-
-test("parseSearch splits words, @authors and #numbers; searchQuery adds them to every bucket", () => {
-  const s = parseSearch("  fix @babakks  #123 token# ")
-  expect(s).toEqual({ words: ["fix", "token#"], authors: ["babakks"], numbers: [123] })
-  expect(parseSearch("")).toEqual({ words: [], authors: [], numbers: [] })
-
-  const repo = parseRepo("cli/cli")
-  expect(searchQuery(repo, 5, s)).toBe("repo:cli/cli is:pr sort:updated-desc is:open fix token# in:title author:babakks")
-  expect(searchQuery(repo, 5, parseSearch("@babakks"))).toBe("repo:cli/cli is:pr sort:updated-desc is:open author:babakks")
-  // GitHub would OR a second author: into author:@me, so your own buckets leave it out.
-  expect(searchQuery(repo, 6, s)).toBe("repo:cli/cli is:pr sort:updated-desc is:merged author:@me fix token# in:title")
-})
-
-test("an @author search empties your own buckets unless the author is you", () => {
-  const res = { data: { viewer: { login: "OscBacon" }, ...Object.fromEntries(BUCKETS.map((_, i) => [`b${i}`, search(node())])) } }
-  const totals = (q: string) => toBuckets(res, now, parseSearch(q)).map(b => b.total)
-  expect(totals("fix")).toEqual([318, 318, 318, 318, 318, 318, 318])
-  expect(totals("@babakks")).toEqual([318, 0, 0, 0, 0, 318, 0])
-  expect(totals("@babakks @oscbacon")).toEqual([318, 318, 318, 318, 318, 318, 318])
-  expect(buildQuery()).toContain("viewer { login }")
-})
-
-test("#numbers are looked up directly and narrowed by the other terms", () => {
-  expect(buildNumbersQuery([12, 34])).toContain("repository(owner: $owner, name: $name) { n12: pullRequest(number: 12) { ...pr } n34: pullRequest(number: 34) { ...pr } }")
-
-  const res = {
-    data: { repository: { n1: node({ number: 1, title: "Fix tokens" }), n2: node({ number: 2, title: "Docs" }), n3: null } },
-    errors: [{ type: "NOT_FOUND", message: "Could not resolve to a PullRequest with the number of 3." }],
-  }
-  expect(toNumbersBucket(res, parseSearch("#1 #2 #3"), now).prs.map(p => p.number)).toEqual([1, 2])
-  expect(toNumbersBucket(res, parseSearch("#1 #2 fix"), now).prs.map(p => p.number)).toEqual([1])
-  expect(toNumbersBucket(res, parseSearch("#1 @someone"), now)).toEqual({ name: "Search results", prs: [] })
-  expect(toNumbersBucket(res, parseSearch("#1 @someone @BABAKKS"), now).prs.map(p => p.number)).toEqual([1])
-  expect(() => toNumbersBucket({ errors: [{ type: "FORBIDDEN", message: "nope" }] }, parseSearch("#1"), now)).toThrow("nope")
-})

package/src/repo.test.ts

@@ -1,91 +0,0 @@
-import { expect, test } from "bun:test"
-import { execFileSync } from "node:child_process"
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs"
-import { tmpdir } from "node:os"
-import { join } from "node:path"
-import { detectRepo, ghHosts, parseRemoteUrl, parseRepo, resolveRepo, type GhHosts, type Remote } from "./repo"
-
-const repo = (owner: string, name: string, host = "github.com") => ({ host, owner, name })
-const hosts = (over: Partial<GhHosts> = {}): GhHosts => ({ known: ["github.com"], defaultHost: "github.com", source: "default", ...over })
-const ghe: Partial<GhHosts> = { known: ["github.com", "ghe.example.com"], defaultHost: "ghe.example.com" }
-
-const withTmp = (fn: (dir: string) => void) => {
-  const dir = mkdtempSync(join(tmpdir(), "inbox-tui-"))
-  try { fn(dir) } finally { rmSync(dir, { recursive: true, force: true }) }
-}
-
-test("parseRepo accepts [HOST/]OWNER/REPO", () => {
-  expect(parseRepo("cli/cli")).toEqual(repo("cli", "cli"))
-  expect(parseRepo("cli/cli", "ghe.example.com")).toEqual(repo("cli", "cli", "ghe.example.com"))
-  expect(parseRepo("GHE.example.com/acme/app")).toEqual(repo("acme", "app", "ghe.example.com"))
-  for (const bad of ["cli", "a/b/c/d", "/cli", "cli/", ""]) expect(() => parseRepo(bad)).toThrow()
-})
-
-test("parseRemoteUrl follows gh's URL handling", () => {
-  expect(parseRemoteUrl("https://github.com/cli/cli.git")).toEqual(repo("cli", "cli"))
-  expect(parseRemoteUrl("https://github.com/cli/cli/")).toEqual(repo("cli", "cli"))
-  expect(parseRemoteUrl("git+https://www.GitHub.com/cli/cli")).toEqual(repo("cli", "cli"))
-  expect(parseRemoteUrl("git@github.com:OscBacon/personal-website.git")).toEqual(repo("OscBacon", "personal-website"))
-  expect(parseRemoteUrl("git+ssh://git@github.com/cli/cli.git")).toEqual(repo("cli", "cli"))
-  expect(parseRemoteUrl("ssh://git@ssh.github.com:443/cli/cli.git")).toEqual(repo("cli", "cli"))
-  expect(parseRemoteUrl("https://user@GHE.example.com/acme/app.git")).toEqual(repo("acme", "app", "ghe.example.com"))
-
-  const alias = (h: string) => (h === "work" ? "github.com" : h)
-  expect(parseRemoteUrl("git@work:acme/app.git", alias)).toEqual(repo("acme", "app"))
-  expect(parseRemoteUrl("https://work/acme/app", alias)).toEqual(repo("acme", "app", "work")) // aliases are ssh-only
-
-  for (const bad of ["/srv/git/app.git", "../local", "file:///srv/a/b", "C:\\repos\\app", "https://github.com/cli", "https://github.com/cli/cli/pulls"]) {
-    expect(parseRemoteUrl(bad)).toBeNull()
-  }
-})
-
-test("resolveRepo: gh-resolved first, then upstream > github > origin > others", () => {
-  const fork = "git@github.com:me/app.git", parent = "https://github.com/acme/app.git"
-  const r = (name: string, fetchUrl: string, extra: Partial<Remote> = {}): Remote => ({ name, fetchUrl, ...extra })
-
-  expect(resolveRepo([r("mine", fork), r("origin", fork), r("Upstream", parent)], hosts())).toEqual(repo("acme", "app"))
-  expect(resolveRepo([r("zzz", parent), r("origin", fork)], hosts())).toEqual(repo("me", "app"))
-  expect(resolveRepo([r("origin", fork, { resolved: "base" }), r("upstream", parent)], hosts())).toEqual(repo("me", "app"))
-  expect(resolveRepo([r("origin", fork, { resolved: "other/thing" })], hosts({ ...ghe, source: "hosts" }))).toEqual(repo("other", "thing", "ghe.example.com"))
-  expect(resolveRepo([r("origin", "/srv/git/app.git", { pushUrl: parent })], hosts())).toEqual(repo("acme", "app"))
-  expect(() => resolveRepo([], hosts())).toThrow(/no git remotes/)
-})
-
-test("resolveRepo only considers known hosts, preferring the default host", () => {
-  const gitlab = { name: "origin", fetchUrl: "https://gitlab.com/me/app" }
-  const dotcom = { name: "mirror", fetchUrl: "https://github.com/acme/app" }
-  const enterprise = { name: "zzz", fetchUrl: "https://ghe.example.com/acme/app" }
-
-  expect(resolveRepo([gitlab, dotcom], hosts())).toEqual(repo("acme", "app"))
-  expect(() => resolveRepo([gitlab], hosts())).toThrow(/known GitHub host/)
-  // A single hosts.yml entry wins when a remote matches it, and falls back otherwise.
-  expect(resolveRepo([dotcom, enterprise], hosts({ ...ghe, source: "hosts" }))).toEqual(repo("acme", "app", "ghe.example.com"))
-  expect(resolveRepo([dotcom], hosts({ ...ghe, source: "hosts" }))).toEqual(repo("acme", "app"))
-  // GH_HOST never falls back.
-  expect(() => resolveRepo([dotcom], hosts({ ...ghe, source: "GH_HOST" }))).toThrow(/GH_HOST/)
-})
-
-test("ghHosts reads host keys from gh's config dir and GH_HOST", () => {
-  withTmp(dir => {
-    writeFileSync(join(dir, "hosts.yml"), "github.com:\n    user: me\n    oauth_token: secret\nghe.example.com:\n    user: me\n")
-    expect(ghHosts({ GH_CONFIG_DIR: dir })).toEqual({ known: ["github.com", "ghe.example.com"], defaultHost: "github.com", source: "default" })
-    expect(ghHosts({ GH_CONFIG_DIR: dir, GH_HOST: "GHE.example.com" })).toMatchObject({ defaultHost: "ghe.example.com", source: "GH_HOST" })
-
-    writeFileSync(join(dir, "hosts.yml"), "ghe.example.com:\n    user: me\n")
-    expect(ghHosts({ GH_CONFIG_DIR: dir })).toEqual({ known: ["ghe.example.com", "github.com"], defaultHost: "ghe.example.com", source: "hosts" })
-  })
-})
-
-test("detectRepo reads a real clone's remotes, insteadOf rewrites and gh-resolved", () => {
-  withTmp(dir => {
-    const git = (...args: string[]) => execFileSync("git", ["-C", dir, ...args])
-    git("init", "-q")
-    git("config", "url.https://github.com/.insteadOf", "gh:")
-    git("remote", "add", "origin", "gh:me/app")
-    git("remote", "add", "upstream", "gh:acme/app")
-    expect(detectRepo(dir, hosts())).toEqual(repo("acme", "app"))
-    git("config", "remote.origin.gh-resolved", "base")
-    expect(detectRepo(dir, hosts())).toEqual(repo("me", "app"))
-  })
-  withTmp(dir => expect(() => detectRepo(dir, hosts())).toThrow(/no git remotes/))
-})

package/src/run.test.ts

@@ -1,28 +0,0 @@
-import { expect, test } from "bun:test"
-import { run } from "./run"
-
-// Prints the prompt switches and whether the shell leads its own session (sid == pid).
-const probe = ["-c", 'echo "$GIT_TERMINAL_PROMPT/$GH_PROMPT_DISABLED"; [ "$(ps -o sid= -p $$ | tr -d " ")" = "$$" ] && echo own-session || echo shared-session']
-
-test.skipIf(process.platform === "win32")("noPrompts runs without a controlling terminal and with prompts disabled", async () => {
-  const { code, stdout } = await run("sh", probe, { noPrompts: true })
-  expect(code).toBe(0)
-  expect(stdout).toBe("0/1\nown-session\n")
-})
-
-test.skipIf(process.platform === "win32")("by default the command keeps the app's session and environment", async () => {
-  const saved = [process.env.GIT_TERMINAL_PROMPT, process.env.GH_PROMPT_DISABLED]
-  delete process.env.GIT_TERMINAL_PROMPT
-  delete process.env.GH_PROMPT_DISABLED
-  try {
-    expect((await run("sh", probe)).stdout).toBe("/\nshared-session\n")
-  } finally {
-    if (saved[0] !== undefined) process.env.GIT_TERMINAL_PROMPT = saved[0]
-    if (saved[1] !== undefined) process.env.GH_PROMPT_DISABLED = saved[1]
-  }
-})
-
-test("run reports exit codes and output, and rejects when the command is missing", async () => {
-  expect(await run("sh", ["-c", "echo out; echo err >&2; exit 3"])).toEqual({ code: 3, stdout: "out\n", stderr: "err\n" })
-  await expect(run("tungsten-no-such-command", [])).rejects.toMatchObject({ code: "ENOENT" })
-})