@oscbacon/tungsten 0.0.1

package/src/github.test.ts

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

@@ -0,0 +1,222 @@
+import type { Bucket, PR, State, Status } from "./data"
+import type { Repo } from "./repo"
+import { run } from "./run"
+
+export const PAGE_SIZE = 25
+const STALE_DAYS = 14
+
+// One GitHub search per bucket; searchQuery() prepends the repo and sort.
+export const BUCKETS = [
+  { name: "Needs your review", query: "is:open user-review-requested:@me" },
+  { name: "Returned to you", query: "is:open author:@me review:changes_requested" },
+  { name: "Approved", query: "is:open author:@me review:approved" },
+  // Not `review:required`: that never matches in repos without required reviews.
+  { name: "Waiting for reviewers", query: "is:open author:@me -is:draft -review:approved -review:changes_requested" },
+  { name: "Drafts", query: "is:open author:@me draft:true" },
+  { name: "Open", query: "is:open" }, // everyone's, not just yours
+  { name: "Recently merged", query: "is:merged author:@me" },
+]
+
+// What the user typed after "/": words match titles, @login an author, #123 a PR number.
+// Like GitHub's author: qualifiers, several authors mean any of them.
+export interface Search {
+  words: string[]
+  authors: string[]
+  numbers: number[]
+}
+
+export function parseSearch(input: string): Search {
+  const search: Search = { words: [], authors: [], numbers: [] }
+  for (const term of input.trim().split(/\s+/).filter(Boolean)) {
+    if (/^@[^@\s]+$/.test(term)) search.authors.push(term.slice(1))
+    else if (/^#\d+$/.test(term)) search.numbers.push(Number(term.slice(1)))
+    else search.words.push(term)
+  }
+  return search
+}
+
+// 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))
+    && s.words.every(w => title.includes(w.toLowerCase()))
+    && (s.authors.length === 0 || s.authors.some(a => author === a.toLowerCase()))
+}
+
+// Buckets of your own PRs. GitHub ORs author: qualifiers, so these can't take the search's authors;
+// toBuckets() keeps them only when one of those authors is you.
+const isMine = (i: number) => BUCKETS[i]!.query.includes("author:@me")
+
+// GitHub search terms for the words and authors; numbers can't be searched, see buildNumbersQuery().
+function searchTerms(s: Search, mine: boolean): string {
+  const authors = mine ? [] : s.authors.map(a => `author:${a}`)
+  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(" ")
+
+const FIELDS = `number title url isDraft state additions deletions updatedAt reviewDecision
+  author { login } commits(last: 1) { nodes { commit { statusCheckRollup { state } } } }
+  headRefName isCrossRepository headRepositoryOwner { login } baseRepository { defaultBranchRef { name } }`
+
+// Searches are passed as variables, so repo names never need escaping in the query text.
+export function buildQuery(): string {
+  const vars = BUCKETS.map((_, i) => `$q${i}: String!`).join(", ")
+  const searches = BUCKETS.map((_, i) => `b${i}: search(query: $q${i}, type: ISSUE, first: ${PAGE_SIZE}) { issueCount nodes { ...pr } }`)
+  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}`
+}
+
+interface PrNode {
+  number: number
+  title: string
+  url: string
+  isDraft: boolean
+  state: string // OPEN | CLOSED | MERGED
+  additions: number
+  deletions: number
+  updatedAt: string
+  reviewDecision: string | null // APPROVED | CHANGES_REQUESTED | REVIEW_REQUIRED
+  author: { login: string } | null // null for deleted accounts
+  commits: { nodes: ({ commit: { statusCheckRollup: { state: string } | null } } | null)[] }
+  headRefName: string
+  isCrossRepository: boolean
+  headRepositoryOwner: { login: string } | null // null once the fork is deleted
+  baseRepository: { defaultBranchRef: { name: string } | null } | null
+}
+
+interface SearchResult {
+  issueCount: number
+  nodes: unknown[]
+}
+
+export interface SearchResponse {
+  data?: Record<string, SearchResult | { login: string } | null> // b0..b6, plus viewer
+  errors?: { message: string }[]
+}
+
+export interface NumbersResponse {
+  data?: { repository: Record<string, unknown> | null } | null
+  errors?: { message: string; type?: string }[]
+}
+
+// Non-PR search hits come back as empty objects.
+const isPrNode = (n: unknown): n is PrNode => typeof n === "object" && n !== null && "number" in n
+
+const CI: Record<string, Status> = { SUCCESS: "pass", FAILURE: "fail", ERROR: "fail", PENDING: "running" }
+
+export function relativeTime(iso: string, now: Date): string {
+  const s = Math.max(0, (now.getTime() - Date.parse(iso)) / 1000)
+  if (s < 60) return "now"
+  if (s < 3600) return `${Math.floor(s / 60)}m`
+  if (s < 86400) return `${Math.floor(s / 3600)}h`
+  if (s < 365 * 86400) return `${Math.floor(s / 86400)}d`
+  return `${Math.floor(s / (365 * 86400))}y`
+}
+
+// Like gh pr checkout: a fork's branch named after the default branch would clash with it,
+// so it gets the fork owner as a prefix.
+export function localBranch(n: Pick<PrNode, "headRefName" | "isCrossRepository" | "headRepositoryOwner" | "baseRepository">): string {
+  const clashes = n.isCrossRepository && n.headRefName === n.baseRepository?.defaultBranchRef?.name
+  return clashes ? `${n.headRepositoryOwner?.login ?? "ghost"}/${n.headRefName}` : n.headRefName
+}
+
+function toPR(n: PrNode, now: Date): PR {
+  const merged = n.state === "MERGED"
+  const state: State =
+    merged ? "merged" :
+    n.isDraft ? "draft" :
+    n.reviewDecision === "APPROVED" ? "approved" :
+    n.reviewDecision === "CHANGES_REQUESTED" ? "author" :
+    "review"
+  const review: Status =
+    merged ? "merged" :
+    n.reviewDecision === "APPROVED" ? "pass" :
+    n.reviewDecision === "CHANGES_REQUESTED" ? "fail" :
+    "pending"
+  const rollup = n.commits.nodes[0]?.commit.statusCheckRollup?.state ?? ""
+
+  return {
+    number: n.number,
+    title: n.title,
+    author: n.author?.login ?? "ghost",
+    state,
+    ci: CI[rollup] ?? "pending",
+    review,
+    additions: n.additions,
+    deletions: n.deletions,
+    updated: relativeTime(n.updatedAt, now),
+    stale: !merged && now.getTime() - Date.parse(n.updatedAt) > STALE_DAYS * 86400_000,
+    url: n.url,
+    branch: localBranch(n),
+  }
+}
+
+export function toBuckets(res: SearchResponse, now = new Date(), search?: Search): Bucket[] {
+  if (res.errors?.length) throw new Error(res.errors.map(e => e.message).join("; "))
+  const viewer = (res.data?.viewer as { login: string } | undefined)?.login.toLowerCase()
+  const notMe = !!search?.authors.length && !search.authors.some(a => a.toLowerCase() === viewer)
+  return BUCKETS.map((b, i) => {
+    if (notMe && isMine(i)) return { name: b.name, total: 0, prs: [] }
+    const result = res.data?.[`b${i}`] as SearchResult | null | undefined
+    return { name: b.name, total: result?.issueCount ?? 0, prs: (result?.nodes ?? []).filter(isPrNode).map(n => toPR(n, now)) }
+  })
+}
+
+// One "Search results" bucket with the PRs that exist, narrowed by the other terms.
+export function toNumbersBucket(res: NumbersResponse, search: Search, now = new Date()): Bucket {
+  // 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}`])
+    .filter(isPrNode)
+    .map(n => toPR(n, now))
+    .filter(pr => matches(pr, search))
+  return { name: "Search results", prs }
+}
+
+async function gh(args: string[]) {
+  try {
+    return await run("gh", args)
+  } catch (e) {
+    if ((e as NodeJS.ErrnoException).code === "ENOENT") throw new Error("gh is not installed (https://cli.github.com); run with --demo to try the UI")
+    throw e
+  }
+}
+
+// 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> {
+  const { code, stdout, stderr } = await gh([
+    "api", "graphql", "--hostname", repo.host,
+    ...Object.entries(fields).flatMap(([k, v]) => ["-f", `${k}=${v}`]),
+  ])
+
+  let res: T | undefined
+  try {
+    res = JSON.parse(stdout)
+  } catch {
+    // Not JSON: gh failed before querying (not logged in, network, ...).
+  }
+  // GraphQL errors exit non-zero but still print the response, which carries the useful message.
+  if (res && (code === 0 || res.errors?.length)) return res
+  throw new Error(stderr.trim().split("\n")[0] || `gh exited with code ${code}`)
+}
+
+export async function fetchBuckets(repo: Repo, search?: Search): Promise<Bucket[]> {
+  if (search?.numbers.length) {
+    const res = await graphql<NumbersResponse>(repo, { query: buildNumbersQuery(search.numbers), owner: repo.owner, name: repo.name })
+    return [toNumbersBucket(res, search)]
+  }
+  const res = await graphql<SearchResponse>(repo, {
+    query: buildQuery(),
+    ...Object.fromEntries(BUCKETS.map((_, i) => [`q${i}`, searchQuery(repo, i, search)])),
+  })
+  return toBuckets(res, new Date(), search)
+}

package/src/index.tsx

@@ -0,0 +1,95 @@
+#!/usr/bin/env bun
+import { createCliRenderer } from "@opentui/core"
+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 { fetchBuckets, matches, parseSearch } from "./github"
+import { detectRepo, ghHosts, parseRepo, repoLabel, type Repo } from "./repo"
+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
+      --demo                     Show sample data instead of fetching from GitHub
+      --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
+let demo: boolean
+let showGitPrompt: boolean
+let notLocal: string | undefined // why c and w can't work from here
+try {
+  const { values } = parseArgs({
+    options: {
+      repo: { type: "string", short: "R" },
+      demo: { type: "boolean" },
+      "show-git-prompt": { type: "boolean" },
+      help: { type: "boolean", short: "h" },
+    },
+  })
+  if (values.help) {
+    console.log(USAGE)
+    process.exit(0)
+  }
+  demo = values.demo ?? false
+  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.
+  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`
+    }
+  }
+} catch (e) {
+  console.error(`${(e as Error).message}\n\n${USAGE}`)
+  process.exit(1)
+}
+
+const load = async (search?: string) => {
+  const s = search ? parseSearch(search) : undefined
+  if (!demo) return fetchBuckets(repo, s)
+  const buckets = demoBuckets(repo)
+  return s ? buckets.map(b => ({ name: b.name, prs: b.prs.filter(pr => matches(pr, s)) })) : buckets
+}
+
+const renderer = await createCliRenderer({ exitOnCtrlC: true })
+
+// Commands that may prompt fail instead, so the app stays on screen;
+// --show-git-prompt hands them the real terminal, hiding the app while they run.
+const runGit: Run = async (cmd, args, opts) => {
+  if (!opts?.interactive) return run(cmd, args)
+  if (!showGitPrompt) return run(cmd, args, { noPrompts: true })
+  renderer.suspend()
+  try {
+    return await run(cmd, args, { terminal: true })
+  } finally {
+    renderer.resume()
+  }
+}
+
+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 })),
+    }
+
+createRoot(renderer).render(<App repo={repo} load={load} actions={actions} />)

package/src/repo.test.ts

@@ -0,0 +1,91 @@
+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/))
+})