@osdlc/typed-gh 0.6.0 → 0.9.0

package/sync.ts

@@ -1,438 +0,0 @@
-/**
- * `Gh` — the synchronous GitHub client, the companion of `@osdlc/typed-git`'s
- * `Git`, bound to one working directory and one {@link CommandRunner}.
- *
- * Authentication is `gh`'s, not ours: no token is read, stored, or passed.
- * That is the whole reason this shells out to the CLI instead of speaking
- * REST — the credential already exists in the user's keychain, and a library
- * that reaches for `GITHUB_TOKEN` is a library that can leak one.
- *
- * Tri-modal, same as the git client: queries return parsed values and never
- * throw, mutations throw `CommandFailed`, and `raw`/`rawChecked` are the
- * escape hatches.
- */
-
-import {
-  runChecked,
-  resolveRunner,
-  spawnRunner,
-  type CommandResult,
-  type CommandRunner,
-  type CommandRunOptions,
-} from '@osdlc/command-seam'
-
-import * as v from './verbs.ts'
-import type {
-  ApiOptions,
-  ApiResponse,
-  AuthStatus,
-  GhTarget,
-  GhVerb,
-  IssueListOptions,
-  ListResult,
-  PrListOptions,
-} from './verbs.ts'
-import { ownerRepoSlug, parseOwnerRepo, parsePrRef } from './repo.ts'
-import type { IssueRow, Label, OwnerRepo, PrSearchHit, PullRequest, Repository } from './types.ts'
-
-/**
- * Factory of per-binary runners — the injectable subprocess seam a CLI tail
- * threads through its call graph. Production uses `spawnRunner`; tests supply
- * a recording factory so a whole tail runs offline.
- */
-export type RunnerFactory = (binary: string) => CommandRunner
-
-/** Default factory: real, spawnSync-backed runners. */
-export const defaultRunnerFactory: RunnerFactory = spawnRunner
-
-/** How long to wait between merge-state retries, in milliseconds. */
-const MERGE_STATE_RETRY_DELAY_MS = 1_500
-
-/** What a client is built with: the runner, and the repository and host it talks to. */
-export interface GhOptions extends GhTarget {
-  runner?: CommandRunner | undefined
-}
-
-/**
- * A typed gh client bound to one working directory, and optionally to one
- * repository and host.
- *
- * With `repo`, every call names that repository (`--repo`, or the
- * `{owner}/{repo}` of an `api` endpoint), so no clone is needed. Without it,
- * gh uses the repository of the clone at `cwd`. With `hostname`, every call
- * goes to that GitHub host. An invalid `repo` or `hostname` throws
- * `RangeError`.
- *
- * Every `timeoutMs` option is a hard cap on the call. An invalid value
- * throws, as in command-seam: `RangeError` for 0, a negative value or `NaN`;
- * `TypeError` for a non-number.
- */
-export class Gh {
-  readonly cwd: string
-  readonly repo: string | undefined
-  readonly hostname: string | undefined
-  private readonly target: GhTarget
-  private readonly runner: CommandRunner
-
-  constructor(cwd: string, opts: GhOptions = {}) {
-    v.checkTarget(opts)
-    this.cwd = cwd
-    this.repo = opts.repo
-    this.hostname = opts.hostname
-    this.target = { repo: opts.repo, hostname: opts.hostname }
-    this.runner = resolveRunner('gh', opts.runner)
-  }
-
-  /** The same client rooted at a different directory (same runner, repo and host). */
-  at(cwd: string): Gh {
-    return new Gh(cwd, { runner: this.runner, repo: this.repo, hostname: this.hostname })
-  }
-
-  /** The same client aimed at another repository (same runner, directory and host). */
-  withRepo(repo: string): Gh {
-    return new Gh(this.cwd, { runner: this.runner, repo, hostname: this.hostname })
-  }
-
-  // ── escape hatches ────────────────────────────────────────────────────────
-
-  /** Unchecked passthrough for verbs not yet lifted into the API. */
-  raw(argv: string[], opts: { timeoutMs?: number | undefined } = {}): CommandResult {
-    return this.runner.run(argv, { cwd: this.cwd, ...opts })
-  }
-
-  /** Checked passthrough — throws `CommandFailed` on a non-zero exit. */
-  rawChecked(argv: string[], opts: { timeoutMs?: number | undefined } = {}): CommandResult {
-    return runChecked(this.runner, argv, { cwd: this.cwd, ...opts })
-  }
-
-  /** Run one verb from the table, honouring its checked/unchecked contract. */
-  private exec<T>(verb: GhVerb<T>, timeoutMs?: number | undefined): T {
-    const opts: CommandRunOptions = { cwd: this.cwd }
-    if (verb.input !== undefined) opts.input = verb.input
-    if (verb.env !== undefined) opts.env = verb.env
-    if (timeoutMs !== undefined) opts.timeoutMs = timeoutMs
-    const result = verb.checked
-      ? runChecked(this.runner, verb.argv, opts)
-      : this.runner.run(verb.argv, opts)
-    return verb.parse(result)
-  }
-
-  // ── queries ───────────────────────────────────────────────────────────────
-
-  /** Pull requests matching `opts`, or null when gh failed. */
-  prList(
-    opts: PrListOptions & { timeoutMs?: number | undefined } = {},
-  ): ListResult<PullRequest> | null {
-    return this.exec(v.prList(opts, this.target), opts.timeoutMs)
-  }
-
-  /**
-   * One PR by number, branch or URL, with the heavy fields; null when gh
-   * failed or there is no such PR.
-   */
-  prView(
-    ref: number | string,
-    opts: { fields?: readonly string[] | undefined; timeoutMs?: number | undefined } = {},
-  ): PullRequest | null {
-    return this.exec(v.prView(ref, opts.fields ?? v.PR_VIEW_FIELDS, this.target), opts.timeoutMs)
-  }
-
-  /**
-   * The one PR that `input` names, or null: what a person typed, such as `42`,
-   * `#42`, `owner/name#42`, a URL or a branch (read by `parsePrRef`).
-   *
-   * Digits are a PR number first; when no such PR comes back, they are tried
-   * as a branch. A branch gives its open PR, or else its newest closed or
-   * merged one, so a tool run after the merge still finds it. Fields default
-   * to {@link PR_LIST_FIELDS}.
-   */
-  prFind(
-    input: string,
-    opts: { fields?: readonly string[] | undefined; timeoutMs?: number | undefined } = {},
-  ): PullRequest | null {
-    const ref = parsePrRef(input)
-    if (ref === null) return null
-    const fields = opts.fields ?? v.PR_LIST_FIELDS
-    const call = { fields, timeoutMs: opts.timeoutMs }
-    if (ref.kind === 'url') return this.prView(ref.url, call)
-    if (ref.kind === 'branch') return prForBranchOn(this, ref.name, call)
-    const client = ref.repo === null ? this : this.withRepo(ownerRepoSlug(ref.repo))
-    const pr = client.prView(ref.number, call)
-    return pr !== null || ref.orBranch === null ? pr : prForBranchOn(this, ref.orBranch, call)
-  }
-
-  /**
-   * The open PR whose head exactly equals `branch`, or null.
-   *
-   * Defaults to {@link PR_REF_FIELDS}: identifying a PR must not cost a
-   * merge-state computation. Pass `opts.fields` to ask for more (e.g.
-   * `isDraft`) in the SAME call, when a caller needs a field beyond identity
-   * before deciding whether to act on the PR at all — asking `prList`/`prView`
-   * separately would cost a second round trip for the common case where the
-   * caller already knows it wants that field up front.
-   */
-  openPrFor(
-    branch: string,
-    opts: { limit?: number | undefined; fields?: readonly string[] | undefined } = {},
-  ): PullRequest | null {
-    const rows = this.prList({
-      head: branch,
-      limit: opts.limit ?? 5,
-      fields: opts.fields ?? v.PR_REF_FIELDS,
-    })
-    return v.pickPrForBranch(rows?.rows ?? null, branch)
-  }
-
-  /**
-   * {@link prView}, re-asked until GitHub settles the merge state.
-   *
-   * GitHub computes mergeability lazily: the first query kicks it off and
-   * answers `UNKNOWN` while it runs. A caller that believes that first answer
-   * mis-triages every PR that is merely slow to compute, so this re-asks
-   * `attempts` times before returning what it has. The last answer is
-   * returned whether or not it settled — `UNKNOWN` is a legitimate final
-   * verdict and callers must still handle it.
-   *
-   * `sleep` is injected so a test does not spend real seconds waiting.
-   */
-  prViewSettled(
-    number: number,
-    opts: {
-      attempts?: number | undefined
-      fields?: readonly string[] | undefined
-      sleep?: ((ms: number) => void) | undefined
-      timeoutMs?: number | undefined
-    } = {},
-  ): PullRequest | null {
-    const attempts = Math.max(1, opts.attempts ?? 3)
-    const sleep = opts.sleep ?? sleepSync
-    let last: PullRequest | null = null
-    for (let i = 0; i < attempts; i += 1) {
-      last = this.prView(number, opts)
-      if (last === null || !v.needsMergeStateRetry(last)) return last
-      if (i < attempts - 1) sleep(MERGE_STATE_RETRY_DELAY_MS)
-    }
-    return last
-  }
-
-  /** A PR's body text, or null when gh failed. */
-  prBody(number: number, opts: { timeoutMs?: number | undefined } = {}): string | null {
-    return this.exec(v.prBody(number, this.target), opts.timeoutMs)
-  }
-
-  /**
-   * A REST GET through `gh api`. Never throws: failure is `ok: false` on the
-   * returned {@link ApiResponse}.
-   */
-  api(endpoint: string, opts: ApiOptions & { timeoutMs?: number | undefined } = {}): ApiResponse {
-    return this.exec(v.api(endpoint, opts, this.target), opts.timeoutMs)
-  }
-
-  /**
-   * A GraphQL query; each page's `data`, or null on a failed or partial
-   * result. See the `graphql` verb.
-   *
-   * @experimental
-   */
-  graphql(
-    query: string,
-    variables: Record<string, v.GraphqlVariable> = {},
-    opts: v.GraphqlOptions & { timeoutMs?: number | undefined } = {},
-  ): unknown[] | null {
-    return this.exec(v.graphql(query, variables, opts, this.target), opts.timeoutMs)
-  }
-
-  /** Every label on the repository (up to `opts.limit`, default 1000), or null when gh failed. */
-  labelList(
-    opts: { limit?: number | undefined; timeoutMs?: number | undefined } = {},
-  ): ListResult<Label> | null {
-    return this.exec(v.labelList(opts, this.target), opts.timeoutMs)
-  }
-
-  /** Issues matching `opts` (open by default, up to 200), or null when gh failed. */
-  issueList(
-    opts: IssueListOptions & { timeoutMs?: number | undefined } = {},
-  ): ListResult<IssueRow> | null {
-    return this.exec(v.issueList(opts, this.target), opts.timeoutMs)
-  }
-
-  /** One issue with its labels, or null when gh failed. */
-  issueView(number: number, opts: { timeoutMs?: number | undefined } = {}): IssueRow | null {
-    return this.exec(v.issueView(number, this.target), opts.timeoutMs)
-  }
-
-  /** An owner's repositories (up to `opts.limit`, default 100), or null when gh failed. */
-  repoList(
-    owner: string,
-    opts: v.RepoListOptions & { timeoutMs?: number | undefined } = {},
-  ): ListResult<Repository> | null {
-    return this.exec(v.repoList(owner, opts, this.target), opts.timeoutMs)
-  }
-
-  /** One repository: `repo`, else the client's repo, else the clone at `cwd`. Null when gh failed. */
-  repoView(
-    repo?: string | undefined,
-    opts: { fields?: readonly string[] | undefined; timeoutMs?: number | undefined } = {},
-  ): Repository | null {
-    return this.exec(v.repoView(repo, opts.fields ?? v.REPO_FIELDS, this.target), opts.timeoutMs)
-  }
-
-  /** Pull requests across repositories matching a search query, or null when gh failed. */
-  searchPrs(
-    query: string,
-    opts: v.SearchPrsOptions & { timeoutMs?: number | undefined } = {},
-  ): ListResult<PrSearchHit> | null {
-    return this.exec(v.searchPrs(query, opts, this.target), opts.timeoutMs)
-  }
-
-  /** True iff the `gh` binary is on PATH and runs. */
-  installed(): boolean {
-    return this.exec(v.installed())
-  }
-
-  /**
-   * True iff `gh` holds credentials. Asked on its own only by a caller that
-   * reports the two halves separately — "gh is missing" and "gh is not logged
-   * in" are different things to tell a person, and a report that collapses
-   * them sends someone to install software they already have.
-   */
-  authenticated(): boolean {
-    return this.authStatus().ok
-  }
-
-  /** Login state and what `gh auth status` printed; `authenticated()` is its `ok`. */
-  authStatus(): AuthStatus {
-    return this.exec(v.authStatus(this.target))
-  }
-
-  /**
-   * True iff `gh` is installed AND authenticated — the two-step probe.
-   *
-   * Short-circuits: an absent binary cannot be asked about credentials.
-   */
-  ready(): boolean {
-    return this.installed() && this.authenticated()
-  }
-
-  /**
-   * `{owner, repo}` parsed from the remote URL you pass, or null when it is
-   * null or names no project.
-   *
-   * Pure: it reads no git config, starts no process and does not ask GitHub.
-   */
-  ownerRepo(remoteUrl: string | null): OwnerRepo | null {
-    return remoteUrl === null ? null : parseOwnerRepo(remoteUrl)
-  }
-
-  // ── mutations (checked) ───────────────────────────────────────────────────
-
-  /** Open a PR and return its URL ('' if gh printed none). */
-  createPr(opts: v.CreatePrOptions): string {
-    return this.exec(v.createPr(opts, this.target))
-  }
-
-  /** Retitle or rewrite a PR body. */
-  editPr(number: number, opts: { title?: string | undefined; body?: string | undefined }): void {
-    this.exec(v.editPr(number, opts, this.target))
-  }
-
-  /** The PR's unified diff; throws `CommandFailed` when gh cannot produce it. */
-  prDiff(number: number): string {
-    return this.exec(v.prDiff(number, this.target))
-  }
-
-  /** Post one conversation comment on a PR; returns its URL ('' if gh printed none). */
-  prComment(number: number, body: string): string {
-    return this.exec(v.prComment(number, body, this.target))
-  }
-
-  /**
-   * Create a `COMMENT` review with inline comments; returns the review's URL ('' if none came back).
-   *
-   * @experimental
-   */
-  createReview(number: number, opts: v.CreateReviewOptions): string {
-    return this.exec(v.createReview(number, opts, this.target))
-  }
-
-  /** Rewrite just a PR's body. */
-  editPrBody(number: number, body: string): void {
-    this.exec(v.editPrBody(number, body, this.target))
-  }
-
-  /** Bring a PR's head branch up to date with its base. */
-  prUpdateBranch(number: number, style: 'merge' | 'rebase' = 'merge'): void {
-    this.exec(v.prUpdateBranch(number, style, this.target))
-  }
-
-  /** Mark a PR ready for review (`draft: false`) or convert it to a draft (`draft: true`). */
-  prSetDraft(number: number, draft: boolean): void {
-    this.exec(v.prSetDraft(number, draft, this.target))
-  }
-
-  /**
-   * Rewrite one PR conversation comment's body. `commentId` is the numeric REST id; anything else throws `RangeError`.
-   *
-   * @experimental
-   */
-  issueCommentEdit(commentId: string, body: string): void {
-    this.exec(v.issueCommentEdit(commentId, body, this.target))
-  }
-
-  /** Merge a PR; GitHub refuses when its head is no longer `opts.headSha`. */
-  prMerge(number: number, opts: { method: v.PrMergeMethod; headSha: string }): void {
-    this.exec(v.prMerge(number, opts, this.target))
-  }
-
-  /** A PR's review threads, or null when they could not be read completely. */
-  prReviewThreads(number: number): v.ReviewThread[] | null {
-    return this.exec(v.prReviewThreads(number, this.target))
-  }
-
-  /** Create a label (or force it to `opts`'s color/description if it already exists). */
-  createLabel(opts: v.CreateLabelOptions): void {
-    this.exec(v.createLabel(opts, this.target))
-  }
-
-  /** Recolor and/or redescribe an existing label. */
-  editLabel(
-    name: string,
-    opts: { color?: string | undefined; description?: string | undefined },
-  ): void {
-    this.exec(v.editLabel(name, opts, this.target))
-  }
-
-  /**
-   * Swap an issue's label: remove `currentLabel` (when given) and add
-   * `newLabel`, in a single `gh issue edit` call — never a briefly-unlabeled
-   * or briefly-double-labeled intermediate state.
-   */
-  setIssueLabel(number: number, currentLabel: string | null, newLabel: string): void {
-    this.exec(v.setIssueLabel(number, currentLabel, newLabel, this.target))
-  }
-}
-
-/** The open PR for `branch`, else its newest closed or merged one. */
-function prForBranchOn(
-  gh: Gh,
-  branch: string,
-  call: { fields: readonly string[]; timeoutMs?: number | undefined },
-): PullRequest | null {
-  const rows = gh.prList({
-    head: branch,
-    state: 'all',
-    limit: 20,
-    fields: v.branchPrFields(call.fields),
-    timeoutMs: call.timeoutMs,
-  })
-  return v.branchPr(rows)
-}
-
-/**
- * Block the calling thread. Crude on purpose: the synchronous client has no
- * event loop to await on, and the alternative — making every caller async to
- * accommodate one retry delay — colors the whole call graph.
- */
-function sleepSync(ms: number): void {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms)
-}

package/types.ts

@@ -1,226 +0,0 @@
-/**
- * The GitHub model, typed.
- *
- * `gh` returns GraphQL-shaped JSON whose fields depend on what you asked for,
- * so every field here is total: a value, or the enum member that means "not
- * known". Absent and unknowable are the same answer to a caller, and giving
- * them one representation is what keeps a consumer from reading a field it
- * never requested as a fact.
- *
- * Most enums are open on purpose. GitHub adds members, and a client that
- * crashes on an unrecognized one is worse than a client that carries it
- * through: unions end in `(string & {})` so a new value still types as the
- * enum while the known members keep their autocomplete.
- *
- * Two are closed: {@link MergeableState} and {@link ReviewDecision}. Callers
- * compare them member by member to decide whether to merge, so the parser
- * maps a value it does not know to `UNKNOWN` or `null` instead of passing it
- * on.
- */
-
-/**
- * Can this PR merge? `UNKNOWN` also covers "GitHub has not computed it yet".
- * Closed: a value the parser does not know reads as `UNKNOWN`.
- */
-export type MergeableState = 'MERGEABLE' | 'CONFLICTING' | 'UNKNOWN'
-
-/**
- * The merge-button state.
- *
- * `BEHIND` only ever appears when branch protection *requires* an up-to-date
- * branch. Without that rule a branch a hundred commits behind still reports
- * `CLEAN`, so this is a corroborating hint about staleness and never the
- * measure of it — compute that from the commit graph.
- */
-export type MergeStateStatus =
-  | 'BEHIND'
-  | 'BLOCKED'
-  | 'CLEAN'
-  | 'DIRTY'
-  | 'DRAFT'
-  | 'HAS_HOOKS'
-  | 'UNKNOWN'
-  | 'UNSTABLE'
-  | (string & {})
-
-/** Where a pull request is in its life: open, closed without a merge, or merged. */
-export type PullRequestState = 'OPEN' | 'CLOSED' | 'MERGED' | (string & {})
-
-/**
- * The review state branch protection reads: approved, changes requested, or a
- * review still required. `null` when there is no decision, or the repository
- * requires no review. Closed: a value the parser does not know reads as `null`.
- */
-export type ReviewDecision = 'APPROVED' | 'CHANGES_REQUESTED' | 'REVIEW_REQUIRED' | null
-
-/** The state of one review. `PENDING` is a review its author has not submitted yet. */
-export type ReviewState =
-  'APPROVED' | 'CHANGES_REQUESTED' | 'COMMENTED' | 'DISMISSED' | 'PENDING' | (string & {})
-
-/** Who wrote something. `login` is normalized — a `[bot]` suffix is stripped. */
-export interface Actor {
-  login: string
-  /** True when GitHub marks the account as a bot, or the login carried `[bot]`. */
-  isBot: boolean
-}
-
-/** A repository label. `color` is hex digits such as `d73a4a`; a field the payload lacks is `''`. */
-export interface Label {
-  name: string
-  color: string
-  description: string
-}
-
-/**
- * A GitHub issue, off `gh issue list`/`gh issue view --json
- * number,title,body,labels,state`. Deliberately a small field set — not the
- * full PR-sized model, since nothing here reads reviews, checks or comments
- * off an issue.
- */
-export interface IssueRow {
-  number: number
-  title: string
-  body: string
-  labels: Label[]
-  state: string
-}
-
-/**
- * How a finished check ended, as GitHub reports it. Null while the check is
- * still running, and always null for a legacy status context. Read
- * {@link CheckRun.verdict} for the answer folded across both node types.
- */
-export type CheckConclusion =
-  | 'SUCCESS'
-  | 'FAILURE'
-  | 'NEUTRAL'
-  | 'CANCELLED'
-  | 'TIMED_OUT'
-  | 'ACTION_REQUIRED'
-  | 'SKIPPED'
-  | 'STALE'
-  | 'STARTUP_FAILURE'
-  | (string & {})
-  | null
-
-/** One rolled-up check, with the two GitHub shapes folded into one. */
-export interface CheckRun {
-  /** A CheckRun's `name`, or a legacy StatusContext's `context`. */
-  name: string
-  /** `QUEUED` / `IN_PROGRESS` / `COMPLETED`; null for a status context. */
-  status: string | null
-  conclusion: CheckConclusion
-  /**
-   * The normalized verdict. A check still running is `pending`, not a pass —
-   * treating "no failure yet" as green is how a red build merges.
-   */
-  verdict: 'pending' | 'success' | 'failure' | 'neutral'
-  /** A CheckRun's `detailsUrl`, or a legacy StatusContext's `targetUrl` — where to read the log. Null when the code host gives none. */
-  url: string | null
-}
-
-/** One conversation comment on a pull request. */
-export interface Comment {
-  /**
-   * GitHub's id for this comment, as a string: a GraphQL node id, or a REST id
-   * turned into text. Null only when the payload omits it (`gh` always sends
-   * one). A REST id of 2^53 or more loses precision when `gh` output is
-   * parsed. Current ids are far below that.
-   */
-  id: string | null
-  author: Actor | null
-  body: string
-  createdAt: string | null
-}
-
-/** One review on a pull request. */
-export interface Review {
-  /** Same as {@link Comment.id}. A REST id of 2^53 or more loses precision when `gh` output is parsed. */
-  id: string | null
-  author: Actor | null
-  body: string
-  state: ReviewState
-  submittedAt: string | null
-}
-
-/**
- * A pull request.
- *
- * Fields `gh` was not asked for come back at their "not known" value, so this
- * type is safe to build from any field subset. `number` is the only field
- * without one — a PR with no number is not a PR, and parsing returns null.
- */
-export interface PullRequest {
-  number: number
-  state: PullRequestState
-  title: string
-  body: string
-  url: string
-  isDraft: boolean
-  baseRefName: string
-  headRefName: string
-  /** Head commit sha, when requested — the thing to pin a force-push lease to. */
-  headRefOid: string | null
-  /**
-   * True when the head branch lives in a fork. Its ref is then not on the
-   * base repository's `origin`; fetch `refs/pull/<n>/head` instead.
-   */
-  isCrossRepository: boolean
-  mergeable: MergeableState
-  mergeStateStatus: MergeStateStatus
-  reviewDecision: ReviewDecision
-  author: Actor | null
-  labels: Label[]
-  checks: CheckRun[]
-  comments: Comment[]
-  reviews: Review[]
-  mergedAt: string | null
-  createdAt: string | null
-  updatedAt: string | null
-}
-
-/** A repository coordinate. */
-export interface OwnerRepo {
-  owner: string
-  repo: string
-}
-
-/** Who can see a repository. */
-export type RepositoryVisibility = 'PUBLIC' | 'PRIVATE' | 'INTERNAL' | (string & {})
-
-/**
- * A repository, off `gh repo list`/`gh repo view --json`. A field not asked
- * for comes back at its "not known" value. `nameWithOwner` is the only field
- * without one: a row without it is dropped.
- */
-export interface Repository {
-  /** `owner/name`. */
-  nameWithOwner: string
-  owner: string
-  name: string
-  description: string
-  /** The default branch; null when not asked for, or the repository is empty. */
-  defaultBranch: string | null
-  visibility: RepositoryVisibility | null
-  isArchived: boolean
-  url: string
-}
-
-/**
- * One pull request found by `gh search prs`. Search has its own field set:
- * it names the repository but carries no head or base branch, so this is not
- * a {@link PullRequest}. `state` is upper-cased to match `PullRequest`.
- */
-export interface PrSearchHit {
-  number: number
-  title: string
-  state: PullRequestState
-  url: string
-  isDraft: boolean
-  repository: OwnerRepo | null
-  author: Actor | null
-  labels: Label[]
-  createdAt: string | null
-  updatedAt: string | null
-  closedAt: string | null
-}