@kitlangton/ghui 0.1.19 → 0.1.21

package/src/appCommands.ts

@@ -0,0 +1,330 @@
+import type { AppCommand } from "./commands.js"
+import { defineCommand } from "./commands.js"
+import type { LoadStatus, PullRequestItem } from "./domain.js"
+import type { DiffView, DiffWrapMode } from "./ui/diff.js"
+import { type PullRequestView, viewEquals, viewLabel, viewMode } from "./pullRequestViews.js"
+
+interface AppCommandActions {
+	readonly openCommandPalette: () => void
+	readonly refreshPullRequests: (message?: string) => void
+	readonly openFilter: () => void
+	readonly clearFilter: () => void
+	readonly openThemeModal: () => void
+	readonly openRepositoryPicker: () => void
+	readonly loadMorePullRequests: () => void
+	readonly switchViewTo: (view: PullRequestView) => void
+	readonly openDetails: () => void
+	readonly closeDetails: () => void
+	readonly openDiffView: () => void
+	readonly closeDiffView: () => void
+	readonly reloadDiff: () => void
+	readonly toggleDiffRenderView: () => void
+	readonly toggleDiffWrapMode: () => void
+	readonly jumpDiffFile: (delta: 1 | -1) => void
+	readonly toggleDiffCommentMode: () => void
+	readonly openDiffCommentModal: () => void
+	readonly togglePullRequestDraftStatus: () => void
+	readonly openLabelModal: () => void
+	readonly openMergeModal: () => void
+	readonly openCloseModal: () => void
+	readonly openPullRequestInBrowser: () => void
+	readonly copyPullRequestMetadata: () => void
+	readonly quit: () => void
+}
+
+interface BuildAppCommandsInput {
+	readonly pullRequestStatus: LoadStatus
+	readonly filterQuery: string
+	readonly filterMode: boolean
+	readonly selectedRepository: string | null
+	readonly activeViews: readonly PullRequestView[]
+	readonly activeView: PullRequestView
+	readonly loadedPullRequestCount: number
+	readonly hasMorePullRequests: boolean
+	readonly isLoadingMorePullRequests: boolean
+	readonly selectedPullRequest: PullRequestItem | null
+	readonly detailFullView: boolean
+	readonly diffFullView: boolean
+	readonly diffReady: boolean
+	readonly effectiveDiffRenderView: DiffView
+	readonly diffWrapMode: DiffWrapMode
+	readonly readyDiffFileCount: number
+	readonly diffFileIndex: number
+	readonly diffCommentMode: boolean
+	readonly selectedDiffCommentAnchorLabel: string | null
+	readonly actions: AppCommandActions
+}
+
+export const buildAppCommands = ({
+	pullRequestStatus,
+	filterQuery,
+	filterMode,
+	selectedRepository,
+	activeViews,
+	activeView,
+	loadedPullRequestCount,
+	hasMorePullRequests,
+	isLoadingMorePullRequests,
+	selectedPullRequest,
+	detailFullView,
+	diffFullView,
+	diffReady,
+	effectiveDiffRenderView,
+	diffWrapMode,
+	readyDiffFileCount,
+	diffFileIndex,
+	diffCommentMode,
+	selectedDiffCommentAnchorLabel,
+	actions,
+}: BuildAppCommandsInput): readonly AppCommand[] => {
+	const selectedPullRequestLabel = selectedPullRequest ? `#${selectedPullRequest.number} ${selectedPullRequest.repository}` : "No pull request selected"
+	const noPullRequestReason = selectedPullRequest ? null : "Select a pull request first."
+	const noOpenPullRequestReason = selectedPullRequest?.state === "open" ? null : selectedPullRequest ? "Pull request is not open." : noPullRequestReason
+	const diffReadyReason = selectedPullRequest
+		? diffReady ? null : "Load the diff before running this command."
+		: noPullRequestReason
+	const diffOpenReadyReason = diffFullView ? diffReadyReason : "Open a diff first."
+	const loadMoreDisabledReason = isLoadingMorePullRequests
+		? "Already loading more pull requests."
+		: hasMorePullRequests ? null : "No more pull requests loaded by this view."
+
+	const forSelected = (
+		command: Omit<AppCommand, "subtitle" | "disabledReason"> & { readonly requireOpen?: boolean },
+	): AppCommand => {
+		const { requireOpen, ...rest } = command
+		return defineCommand({
+			...rest,
+			subtitle: selectedPullRequestLabel,
+			disabledReason: requireOpen ? noOpenPullRequestReason : noPullRequestReason,
+		})
+	}
+
+	return [
+		defineCommand({
+			id: "command.open",
+			title: "Open command palette",
+			scope: "Global",
+			subtitle: "Search every available route through ghui",
+			shortcut: "ctrl-p/cmd-k",
+			keywords: ["palette", "commands", "deck"],
+			run: actions.openCommandPalette,
+		}),
+		defineCommand({
+			id: "pull.refresh",
+			title: pullRequestStatus === "error" ? "Retry loading pull requests" : "Refresh pull requests",
+			scope: "Global",
+			subtitle: "Fetch the latest queue from GitHub",
+			shortcut: "r",
+			keywords: ["reload", "sync"],
+			run: () => actions.refreshPullRequests("Refreshed"),
+		}),
+		defineCommand({
+			id: "filter.open",
+			title: "Filter pull requests",
+			scope: "Global",
+			subtitle: "Search the visible queue",
+			shortcut: "/",
+			keywords: ["search"],
+			run: actions.openFilter,
+		}),
+		defineCommand({
+			id: "filter.clear",
+			title: "Clear pull request filter",
+			scope: "Global",
+			subtitle: "Show every pull request in the current queue",
+			shortcut: "esc",
+			disabledReason: filterQuery.length > 0 || filterMode ? null : "No filter is active.",
+			run: actions.clearFilter,
+		}),
+		defineCommand({
+			id: "theme.open",
+			title: "Choose theme",
+			scope: "Global",
+			subtitle: "Preview and persist a terminal color theme",
+			shortcut: "t",
+			keywords: ["colors", "appearance"],
+			run: actions.openThemeModal,
+		}),
+		defineCommand({
+			id: "repository.open",
+			title: "Open repository...",
+			scope: "View",
+			subtitle: selectedRepository ? `Current repository: ${selectedRepository}` : "Enter owner/name or a GitHub URL",
+			keywords: ["repo", "repository", "owner", "github"],
+			run: actions.openRepositoryPicker,
+		}),
+		...activeViews.map((view) => defineCommand({
+			id: view._tag === "Repository" ? "view.repository" : `view.${view.mode}`,
+			title: `Show ${viewLabel(view)} view`,
+			scope: "View" as const,
+			subtitle: viewEquals(view, activeView) ? "Already showing this view" : "Switch pull request view",
+			keywords: [viewMode(view), viewLabel(view), "queue", "view"],
+			disabledReason: viewEquals(view, activeView) ? "Already showing this view." : null,
+			run: () => actions.switchViewTo(view),
+		})),
+		defineCommand({
+			id: "pull.load-more",
+			title: "Load more pull requests",
+			scope: "Navigation",
+			subtitle: `${loadedPullRequestCount} loaded`,
+			disabledReason: loadMoreDisabledReason,
+			keywords: ["next page", "pagination", "more"],
+			run: actions.loadMorePullRequests,
+		}),
+		forSelected({
+			id: "detail.open",
+			title: "Open pull request details",
+			scope: "Pull request",
+			shortcut: "enter",
+			run: actions.openDetails,
+		}),
+		defineCommand({
+			id: "detail.close",
+			title: "Close details view",
+			scope: "Pull request",
+			subtitle: "Return to the queue",
+			shortcut: "esc",
+			disabledReason: detailFullView ? null : "Details view is not open.",
+			run: actions.closeDetails,
+		}),
+		forSelected({
+			id: "diff.open",
+			title: "Open stacked diff",
+			scope: "Diff",
+			shortcut: "d",
+			keywords: ["files", "patch"],
+			run: actions.openDiffView,
+		}),
+		defineCommand({
+			id: "diff.close",
+			title: "Close diff view",
+			scope: "Diff",
+			subtitle: "Return to the queue or detail view",
+			shortcut: "esc",
+			disabledReason: diffFullView ? null : "Diff view is not open.",
+			run: actions.closeDiffView,
+		}),
+		defineCommand({
+			id: "diff.reload",
+			title: "Reload diff",
+			scope: "Diff",
+			subtitle: selectedPullRequestLabel,
+			shortcut: "r",
+			disabledReason: diffFullView && selectedPullRequest ? null : "Open a pull request diff first.",
+			keywords: ["refresh", "comments"],
+			run: actions.reloadDiff,
+		}),
+		defineCommand({
+			id: "diff.toggle-view",
+			title: "Toggle diff split/unified view",
+			scope: "Diff",
+			subtitle: effectiveDiffRenderView === "split" ? "Switch to unified view" : "Switch to split view",
+			shortcut: "v",
+			disabledReason: diffFullView ? null : "Open a diff first.",
+			run: actions.toggleDiffRenderView,
+		}),
+		defineCommand({
+			id: "diff.toggle-wrap",
+			title: "Toggle diff word wrap",
+			scope: "Diff",
+			subtitle: diffWrapMode === "none" ? "Wrap long diff lines" : "Keep diff lines unwrapped",
+			shortcut: "w",
+			disabledReason: diffFullView ? null : "Open a diff first.",
+			run: actions.toggleDiffWrapMode,
+		}),
+		defineCommand({
+			id: "diff.next-file",
+			title: "Next diff file",
+			scope: "Diff",
+			subtitle: readyDiffFileCount > 0 ? `${diffFileIndex + 1}/${readyDiffFileCount}` : "No diff files loaded",
+			shortcut: "]",
+			disabledReason: diffFullView && readyDiffFileCount > 0 ? null : diffOpenReadyReason,
+			run: () => actions.jumpDiffFile(1),
+		}),
+		defineCommand({
+			id: "diff.previous-file",
+			title: "Previous diff file",
+			scope: "Diff",
+			subtitle: readyDiffFileCount > 0 ? `${diffFileIndex + 1}/${readyDiffFileCount}` : "No diff files loaded",
+			shortcut: "[",
+			disabledReason: diffFullView && readyDiffFileCount > 0 ? null : diffOpenReadyReason,
+			run: () => actions.jumpDiffFile(-1),
+		}),
+		defineCommand({
+			id: "diff.comment-mode",
+			title: diffCommentMode ? "Exit diff comment mode" : "Enter diff comment mode",
+			scope: "Diff",
+			subtitle: diffCommentMode ? "Return to diff scrolling" : "Choose a line to comment on",
+			shortcut: "c",
+			disabledReason: diffFullView && diffReady ? null : diffOpenReadyReason,
+			keywords: ["review", "comment", "line"],
+			run: actions.toggleDiffCommentMode,
+		}),
+		defineCommand({
+			id: "diff.add-comment",
+			title: "Add comment on selected diff line",
+			scope: "Diff",
+			subtitle: selectedDiffCommentAnchorLabel ?? "No diff line selected",
+			shortcut: "a",
+			disabledReason: diffCommentMode && selectedDiffCommentAnchorLabel ? null : "Enter diff comment mode and select a line first.",
+			keywords: ["review", "reply"],
+			run: actions.openDiffCommentModal,
+		}),
+		forSelected({
+			id: "pull.toggle-draft",
+			title: selectedPullRequest?.reviewStatus === "draft" ? "Mark ready for review" : "Mark as draft",
+			scope: "Pull request",
+			shortcut: "s",
+			keywords: ["state", "ready"],
+			run: actions.togglePullRequestDraftStatus,
+		}),
+		forSelected({
+			id: "pull.labels",
+			title: "Manage labels",
+			scope: "Pull request",
+			shortcut: "l",
+			run: actions.openLabelModal,
+		}),
+		forSelected({
+			id: "pull.merge",
+			title: "Merge pull request",
+			scope: "Pull request",
+			shortcut: "m",
+			keywords: ["auto merge", "squash"],
+			run: actions.openMergeModal,
+		}),
+		forSelected({
+			id: "pull.close",
+			title: "Close pull request",
+			scope: "Pull request",
+			shortcut: "x",
+			requireOpen: true,
+			run: actions.openCloseModal,
+		}),
+		forSelected({
+			id: "pull.open-browser",
+			title: "Open pull request in browser",
+			scope: "Pull request",
+			shortcut: "o",
+			keywords: ["github", "web"],
+			run: actions.openPullRequestInBrowser,
+		}),
+		forSelected({
+			id: "pull.copy-metadata",
+			title: "Copy pull request metadata",
+			scope: "Pull request",
+			shortcut: "y",
+			keywords: ["clipboard", "url", "title"],
+			run: actions.copyPullRequestMetadata,
+		}),
+		defineCommand({
+			id: "app.quit",
+			title: "Quit ghui",
+			scope: "System",
+			subtitle: "Leave the terminal UI",
+			shortcut: "q",
+			keywords: ["exit"],
+			run: actions.quit,
+		}),
+	]
+}

package/src/commands.ts

@@ -0,0 +1,73 @@
+export type CommandScope = "Global" | "View" | "Pull request" | "Diff" | "Navigation" | "System"
+
+const SCOPE_ORDER: readonly CommandScope[] = ["Global", "View", "Pull request", "Diff", "Navigation", "System"]
+
+export const sortCommandsByScope = (commands: readonly AppCommand[]) =>
+	[...commands].sort((left, right) => SCOPE_ORDER.indexOf(left.scope) - SCOPE_ORDER.indexOf(right.scope))
+
+export interface AppCommand {
+	readonly id: string
+	readonly title: string
+	readonly scope: CommandScope
+	readonly run: () => void
+	readonly subtitle?: string
+	readonly shortcut?: string
+	readonly keywords?: readonly string[]
+	readonly disabledReason?: string | null
+}
+
+export const defineCommand = (command: AppCommand): AppCommand => command
+
+export const commandEnabled = (command: AppCommand) => !command.disabledReason
+
+const normalize = (text: string) => text.toLowerCase().replace(/[^a-z0-9#]+/g, " ").trim()
+
+const acronym = (text: string) => normalize(text).split(" ").filter(Boolean).map((word) => word[0]).join("")
+
+const fuzzyIncludes = (text: string, query: string) => {
+	let index = 0
+	for (const char of text) {
+		if (char === query[index]) index++
+		if (index >= query.length) return true
+	}
+	return query.length === 0
+}
+
+const commandSearchText = (command: AppCommand) => normalize([
+	command.title,
+	command.subtitle,
+	command.scope,
+	command.shortcut,
+	...(command.keywords ?? []),
+].filter(Boolean).join(" "))
+
+const commandScore = (command: AppCommand, query: string) => {
+	const normalizedQuery = normalize(query)
+	if (normalizedQuery.length === 0) return 0
+
+	const title = normalize(command.title)
+	const searchText = commandSearchText(command)
+	const titleAcronym = acronym(command.title)
+	if (title.startsWith(normalizedQuery)) return 0
+	if (searchText.startsWith(normalizedQuery)) return 1
+	if (title.includes(normalizedQuery)) return 2
+	if (searchText.includes(normalizedQuery)) return 3
+	if (titleAcronym.startsWith(normalizedQuery)) return 4
+	if (fuzzyIncludes(searchText, normalizedQuery.replaceAll(" ", ""))) return 5
+	return null
+}
+
+export const filterCommands = (commands: readonly AppCommand[], query: string) => {
+	return commands.flatMap((command, index) => {
+		const score = commandScore(command, query)
+		return score === null ? [] : [{ command, index, score }]
+	}).sort((left, right) => {
+		const enabled = Number(commandEnabled(right.command)) - Number(commandEnabled(left.command))
+		return enabled || left.score - right.score || left.index - right.index
+	}).map(({ command }) => command)
+}
+
+export const clampCommandIndex = (index: number, commands: readonly AppCommand[]) => {
+	if (commands.length === 0) return 0
+	return Math.max(0, Math.min(commands.length - 1, index))
+}

package/src/config.ts

@@ -2,6 +2,8 @@ import { Config, Effect } from "effect"
 
 const positiveIntOr = (fallback: number) => (value: number) => Number.isFinite(value) && value > 0 ? value : fallback
 
+const pageSizeOr = (fallback: number) => (value: number) => Math.min(100, positiveIntOr(fallback)(value))
+
 const appConfig = Config.all({
 	author: Config.string("GHUI_AUTHOR").pipe(
 		Config.withDefault("@me"),
@@ -11,6 +13,14 @@ const appConfig = Config.all({
 		Config.withDefault(200),
 		Config.map(positiveIntOr(200)),
 	),
+	prPageSize: Config.int("GHUI_PR_PAGE_SIZE").pipe(
+		Config.withDefault(50),
+		Config.map(pageSizeOr(50)),
+	),
+	repository: Config.string("GHUI_REPO").pipe(
+		Config.withDefault(""),
+		Config.map((value) => value.trim() || null),
+	),
 })
 
 export const config = Effect.runSync(Effect.gen(function*() {

package/src/domain.ts

@@ -1,24 +1,24 @@
 import { Schema } from "effect"
 
-export const LoadStatus = Schema.Literals(["loading", "ready", "error"])
-export type LoadStatus = Schema.Schema.Type<typeof LoadStatus>
+export type LoadStatus = "loading" | "ready" | "error"
 
-export const PullRequestState = Schema.Literals(["open", "closed", "merged"])
-export type PullRequestState = Schema.Schema.Type<typeof PullRequestState>
+export type PullRequestState = "open" | "closed" | "merged"
 
-export const PullRequestQueueMode = Schema.Literals(["authored", "review", "assigned", "mentioned"])
-export type PullRequestQueueMode = Schema.Schema.Type<typeof PullRequestQueueMode>
-export const pullRequestQueueModes = PullRequestQueueMode.literals
+export const pullRequestQueueModes = ["authored", "review", "assigned", "mentioned"] as const
+export type PullRequestUserQueueMode = (typeof pullRequestQueueModes)[number]
+export type PullRequestQueueMode = "repository" | PullRequestUserQueueMode
 
 export const pullRequestQueueLabels = {
+	repository: "repository",
 	authored: "authored",
 	review: "review requested",
 	assigned: "assigned",
 	mentioned: "mentioned",
 } as const satisfies Record<PullRequestQueueMode, string>
 
-export const pullRequestQueueSearchQualifier = (mode: PullRequestQueueMode, author: string) => {
+export const pullRequestQueueSearchQualifier = (mode: PullRequestQueueMode, author: string, repository: string | null) => {
 	const qualifiers = {
+		repository: repository ? `repo:${repository}` : `author:${author}`,
 		authored: `author:${author}`,
 		review: "review-requested:@me",
 		assigned: "assignee:@me",
@@ -27,26 +27,22 @@ export const pullRequestQueueSearchQualifier = (mode: PullRequestQueueMode, auth
 	return qualifiers[mode]
 }
 
-export const CheckConclusion = Schema.Literals(["success", "failure", "neutral", "skipped", "cancelled", "timed_out"])
-export type CheckConclusion = Schema.Schema.Type<typeof CheckConclusion>
+export type CheckConclusion = "success" | "failure" | "neutral" | "skipped" | "cancelled" | "timed_out"
 
-export const CheckRunStatus = Schema.Literals(["completed", "in_progress", "queued", "pending"])
-export type CheckRunStatus = Schema.Schema.Type<typeof CheckRunStatus>
+export type CheckRunStatus = "completed" | "in_progress" | "queued" | "pending"
 
-export const CheckRollupStatus = Schema.Literals(["passing", "pending", "failing", "none"])
-export type CheckRollupStatus = Schema.Schema.Type<typeof CheckRollupStatus>
+export type CheckRollupStatus = "passing" | "pending" | "failing" | "none"
 
-export const ReviewStatus = Schema.Literals(["draft", "approved", "changes", "review", "none"])
-export type ReviewStatus = Schema.Schema.Type<typeof ReviewStatus>
+export type ReviewStatus = "draft" | "approved" | "changes" | "review" | "none"
 
-export const Mergeable = Schema.Literals(["mergeable", "conflicting", "unknown"])
-export type Mergeable = Schema.Schema.Type<typeof Mergeable>
+export type Mergeable = "mergeable" | "conflicting" | "unknown"
 
+// DiffCommentSide is the only literal type still consumed at runtime — GitHubService
+// uses it as a Schema inside PullRequestCommentSchema.
 export const DiffCommentSide = Schema.Literals(["LEFT", "RIGHT"])
 export type DiffCommentSide = Schema.Schema.Type<typeof DiffCommentSide>
 
-export const PullRequestMergeAction = Schema.Literals(["squash", "auto", "admin", "disable-auto"])
-export type PullRequestMergeAction = Schema.Schema.Type<typeof PullRequestMergeAction>
+export type PullRequestMergeAction = "squash" | "auto" | "admin" | "disable-auto"
 
 export interface CheckItem {
 	readonly name: string
@@ -103,6 +99,19 @@ export interface PullRequestItem {
 	readonly url: string
 }
 
+export interface PullRequestPage {
+	readonly items: readonly PullRequestItem[]
+	readonly endCursor: string | null
+	readonly hasNextPage: boolean
+}
+
+export interface ListPullRequestPageInput {
+	readonly mode: PullRequestQueueMode
+	readonly repository: string | null
+	readonly cursor: string | null
+	readonly pageSize: number
+}
+
 export interface PullRequestMergeInfo {
 	readonly repository: string
 	readonly number: number

package/src/errors.ts

@@ -0,0 +1,10 @@
+const hasStringField = <K extends string>(value: object, key: K): value is { [P in K]: string } & object =>
+	key in value && typeof (value as Record<string, unknown>)[key] === "string"
+
+export const errorMessage = (error: unknown): string => {
+	if (typeof error === "object" && error !== null) {
+		if (hasStringField(error, "detail") && error.detail.length > 0) return error.detail
+		if (hasStringField(error, "message") && error.message.length > 0) return error.message
+	}
+	return error instanceof Error ? error.message : String(error)
+}

package/src/index.tsx

@@ -1,15 +1,38 @@
 #!/usr/bin/env bun
 
-import { createCliRenderer } from "@opentui/core"
+import { addDefaultParsers, createCliRenderer, createTerminalPalette } from "@opentui/core"
 import { RegistryProvider } from "@effect/atom-react"
 import { createRoot } from "@opentui/react"
-import { App } from "./App.js"
+import { createDefaultOpenTuiKeymap } from "@opentui/keymap/opentui"
+import { KeymapProvider } from "@opentui/keymap/react"
 
 process.env.OTUI_USE_ALTERNATE_SCREEN = "true"
 
+addDefaultParsers([
+	{
+		filetype: "bash",
+		aliases: ["sh", "shell", "zsh", "ksh"],
+		wasm: "https://github.com/tree-sitter/tree-sitter-bash/releases/download/v0.25.1/tree-sitter-bash.wasm",
+		queries: {
+			highlights: ["https://raw.githubusercontent.com/tree-sitter/tree-sitter-bash/v0.25.1/queries/highlights.scm"],
+		},
+	},
+])
+
 const FOCUS_REPORTING_ENABLE = "\x1b[?1004h"
 const FOCUS_REPORTING_DISABLE = "\x1b[?1004l"
 
+const paletteDetector = createTerminalPalette(process.stdin, process.stdout)
+const [terminalColors, { setSystemThemeColors }, { App }] = await Promise.all([
+	paletteDetector.detect({ timeout: 150 }).catch(() => null).finally(() => paletteDetector.cleanup()),
+	import("./ui/colors.js"),
+	import("./App.js"),
+])
+
+if (terminalColors) {
+	setSystemThemeColors(terminalColors)
+}
+
 const renderer = await createCliRenderer({
 	exitOnCtrlC: false,
 	screenMode: "alternate-screen",
@@ -22,8 +45,12 @@ const renderer = await createCliRenderer({
 
 process.stdout.write(FOCUS_REPORTING_ENABLE)
 
+const keymap = createDefaultOpenTuiKeymap(renderer)
+
 createRoot(renderer).render(
 	<RegistryProvider>
-		<App />
+		<KeymapProvider keymap={keymap}>
+			<App />
+		</KeymapProvider>
 	</RegistryProvider>,
 )

package/src/mergeActions.ts

@@ -61,12 +61,7 @@ const mergeActionDefinitions = {
 	},
 } as const satisfies Record<PullRequestMergeAction, MergeActionDefinition>
 
-export const mergeActions = [
-	mergeActionDefinitions.squash,
-	mergeActionDefinitions.auto,
-	mergeActionDefinitions["disable-auto"],
-	mergeActionDefinitions.admin,
-] as const satisfies readonly MergeActionDefinition[]
+export const mergeActions: readonly MergeActionDefinition[] = Object.values(mergeActionDefinitions)
 
 export const availableMergeActions = (info: PullRequestMergeInfo | null): readonly MergeActionDefinition[] => {
 	if (!info) return []

package/src/pullRequestCache.ts

@@ -0,0 +1,19 @@
+import type { PullRequestItem } from "./domain.js"
+
+export const mergeCachedDetails = (fresh: readonly PullRequestItem[], cached: readonly PullRequestItem[] | undefined) => {
+	if (!cached) return fresh
+	const cachedByUrl = new Map(cached.map((pullRequest) => [pullRequest.url, pullRequest]))
+	return fresh.map((pullRequest) => {
+		const cachedPullRequest = cachedByUrl.get(pullRequest.url)
+		if (!cachedPullRequest?.detailLoaded || cachedPullRequest.headRefOid !== pullRequest.headRefOid) return pullRequest
+		return {
+			...pullRequest,
+			body: cachedPullRequest.body,
+			labels: cachedPullRequest.labels,
+			additions: cachedPullRequest.additions,
+			deletions: cachedPullRequest.deletions,
+			changedFiles: cachedPullRequest.changedFiles,
+			detailLoaded: true,
+		} satisfies PullRequestItem
+	})
+}

package/src/pullRequestViews.ts

@@ -0,0 +1,45 @@
+import { pullRequestQueueLabels, pullRequestQueueModes, type PullRequestQueueMode, type PullRequestUserQueueMode } from "./domain.js"
+
+export type PullRequestView =
+	| { readonly _tag: "Repository"; readonly repository: string }
+	| { readonly _tag: "Queue"; readonly mode: PullRequestUserQueueMode; readonly repository: string | null }
+
+export const initialPullRequestView = (repository: string | null): PullRequestView => repository
+	? { _tag: "Repository", repository }
+	: { _tag: "Queue", mode: "authored", repository: null }
+
+export const viewMode = (view: PullRequestView): PullRequestQueueMode => view._tag === "Repository" ? "repository" : view.mode
+
+export const viewRepository = (view: PullRequestView) => view.repository
+
+export const viewCacheKey = (view: PullRequestView) => view._tag === "Repository" ? `repository:${view.repository}` : view.mode
+
+export const viewEquals = (left: PullRequestView, right: PullRequestView) =>
+	left._tag === right._tag && viewMode(left) === viewMode(right) && left.repository === right.repository
+
+export const activePullRequestViews = (view: PullRequestView): readonly PullRequestView[] => {
+	const repository = viewRepository(view)
+	return [
+		...(repository ? [{ _tag: "Repository" as const, repository }] : []),
+		...pullRequestQueueModes.map((mode) => ({ _tag: "Queue" as const, mode, repository })),
+	]
+}
+
+export const nextView = (view: PullRequestView, views: readonly PullRequestView[], delta: 1 | -1) => {
+	const index = Math.max(0, views.findIndex((candidate) => viewEquals(candidate, view)))
+	return views[(index + delta + views.length) % views.length]!
+}
+
+export const viewLabel = (view: PullRequestView) => view._tag === "Repository" ? view.repository : pullRequestQueueLabels[view.mode]
+
+export const parseRepositoryInput = (input: string) => {
+	const trimmed = input.trim()
+	const urlMatch = trimmed.match(/^(?:https?:\/\/)?(?:www\.)?github\.com\/([^/\s]+)\/([^/\s?#]+)(?:[/?#].*)?$/i)
+	const shorthandMatch = trimmed.match(/^([^/\s]+)\/([^/\s]+)$/)
+	const match = urlMatch ?? shorthandMatch
+	if (!match) return null
+	const owner = match[1]!
+	const repo = match[2]!.replace(/\.git$/i, "")
+	if (!/^[A-Za-z0-9_.-]+$/.test(owner) || !/^[A-Za-z0-9_.-]+$/.test(repo)) return null
+	return `${owner}/${repo}`
+}