@oscbacon/tungsten 0.0.1 → 0.0.2

package/README.md

@@ -15,17 +15,28 @@ 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 --demo          # sample data, no clone or network
+tungsten --show-git-prompt  # let c and w ask for ssh passphrases or credentials
+```
 
 ## Buckets
 

package/package.json

@@ -1,10 +1,30 @@
 {
   "name": "@oscbacon/tungsten",
   "type": "module",
-  "version": "0.0.1",
+  "version": "0.0.2",
+  "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/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" })
-})