feat: Navigate prompts with ctrl-p and ctrl-n (#605)

* feat: Navigate prompts with ctrl-p and ctrl-n

Re-emit the Emacs-style control keypresses as arrow keys so they move
the cursor in every clack prompt kind, including autocomplete, which
ignores clack's own key alias table.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FyVFq6gYChW9wtoDq8CHsD

* feat: Add ctrl-j/k prompt navigation and arrow key back and forth

Replace the keypress alias listener with an input stream that rewrites
keys before readline decodes them, which the alias approach could not do:
ctrl-j arrives as a line feed that readline submits, wiping the typed
autocomplete filter.

The translated stream also makes the right arrow submit and the left
arrow return to the previous prompt, both only while nothing is typed, so
the caret still works while editing a filter or value. Going back is opt
in per prompt, so a stray left arrow cannot abandon a command, and the
command menu now goes up one level rather than back to the root.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FyVFq6gYChW9wtoDq8CHsD

* Revert "feat: Add ctrl-j/k prompt navigation and arrow key back and forth"

This reverts commit f4e10c3.

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: razor-x

src/lib/util/prompt.test.ts

@@ -1,6 +1,14 @@
+import { EventEmitter } from 'node:events'
+import type { Key } from 'node:readline'
+
 import { expect, test } from 'vitest'
 
-import { type SearchableChoice, searchChoices } from './prompt.js'
+import {
+  arrowKeyFor,
+  emitArrowKeyAliases,
+  type SearchableChoice,
+  searchChoices,
+} from './prompt.js'
 
 const workspaces = [
   { label: 'Sandbox', hint: 'ws_1' },
@@ -33,3 +41,54 @@ test('searchChoices: offers every choice until something is typed', () => {
   expect(search('', workspaces)).toEqual(workspaces)
   expect(search('  ', workspaces)).toEqual(workspaces)
 })
+
+const ctrl = (name: string): Key => ({
+  name,
+  ctrl: true,
+  meta: false,
+  shift: false,
+  sequence: String.fromCharCode(name.charCodeAt(0) - 96),
+})
+
+test('arrowKeyFor: maps ctrl-p and ctrl-n to the arrow keys', () => {
+  expect(arrowKeyFor(ctrl('p'))?.name).toBe('up')
+  expect(arrowKeyFor(ctrl('n'))?.name).toBe('down')
+})
+
+test('arrowKeyFor: leaves every other key alone', () => {
+  expect(arrowKeyFor(undefined)).toBeUndefined()
+  expect(arrowKeyFor(ctrl('c'))).toBeUndefined()
+  expect(arrowKeyFor({ name: 'p', sequence: 'p' })).toBeUndefined()
+  expect(arrowKeyFor({ name: 'n', sequence: 'n' })).toBeUndefined()
+  expect(arrowKeyFor({ ...ctrl('p'), meta: true })).toBeUndefined()
+  expect(arrowKeyFor({ ...ctrl('n'), shift: true })).toBeUndefined()
+  expect(arrowKeyFor({ name: 'up', sequence: '\x1B[A' })).toBeUndefined()
+})
+
+test('emitArrowKeyAliases: re-emits control keypresses as arrow keys', () => {
+  const input = new EventEmitter()
+  emitArrowKeyAliases(input)
+
+  const keypresses: Array<[string | undefined, Key | undefined]> = []
+  input.on('keypress', (char, key) => keypresses.push([char, key]))
+
+  input.emit('keypress', '\x10', ctrl('p'))
+  input.emit('keypress', 'a', { name: 'a', sequence: 'a' })
+
+  // The synthetic arrow key arrives first: the re-emit is synchronous,
+  // and the alias listener runs before any listener attached after it.
+  expect(keypresses).toEqual([
+    [
+      undefined,
+      {
+        name: 'up',
+        ctrl: false,
+        meta: false,
+        shift: false,
+        sequence: '\x1B[A',
+      },
+    ],
+    ['\x10', ctrl('p')],
+    ['a', { name: 'a', sequence: 'a' }],
+  ])
+})

src/lib/util/prompt.ts

@@ -1,3 +1,6 @@
+import type { EventEmitter } from 'node:events'
+import type { Key } from 'node:readline'
+
 import {
   autocomplete,
   autocompleteMultiselect,
@@ -40,6 +43,46 @@ const ensureInteractive = (): void => {
       'Cannot prompt without a terminal: pass the missing arguments, or pipe them in as JSON',
     )
   }
+  installArrowKeyAliases()
+}
+
+/**
+ * The arrow keypress an Emacs-style control keypress stands for, or
+ * undefined for any other key: ctrl-p is up and ctrl-n is down.
+ */
+export const arrowKeyFor = (key: Key | undefined): Key | undefined => {
+  if (key?.ctrl !== true || key.meta === true || key.shift === true) {
+    return undefined
+  }
+  const base = { ctrl: false, meta: false, shift: false }
+  if (key.name === 'p') return { ...base, name: 'up', sequence: '\x1B[A' }
+  if (key.name === 'n') return { ...base, name: 'down', sequence: '\x1B[B' }
+  return undefined
+}
+
+/**
+ * Re-emit Emacs-style control keypresses as the arrow keys they stand for.
+ *
+ * Clack navigates on the readline key name, so a synthetic arrow keypress
+ * moves the cursor in every prompt kind. Its own alias table cannot express
+ * this: aliases match bare key names, unaware of ctrl, and are ignored by
+ * prompts that track typed input, such as autocomplete.
+ */
+export const emitArrowKeyAliases = (input: EventEmitter): void => {
+  input.on('keypress', (_char, key: Key | undefined) => {
+    const arrowKey = arrowKeyFor(key)
+    if (arrowKey !== undefined) input.emit('keypress', undefined, arrowKey)
+  })
+}
+
+let arrowKeyAliasesInstalled = false
+
+// Keypress events only flow while a prompt has stdin in raw mode, so the
+// listener is inert the rest of the time and never holds the process open.
+const installArrowKeyAliases = (): void => {
+  if (arrowKeyAliasesInstalled) return
+  arrowKeyAliasesInstalled = true
+  emitArrowKeyAliases(process.stdin)
 }
 
 const unwrap = <Value>(value: Value | symbol): Value => {