@kitlangton/ghui 0.1.22 → 0.2.1

package/src/appCommands.ts

@@ -1,12 +1,12 @@
 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 { DiffView, DiffWhitespaceMode, 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 refreshPullRequests: (message?: string, options?: { readonly resetTransientState?: boolean }) => void
 	readonly openFilter: () => void
 	readonly clearFilter: () => void
 	readonly openThemeModal: () => void
@@ -20,6 +20,7 @@ interface AppCommandActions {
 	readonly reloadDiff: () => void
 	readonly toggleDiffRenderView: () => void
 	readonly toggleDiffWrapMode: () => void
+	readonly toggleDiffWhitespaceMode: () => void
 	readonly jumpDiffFile: (delta: 1 | -1) => void
 	readonly openSelectedDiffComment: () => void
 	readonly toggleDiffCommentRange: () => void
@@ -50,6 +51,7 @@ interface BuildAppCommandsInput {
 	readonly diffReady: boolean
 	readonly effectiveDiffRenderView: DiffView
 	readonly diffWrapMode: DiffWrapMode
+	readonly diffWhitespaceMode: DiffWhitespaceMode
 	readonly readyDiffFileCount: number
 	readonly diffFileIndex: number
 	readonly diffRangeActive: boolean
@@ -75,6 +77,7 @@ export const buildAppCommands = ({
 	diffReady,
 	effectiveDiffRenderView,
 	diffWrapMode,
+	diffWhitespaceMode,
 	readyDiffFileCount,
 	diffFileIndex,
 	diffRangeActive,
@@ -128,7 +131,7 @@ export const buildAppCommands = ({
 			subtitle: "Fetch the latest queue from GitHub",
 			shortcut: "r",
 			keywords: ["reload", "sync"],
-			run: () => actions.refreshPullRequests("Refreshed"),
+			run: () => actions.refreshPullRequests("Refreshed", { resetTransientState: true }),
 		}),
 		defineCommand({
 			id: "filter.open",
@@ -201,7 +204,7 @@ export const buildAppCommands = ({
 		}),
 		forSelected({
 			id: "diff.open",
-			title: "Open stacked diff",
+			title: "Open diff",
 			scope: "Diff",
 			shortcut: "d",
 			keywords: ["files", "patch"],
@@ -244,6 +247,15 @@ export const buildAppCommands = ({
 			disabledReason: diffFullView ? null : "Open a diff first.",
 			run: actions.toggleDiffWrapMode,
 		}),
+		defineCommand({
+			id: "diff.toggle-whitespace",
+			title: diffWhitespaceMode === "ignore" ? "Show whitespace changes" : "Ignore whitespace changes",
+			scope: "Diff",
+			subtitle: diffWhitespaceMode === "ignore" ? "Display the original GitHub patch" : "Hide whitespace-only line changes",
+			disabledReason: diffFullView ? null : "Open a diff first.",
+			keywords: ["whitespace", "spacing", "ignore", "show"],
+			run: actions.toggleDiffWhitespaceMode,
+		}),
 		defineCommand({
 			id: "diff.next-file",
 			title: "Next diff file",

package/src/domain.ts

@@ -78,6 +78,17 @@ export interface PullRequestReviewComment {
 	readonly url: string | null
 }
 
+export type PullRequestConversationItem =
+	| {
+		readonly _tag: "comment"
+		readonly id: string
+		readonly author: string
+		readonly body: string
+		readonly createdAt: Date | null
+		readonly url: string | null
+	}
+	| ({ readonly _tag: "review-comment" } & PullRequestReviewComment)
+
 export interface PullRequestItem {
 	readonly repository: string
 	readonly author: string

package/src/index.tsx

@@ -3,8 +3,6 @@
 import { addDefaultParsers, createCliRenderer, createTerminalPalette } from "@opentui/core"
 import { RegistryProvider } from "@effect/atom-react"
 import { createRoot } from "@opentui/react"
-import { KeymapProvider } from "@opentui/keymap/react"
-import { createKeymap } from "./keyboard/createKeymap.js"
 
 process.env.OTUI_USE_ALTERNATE_SCREEN = "true"
 
@@ -45,12 +43,8 @@ const renderer = await createCliRenderer({
 
 process.stdout.write(FOCUS_REPORTING_ENABLE)
 
-const keymap = createKeymap(renderer)
-
 createRoot(renderer).render(
 	<RegistryProvider>
-		<KeymapProvider keymap={keymap}>
-			<App />
-		</KeymapProvider>
+		<App />
 	</RegistryProvider>,
 )

package/src/keyboard/opentuiAdapter.ts

@@ -0,0 +1,43 @@
+import type { KeyEvent } from "@opentui/core"
+import { useKeyboard } from "@opentui/react"
+import type { ParsedStroke } from "@ghui/keymap"
+import type { KeySubscribe } from "@ghui/keymap/react"
+import { useMemo, useRef } from "react"
+
+/**
+ * Map an opentui KeyEvent into @ghui/keymap's ParsedStroke.
+ * `option` (alt key on Linux/Windows) is folded into `meta` to keep one
+ * cross-platform modifier surface.
+ */
+export const normalizeOpenTuiKey = (event: KeyEvent): ParsedStroke => ({
+	key: event.name.toLowerCase(),
+	ctrl: event.ctrl,
+	shift: event.shift,
+	meta: event.meta || event.option,
+})
+
+/**
+ * React hook that returns a stable `KeySubscribe` driven by opentui's keyboard.
+ *
+ * Multiple subscribers (e.g. the `@ghui/keymap` dispatcher and any text-input
+ * fallback) can each register their own handler. Internally we attach a single
+ * `useKeyboard` and fan out to every registered handler, so we don't accidentally
+ * stack two `useKeyboard` listeners on the same component.
+ */
+export const useOpenTuiSubscribe = (): KeySubscribe => {
+	const handlersRef = useRef<Set<(stroke: ParsedStroke) => void>>(new Set())
+
+	useKeyboard((event) => {
+		const keyEvent = event as KeyEvent
+		if (keyEvent.defaultPrevented) return
+		const stroke = normalizeOpenTuiKey(keyEvent)
+		for (const handler of handlersRef.current) handler(stroke)
+	})
+
+	return useMemo<KeySubscribe>(() => (handler) => {
+		handlersRef.current.add(handler)
+		return () => {
+			handlersRef.current.delete(handler)
+		}
+	}, [])
+}

package/src/keymap/all.ts

@@ -0,0 +1,103 @@
+import { context } from "@ghui/keymap"
+import { closeModalKeymap, type CloseModalCtx } from "./closeModal.ts"
+import { commandPaletteKeymap, type CommandPaletteCtx } from "./commandPalette.ts"
+import { commentModalKeymap, type CommentModalCtx } from "./commentModal.ts"
+import { commentThreadModalKeymap, type CommentThreadModalCtx } from "./commentThreadModal.ts"
+import { detailViewKeymap, type DetailViewCtx } from "./detailView.ts"
+import { diffViewKeymap, type DiffViewCtx } from "./diffView.ts"
+import { filterModeKeymap, type FilterModeCtx } from "./filterMode.ts"
+import { labelModalKeymap, type LabelModalCtx } from "./labelModal.ts"
+import { listNavKeymap, type ListNavCtx } from "./listNav.ts"
+import { mergeModalKeymap, type MergeModalCtx } from "./mergeModal.ts"
+import { openRepositoryModalKeymap, type OpenRepositoryModalCtx } from "./openRepositoryModal.ts"
+import { themeModalKeymap, type ThemeModalCtx } from "./themeModal.ts"
+
+export interface AppCtx {
+	// Active flags
+	readonly closeModalActive: boolean
+	readonly mergeModalActive: boolean
+	readonly commentThreadModalActive: boolean
+	readonly labelModalActive: boolean
+	readonly themeModalActive: boolean
+	readonly openRepositoryModalActive: boolean
+	readonly commentModalActive: boolean
+	readonly commandPaletteActive: boolean
+	readonly filterMode: boolean
+	readonly diffFullView: boolean
+	readonly detailFullView: boolean
+
+	// True whenever a modal/mode swallows raw text input (so q-quit, etc. are
+	// disabled inside text-editing contexts).
+	readonly textInputActive: boolean
+
+	// Per-layer narrow contexts
+	readonly closeModal: CloseModalCtx
+	readonly mergeModal: MergeModalCtx
+	readonly commentThreadModal: CommentThreadModalCtx
+	readonly labelModal: LabelModalCtx
+	readonly themeModal: ThemeModalCtx
+	readonly openRepositoryModal: OpenRepositoryModalCtx
+	readonly commentModal: CommentModalCtx
+	readonly commandPalette: CommandPaletteCtx
+	readonly filterModeCtx: FilterModeCtx
+	readonly diff: DiffViewCtx
+	readonly detail: DetailViewCtx
+	readonly listNav: ListNavCtx
+
+	// Always-on / app-level
+	readonly openCommandPalette: () => void
+	readonly handleQuitOrClose: () => void
+}
+
+const App = context<AppCtx>()
+
+const inListMode = (a: AppCtx): boolean =>
+	!a.closeModalActive
+	&& !a.mergeModalActive
+	&& !a.commentThreadModalActive
+	&& !a.labelModalActive
+	&& !a.themeModalActive
+	&& !a.openRepositoryModalActive
+	&& !a.commentModalActive
+	&& !a.commandPaletteActive
+	&& !a.filterMode
+	&& !a.diffFullView
+	&& !a.detailFullView
+
+export const appKeymap = App(
+	// Always-on: command palette opener
+	{ id: "command.open", title: "Open command palette", keys: ["ctrl+p", "meta+k"], run: (s) => s.openCommandPalette() },
+
+	// Quit / close-active-modal — gated to "not editing text"
+	{
+		id: "app.quit-or-close",
+		title: "Quit / close modal",
+		keys: ["ctrl+c"],
+		run: (s) => s.handleQuitOrClose(),
+	},
+	{
+		id: "app.quit-or-close-q",
+		title: "Quit / close modal",
+		keys: ["q"],
+		when: (s) => !s.textInputActive,
+		run: (s) => s.handleQuitOrClose(),
+	},
+
+	// Modal layers
+	closeModalKeymap.scope((a) => a.closeModalActive && a.closeModal),
+	mergeModalKeymap.scope((a) => a.mergeModalActive && a.mergeModal),
+	commentThreadModalKeymap.scope((a) => a.commentThreadModalActive && a.commentThreadModal),
+	labelModalKeymap.scope((a) => a.labelModalActive && a.labelModal),
+	themeModalKeymap.scope((a) => a.themeModalActive && a.themeModal),
+	openRepositoryModalKeymap.scope((a) => a.openRepositoryModalActive && a.openRepositoryModal),
+	commentModalKeymap.scope((a) => a.commentModalActive && a.commentModal),
+	commandPaletteKeymap.scope((a) => a.commandPaletteActive && a.commandPalette),
+	filterModeKeymap.scope((a) => a.filterMode && a.filterModeCtx),
+
+	// Full-view layers (only when no modal is on top)
+	diffViewKeymap.scope((a) => a.diffFullView && !a.commandPaletteActive && a.diff),
+	detailViewKeymap.scope((a) => a.detailFullView && !a.commandPaletteActive && a.detail),
+
+	// PR list nav
+	listNavKeymap.scope((a) => inListMode(a) && a.listNav),
+)

package/src/keymap/closeModal.ts

@@ -0,0 +1,13 @@
+import { context } from "@ghui/keymap"
+
+export interface CloseModalCtx {
+	readonly closeModal: () => void
+	readonly confirmClose: () => void
+}
+
+const Close = context<CloseModalCtx>()
+
+export const closeModalKeymap = Close(
+	{ id: "close-modal.cancel", title: "Cancel", keys: ["escape"], run: (s) => s.closeModal() },
+	{ id: "close-modal.confirm", title: "Close pull request", keys: ["return"], run: (s) => s.confirmClose() },
+)

package/src/keymap/commandPalette.ts

@@ -0,0 +1,16 @@
+import { context } from "@ghui/keymap"
+
+export interface CommandPaletteCtx {
+	readonly closeModal: () => void
+	readonly runSelected: () => void
+	readonly moveSelection: (delta: -1 | 1) => void
+}
+
+const Palette = context<CommandPaletteCtx>()
+
+export const commandPaletteKeymap = Palette(
+	{ id: "palette.close", title: "Close palette", keys: ["escape", "ctrl+c"], run: (s) => s.closeModal() },
+	{ id: "palette.run", title: "Run command", keys: ["return"], run: (s) => s.runSelected() },
+	{ id: "palette.up", title: "Up", keys: ["up"], run: (s) => s.moveSelection(-1) },
+	{ id: "palette.down", title: "Down", keys: ["down"], run: (s) => s.moveSelection(1) },
+)

package/src/keymap/commentModal.ts

@@ -0,0 +1,73 @@
+import { context } from "@ghui/keymap"
+
+/**
+ * Single-method-per-binding interface. Each `move*` / `delete*` is a discrete
+ * editor command; the App constructs the context so each method applies the
+ * appropriate `editorState → editorState` transform via the existing
+ * `editComment` helper.
+ */
+export interface CommentModalCtx {
+	readonly closeModal: () => void
+	readonly submit: () => void
+	readonly insertNewline: () => void
+	readonly moveLeft: () => void
+	readonly moveRight: () => void
+	readonly moveUp: () => void
+	readonly moveDown: () => void
+	readonly moveLineStart: () => void
+	readonly moveLineEnd: () => void
+	readonly moveWordBackward: () => void
+	readonly moveWordForward: () => void
+	readonly backspace: () => void
+	readonly deleteForward: () => void
+	readonly deleteWordBackward: () => void
+	readonly deleteWordForward: () => void
+	readonly deleteToLineStart: () => void
+	readonly deleteToLineEnd: () => void
+}
+
+const Comment = context<CommentModalCtx>()
+
+export const commentModalKeymap = Comment(
+	{ id: "comment.escape", title: "Cancel", keys: ["escape"], run: (s) => s.closeModal() },
+	{ id: "comment.submit", title: "Submit", keys: ["ctrl+s", "return"], run: (s) => s.submit() },
+	{ id: "comment.newline", title: "Insert newline", keys: ["shift+return"], run: (s) => s.insertNewline() },
+
+	// Cursor movement
+	{ id: "comment.move-left", title: "Cursor left", keys: ["left", "ctrl+b"], run: (s) => s.moveLeft() },
+	{ id: "comment.move-right", title: "Cursor right", keys: ["right", "ctrl+f"], run: (s) => s.moveRight() },
+	{ id: "comment.move-up", title: "Cursor up", keys: ["up"], run: (s) => s.moveUp() },
+	{ id: "comment.move-down", title: "Cursor down", keys: ["down"], run: (s) => s.moveDown() },
+	{ id: "comment.line-start", title: "Line start", keys: ["home", "ctrl+a"], run: (s) => s.moveLineStart() },
+	{ id: "comment.line-end", title: "Line end", keys: ["end", "ctrl+e"], run: (s) => s.moveLineEnd() },
+	{
+		id: "comment.word-back",
+		title: "Word backward",
+		keys: ["meta+b", "meta+left"],
+		run: (s) => s.moveWordBackward(),
+	},
+	{
+		id: "comment.word-forward",
+		title: "Word forward",
+		keys: ["meta+f", "meta+right"],
+		run: (s) => s.moveWordForward(),
+	},
+
+	// Deletion
+	{ id: "comment.backspace", title: "Backspace", keys: ["backspace"], run: (s) => s.backspace() },
+	{ id: "comment.delete", title: "Delete", keys: ["delete", "ctrl+d"], run: (s) => s.deleteForward() },
+	{
+		id: "comment.delete-word-back",
+		title: "Delete word backward",
+		keys: ["ctrl+w", "meta+backspace"],
+		run: (s) => s.deleteWordBackward(),
+	},
+	{
+		id: "comment.delete-word-forward",
+		title: "Delete word forward",
+		keys: ["meta+delete"],
+		run: (s) => s.deleteWordForward(),
+	},
+	{ id: "comment.delete-to-line-start", title: "Delete to line start", keys: ["ctrl+u"], run: (s) => s.deleteToLineStart() },
+	{ id: "comment.delete-to-line-end", title: "Delete to line end", keys: ["ctrl+k"], run: (s) => s.deleteToLineEnd() },
+)

package/src/keymap/commentThreadModal.ts

@@ -0,0 +1,24 @@
+import { context } from "@ghui/keymap"
+
+export interface CommentThreadModalCtx {
+	readonly halfPage: number
+	readonly closeModal: () => void
+	readonly openInlineComment: () => void
+	readonly scrollBy: (delta: number) => void
+}
+
+const Thread = context<CommentThreadModalCtx>()
+
+export const commentThreadModalKeymap = Thread(
+	{ id: "comment-thread.close", title: "Close", keys: ["escape"], run: (s) => s.closeModal() },
+	{ id: "comment-thread.reply", title: "Reply", keys: ["return", "a", "c"], run: (s) => s.openInlineComment() },
+	{ id: "comment-thread.up", title: "Up", keys: ["k", "up"], run: (s) => s.scrollBy(-1) },
+	{ id: "comment-thread.down", title: "Down", keys: ["j", "down"], run: (s) => s.scrollBy(1) },
+	{ id: "comment-thread.half-up", title: "Half page up", keys: ["pageup", "ctrl+u"], run: (s) => s.scrollBy(-s.halfPage) },
+	{
+		id: "comment-thread.half-down",
+		title: "Half page down",
+		keys: ["pagedown", "ctrl+d", "ctrl+v"],
+		run: (s) => s.scrollBy(s.halfPage),
+	},
+)

package/src/keymap/detailView.ts

@@ -0,0 +1,30 @@
+import { context, type Scrollable, scrollCommands } from "@ghui/keymap"
+
+export interface DetailViewCtx extends Scrollable {
+	readonly closeDetail: () => void
+	readonly openTheme: () => void
+	readonly openDiff: () => void
+	readonly closePullRequest: () => void
+	readonly openLabels: () => void
+	readonly openMerge: () => void
+	readonly toggleDraft: () => void
+	readonly refresh: () => void
+	readonly openInBrowser: () => void
+	readonly copyMetadata: () => void
+}
+
+const Detail = context<DetailViewCtx>()
+
+export const detailViewKeymap = Detail(
+	scrollCommands<DetailViewCtx>(),
+	{ id: "detail.close", title: "Close detail", keys: ["escape", "return"], run: (s) => s.closeDetail() },
+	{ id: "detail.theme", title: "Open theme", keys: ["t"], run: (s) => s.openTheme() },
+	{ id: "detail.diff", title: "Open diff", keys: ["d"], run: (s) => s.openDiff() },
+	{ id: "detail.close-pr", title: "Close pull request", keys: ["x"], run: (s) => s.closePullRequest() },
+	{ id: "detail.labels", title: "Manage labels", keys: ["l"], run: (s) => s.openLabels() },
+	{ id: "detail.merge", title: "Merge", keys: ["m", "shift+m"], run: (s) => s.openMerge() },
+	{ id: "detail.toggle-draft", title: "Toggle draft", keys: ["s", "shift+s"], run: (s) => s.toggleDraft() },
+	{ id: "detail.refresh", title: "Refresh", keys: ["r"], run: (s) => s.refresh() },
+	{ id: "detail.open-browser", title: "Open in browser", keys: ["o"], run: (s) => s.openInBrowser() },
+	{ id: "detail.copy", title: "Copy metadata", keys: ["y"], run: (s) => s.copyMetadata() },
+)

package/src/keymap/diffView.ts

@@ -0,0 +1,91 @@
+import { context } from "@ghui/keymap"
+import { countedVerticalBindings } from "./helpers.ts"
+
+export type DiffSide = "LEFT" | "RIGHT"
+export type DiffAlign = "center" | "top" | "bottom"
+
+export interface DiffViewCtx {
+	readonly halfPage: number
+	readonly handleEscape: () => void          // closes diff, or clears comment range if active
+	readonly openSelectedComment: () => void
+	readonly addComment: () => void
+	readonly toggleRange: () => void
+	readonly toggleView: () => void
+	readonly toggleWrap: () => void
+	readonly reload: () => void
+	readonly nextThread: () => void
+	readonly previousThread: () => void
+	readonly moveAnchor: (delta: number, opts?: { preserveViewportRow?: boolean }) => void
+	readonly moveAnchorToBoundary: (boundary: "first" | "last") => void
+	readonly alignAnchor: (align: DiffAlign) => void
+	readonly selectSide: (side: DiffSide) => void
+	readonly nextFile: () => void
+	readonly previousFile: () => void
+	readonly openInBrowser: () => void
+}
+
+const Diff = context<DiffViewCtx>()
+
+export const diffViewKeymap = Diff(
+	{ id: "diff.escape", title: "Close diff / clear range", keys: ["escape"], run: (s) => s.handleEscape() },
+	{ id: "diff.open-comment", title: "Open / add comment", keys: ["return"], run: (s) => s.openSelectedComment() },
+	{ id: "diff.add-comment", title: "Add comment on line", keys: ["a"], run: (s) => s.addComment() },
+	{ id: "diff.toggle-range", title: "Toggle comment range", keys: ["v"], run: (s) => s.toggleRange() },
+	{ id: "diff.toggle-view", title: "Toggle split/unified", keys: ["shift+v"], run: (s) => s.toggleView() },
+	{ id: "diff.toggle-wrap", title: "Toggle wrap", keys: ["w"], run: (s) => s.toggleWrap() },
+	{ id: "diff.reload", title: "Reload diff", keys: ["r"], run: (s) => s.reload() },
+	{ id: "diff.next-thread", title: "Next thread", keys: ["n"], run: (s) => s.nextThread() },
+	{ id: "diff.previous-thread", title: "Previous thread", keys: ["p"], run: (s) => s.previousThread() },
+
+	// Half-page anchor moves preserve viewport row (true vim semantics)
+	{
+		id: "diff.half-up",
+		title: "Half page up",
+		keys: ["pageup", "ctrl+u"],
+		run: (s) => s.moveAnchor(-s.halfPage, { preserveViewportRow: true }),
+	},
+	{
+		id: "diff.half-down",
+		title: "Half page down",
+		keys: ["pagedown", "ctrl+d", "ctrl+v"],
+		run: (s) => s.moveAnchor(s.halfPage, { preserveViewportRow: true }),
+	},
+
+	// Jump-by-8 (shift+arrow / meta+arrow / shift+letter / meta+letter)
+	{
+		id: "diff.jump-up",
+		title: "Jump up",
+		keys: ["shift+up", "shift+k", "meta+up", "meta+k"],
+		run: (s) => s.moveAnchor(-8),
+	},
+	{
+		id: "diff.jump-down",
+		title: "Jump down",
+		keys: ["shift+down", "shift+j", "meta+down", "meta+j"],
+		run: (s) => s.moveAnchor(8),
+	},
+
+	// Vim count prefixes ("2 k", "15 j", etc.)
+	...countedVerticalBindings<DiffViewCtx>((s, delta) => s.moveAnchor(delta)),
+
+	// Single-step
+	{ id: "diff.up", title: "Up", keys: ["up", "k"], run: (s) => s.moveAnchor(-1) },
+	{ id: "diff.down", title: "Down", keys: ["down", "j"], run: (s) => s.moveAnchor(1) },
+
+	// Side selection
+	{ id: "diff.side-left", title: "Old side", keys: ["left", "h"], run: (s) => s.selectSide("LEFT") },
+	{ id: "diff.side-right", title: "New side", keys: ["right", "l"], run: (s) => s.selectSide("RIGHT") },
+
+	// File nav
+	{ id: "diff.next-file", title: "Next file", keys: ["]"], run: (s) => s.nextFile() },
+	{ id: "diff.previous-file", title: "Previous file", keys: ["["], run: (s) => s.previousFile() },
+
+	// Boundary jumps + align
+	{ id: "diff.first", title: "First comment", keys: ["g g"], run: (s) => s.moveAnchorToBoundary("first") },
+	{ id: "diff.last", title: "Last comment", keys: ["shift+g"], run: (s) => s.moveAnchorToBoundary("last") },
+	{ id: "diff.align-center", title: "Align center", keys: ["z z"], run: (s) => s.alignAnchor("center") },
+	{ id: "diff.align-top", title: "Align top", keys: ["z t"], run: (s) => s.alignAnchor("top") },
+	{ id: "diff.align-bottom", title: "Align bottom", keys: ["z b"], run: (s) => s.alignAnchor("bottom") },
+
+	{ id: "diff.open-browser", title: "Open in browser", keys: ["o"], run: (s) => s.openInBrowser() },
+)

package/src/keymap/filterMode.ts

@@ -0,0 +1,13 @@
+import { context } from "@ghui/keymap"
+
+export interface FilterModeCtx {
+	readonly cancel: () => void
+	readonly commit: () => void
+}
+
+const Filter = context<FilterModeCtx>()
+
+export const filterModeKeymap = Filter(
+	{ id: "filter-mode.cancel", title: "Cancel filter", keys: ["escape"], run: (s) => s.cancel() },
+	{ id: "filter-mode.commit", title: "Apply filter", keys: ["return"], run: (s) => s.commit() },
+)

package/src/keymap/helpers.ts

@@ -0,0 +1,24 @@
+import type { CommandConfig } from "@ghui/keymap"
+
+const MAX_COUNT_PREFIX = 99
+
+const countSequence = (count: number, key: string) =>
+	`${String(count).split("").join(" ")} ${key}`
+
+/**
+ * Vim-style "count prefix" navigation: `2 k` moves by 2, `15 j` by 15, etc.
+ * Generates bindings for `count` × {k, up, j, down} for count ∈ [1, 99].
+ *
+ * Each generated binding is anonymous (no meta) — they don't belong in the
+ * palette. Only `moveBy` semantics matter.
+ */
+export const countedVerticalBindings = <C>(
+	moveBy: (ctx: C, delta: number) => void,
+): readonly CommandConfig<C>[] => {
+	const out: CommandConfig<C>[] = []
+	for (let count = 1; count <= MAX_COUNT_PREFIX; count++) {
+		out.push({ keys: [countSequence(count, "k"), countSequence(count, "up")], run: (s) => moveBy(s, -count) })
+		out.push({ keys: [countSequence(count, "j"), countSequence(count, "down")], run: (s) => moveBy(s, count) })
+	}
+	return out
+}

package/src/keymap/labelModal.ts

@@ -0,0 +1,16 @@
+import { context } from "@ghui/keymap"
+
+export interface LabelModalCtx {
+	readonly closeModal: () => void
+	readonly toggleSelected: () => void
+	readonly moveSelection: (delta: -1 | 1) => void
+}
+
+const Label = context<LabelModalCtx>()
+
+export const labelModalKeymap = Label(
+	{ id: "label-modal.close", title: "Close", keys: ["escape"], run: (s) => s.closeModal() },
+	{ id: "label-modal.toggle", title: "Toggle label", keys: ["return"], run: (s) => s.toggleSelected() },
+	{ id: "label-modal.up", title: "Up", keys: ["k", "up"], run: (s) => s.moveSelection(-1) },
+	{ id: "label-modal.down", title: "Down", keys: ["j", "down"], run: (s) => s.moveSelection(1) },
+)