@oscbacon/tungsten 0.0.2 → 0.1.0

package/README.md

@@ -34,7 +34,9 @@ bun link    # links `tungsten` into ~/.bun/bin; make sure that's on your PATH
 ```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
 ```
 
@@ -48,7 +50,8 @@ tungsten --show-git-prompt  # let c and w ask for ssh passphrases or credentials
 - 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
 
@@ -70,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,9 +1,15 @@
 {
   "name": "@oscbacon/tungsten",
   "type": "module",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "description": "A terminal inbox for a GitHub repo's pull requests",
-  "keywords": ["github", "pull-requests", "tui", "terminal", "cli"],
+  "keywords": [
+    "github",
+    "pull-requests",
+    "tui",
+    "terminal",
+    "cli"
+  ],
   "license": "MIT",
   "author": "Oscar Baracos",
   "repository": {

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 {