@chroxify/eunoe 1.0.0 → 1.1.0

package/src/cli/replay/index.ts

@@ -0,0 +1,141 @@
+import type { Config } from "../../config"
+import type { Body, Message } from "../../context/content"
+import { isPrompt, type ReduceOptions, reduceTurn, splitTurns, turnFingerprint } from "../../context/fold/turns"
+import { compact } from "../../proxy/compaction"
+import { DEFAULT_RATIO, sizeOf } from "../../proxy/estimate"
+import type { ThreadState } from "../../proxy/state"
+
+export interface ReplayOptions {
+  config: Config
+  window: number
+  fixedTokens: number
+  recallChars?: number
+}
+
+export interface Replay {
+  requests: number
+  turns: number
+  folds: number
+  dropped: number
+  nativeCompactions: number
+  discarded: number
+  plainTokens: number
+  eunoeTokens: number
+  plainCost: number
+  eunoeCost: number
+  peakPlain: number
+  peakEunoe: number
+}
+
+export interface ReplayedSession extends Replay {
+  id: string
+  file: string
+  bytes: number
+  cwd: string | null
+  title: string | null
+  ms: number
+}
+
+export const REPLAY_NATIVE_COMPACT_AT = 0.92
+
+const NATIVE_SUMMARY_CHARS = 30_000
+const CACHE_READ_WEIGHT = 0.1
+const CACHE_WRITE_WEIGHT = 1.25
+
+const emptyChars = sizeOf({ system: "", tools: [], messages: [] })
+const charsOf = (message: Message) => sizeOf({ system: "", tools: [], messages: [message] }) - emptyChars
+const listChars = (sum: number, count: number) => sum + Math.max(0, count - 1)
+const tokens = (chars: number) => Math.round(chars * DEFAULT_RATIO)
+
+function commonPrefix(a: Message[], b: Message[]): number {
+  let chars = 0
+  for (let i = 0; i < Math.min(a.length, b.length); i += 1) {
+    if (a[i] !== b[i] && JSON.stringify(a[i]) !== JSON.stringify(b[i])) break
+    chars += charsOf(a[i]) + 1
+  }
+  return chars
+}
+
+export function replaySession(messages: Message[], { config, window, fixedTokens, recallChars: recallPerPrompt = 3_500 }: ReplayOptions): Replay {
+  const out: Replay = { requests: 0, turns: 0, folds: 0, dropped: 0, nativeCompactions: 0, discarded: 0, plainTokens: 0, eunoeTokens: 0, plainCost: 0, eunoeCost: 0, peakPlain: 0, peakEunoe: 0 }
+  const fixedChars = Math.round(fixedTokens / DEFAULT_RATIO)
+  const system = "x".repeat(fixedChars)
+  const sizes = messages.map(charsOf)
+  const { preamble, turns } = splitTurns(messages)
+  const turnAt = [...preamble.map(() => -1), ...turns.flatMap((turn, k) => turn.map(() => k))]
+  const limit = (config.compactAt * window) / DEFAULT_RATIO
+  const cost = (chars: number, cacheable: number) => {
+    const cached = Math.max(0, cacheable - fixedChars)
+    return CACHE_READ_WEIGHT * tokens(cached) + CACHE_WRITE_WEIGHT * tokens(chars - fixedChars - cached)
+  }
+  out.turns = turns.length
+
+  const reduced = new Map<string, Message[]>()
+  const reduce = (turn: Message[], options: ReduceOptions) => {
+    const key = `${turnFingerprint(turn)}:${turn.length}`
+    const hit = reduced.get(key) ?? reduceTurn(turn, options)
+    reduced.set(key, hit)
+    return hit
+  }
+
+  const state: ThreadState = {}
+  const eunoe = { sent: [] as Message[], sum: 0, count: 0, upTo: 0, recall: 0, compactedTurn: -2, previous: 0 }
+  const plain = { sum: 0, count: 0, since: 0, previous: 0 }
+
+  const sendEunoe = (i: number) => {
+    const turn = turnAt[i - 1]
+    const newTurn = turn !== eunoe.compactedTurn
+    if (newTurn && state.cut && isPrompt(messages[i - 1])) eunoe.recall += recallPerPrompt
+    for (; eunoe.upTo < i; eunoe.upTo += 1) {
+      eunoe.sum += sizes[eunoe.upTo]
+      eunoe.count += 1
+    }
+    let cacheable = eunoe.previous
+    if (newTurn || fixedChars + listChars(eunoe.sum, eunoe.count) + eunoe.recall > limit) {
+      const recall = eunoe.recall
+      const decorate = (ms: Message[]) => (recall ? [...ms, { role: "user", content: "r".repeat(recall) }] : ms)
+      const result = compact({ body: { system, tools: [], messages: messages.slice(0, i) } as Body, config, state, window, guide: null, mayCompact: true, reduce, decorate })
+      if (result.note.compacted) out.folds += 1
+      out.dropped = Math.max(out.dropped, Number(result.note.omitted ?? 0))
+      if (result.note.compacted || result.note.actions) cacheable = Math.min(eunoe.previous, fixedChars + commonPrefix(eunoe.sent, result.messages))
+      eunoe.sent = result.messages
+      eunoe.sum = eunoe.sent.reduce((sum, m) => sum + charsOf(m), 0)
+      eunoe.count = eunoe.sent.length
+      eunoe.compactedTurn = turn
+    }
+    const chars = fixedChars + listChars(eunoe.sum, eunoe.count) + eunoe.recall
+    out.eunoeTokens += tokens(chars - fixedChars)
+    out.peakEunoe = Math.max(out.peakEunoe, tokens(chars))
+    out.eunoeCost += cost(chars, cacheable)
+    eunoe.previous = chars
+  }
+
+  const sendPlain = (i: number) => {
+    for (; plain.since < i; plain.since += 1) {
+      plain.sum += sizes[plain.since]
+      plain.count += 1
+    }
+    let chars = fixedChars + listChars(plain.sum, plain.count)
+    let cacheable = plain.previous
+    out.peakPlain = Math.max(out.peakPlain, tokens(chars))
+    if (tokens(chars) > REPLAY_NATIVE_COMPACT_AT * window) {
+      out.nativeCompactions += 1
+      out.discarded += tokens(chars - fixedChars)
+      plain.sum = NATIVE_SUMMARY_CHARS
+      plain.count = 1
+      chars = fixedChars + listChars(plain.sum, plain.count)
+      cacheable = fixedChars
+    }
+    out.plainTokens += tokens(chars - fixedChars)
+    out.plainCost += cost(chars, cacheable)
+    plain.previous = chars
+  }
+
+  for (let i = 1; i < messages.length; i += 1) {
+    if (messages[i].role !== "assistant") continue
+    out.requests += 1
+    sendEunoe(i)
+    sendPlain(i)
+  }
+  return out
+}

package/src/cli/replay/worker.ts

@@ -0,0 +1,15 @@
+import { statSync } from "node:fs"
+import { basename } from "node:path"
+import { cwdOf, titleOf } from "../../proxy/sessions"
+import { sessionMessages } from "../../transcript/messages"
+import { type ReplayedSession, type ReplayOptions, replaySession } from "."
+
+declare var self: Worker
+
+self.onmessage = (event: MessageEvent<{ file: string; options: ReplayOptions }>) => {
+  const { file, options } = event.data
+  const started = performance.now()
+  const replay = replaySession(sessionMessages(file), options)
+  const done: ReplayedSession = { ...replay, id: basename(file, ".jsonl"), file, bytes: statSync(file).size, cwd: cwdOf(file) ?? null, title: titleOf(file) ?? null, ms: Math.round(performance.now() - started) }
+  postMessage(done)
+}

package/src/cli/sessions/browse.ts

@@ -0,0 +1,88 @@
+import { clip } from "../../context/content"
+import { interact, keys, printable } from "../terminal/prompt"
+import { c, wrap } from "../terminal/ui"
+import { askOf, metaOf, shortId } from "."
+import { rankCandidates, type SessionCandidate } from "./source"
+
+export const UNTITLED = "untitled"
+
+const ROWS = 7
+
+const metas = new Map<string, string>()
+
+const columns = () => Math.max(60, process.stdout.columns ?? 100)
+
+function cachedMeta(cand: SessionCandidate) {
+  const meta = metas.get(cand.id) ?? metaOf(cand)
+  metas.set(cand.id, meta)
+  return meta
+}
+
+export function filterCandidates(query: string, candidates: SessionCandidate[]): SessionCandidate[] {
+  const words = query.toLowerCase().split(/\s+/).filter(Boolean)
+  if (words.length === 0) return candidates
+  const ranked = rankCandidates(query, candidates)
+  const haystack = (cand: SessionCandidate) => `${cand.label} ${cand.asks.join(" ")} ${cand.id}`.toLowerCase()
+  const loose = candidates.filter((cand) => !ranked.includes(cand) && words.every((word) => haystack(cand).includes(word)))
+  return [...ranked, ...loose]
+}
+
+function row(cand: SessionCandidate, chosen: boolean, width: number): string[] {
+  const marker = chosen ? c.green("●") : c.dim("○")
+  const info = cachedMeta(cand)
+  const title = cand.label ? clip(cand.label, width - info.length - 16) : UNTITLED
+  const head = `  ${marker} ${c.cyan(shortId(cand.id))}  ${chosen ? c.bold(title) : cand.label ? title : c.dim(title)}  ${c.dim(info)}`
+  if (!chosen) return [head]
+  const lines = [head]
+  for (const [label, text] of [
+    ["first", cand.asks[0]],
+    ["last ", cand.asks.at(-1)],
+  ] as const) {
+    const [first = "", ...rest] = wrap(askOf(text), width - 14)
+    lines.push(`      ${c.dim(label)}  ${first}`, ...rest.map((more) => `             ${more}`))
+  }
+  return lines
+}
+
+function render(title: string, query: string, shown: SessionCandidate[], total: number, index: number, help: string): string[] {
+  const width = columns()
+  const lines = [`  ${c.bold(title)}  ${c.dim(`${shown.length} of ${total}`)}`, `  ${c.cyan("›")} ${query || c.dim("type to filter")}`, ""]
+  if (shown.length === 0) lines.push(`  ${c.dim("nothing matches")}`)
+  const start = Math.max(0, Math.min(index - Math.floor(ROWS / 2), shown.length - ROWS))
+  if (start > 0) lines.push(`  ${c.dim(`↑ ${start} more`)}`)
+  for (const [i, cand] of shown.slice(start, start + ROWS).entries()) lines.push(...row(cand, start + i === index, width))
+  if (start + ROWS < shown.length) lines.push(`  ${c.dim(`↓ ${shown.length - start - ROWS} more`)}`)
+  lines.push("", `  ${c.dim(help)}`)
+  return lines
+}
+
+export async function browse(title: string, candidates: SessionCandidate[], initial = "", help = "↑↓ move · type to filter · enter choose · esc quit"): Promise<SessionCandidate | null> {
+  let query = initial
+  let shown = filterCandidates(query, candidates)
+  let index = 0
+  let chosen: SessionCandidate | null = null
+  const step = (by: number) => {
+    index = shown.length > 0 ? (index + shown.length + by) % shown.length : 0
+  }
+  await interact(
+    () => render(title, query, shown, candidates.length, index, help),
+    (key) => {
+      if (key === keys.up || key === keys.down) {
+        step(key === keys.up ? -1 : 1)
+        return
+      }
+      if (keys.enter.includes(key)) {
+        chosen = shown[index] ?? null
+        return true
+      }
+      if (keys.escape.includes(key)) return true
+      if (keys.backspace.includes(key)) query = query.slice(0, -1)
+      else if (key === keys.clear) query = ""
+      else if (printable(key)) query += key
+      else return
+      shown = filterCandidates(query, candidates)
+      index = 0
+    },
+  )
+  return chosen
+}

package/src/cli/sessions/index.ts

@@ -0,0 +1,76 @@
+import { spawnSync } from "node:child_process"
+import { claudeConfigDirs, readConfig } from "../../config"
+import { FOLD_CAP_CHARS, foldedView, sourceChunks } from "../../context/fold"
+import { recallFor } from "../../context/recall"
+import { DEFAULT_RATIO } from "../../proxy/estimate"
+import { continueToken } from "../../proxy/handoff"
+import { seenSessions } from "../../proxy/sessions"
+import { isSessionId } from "../../transcript/locate"
+import { subagentChunks } from "../../transcript/subagents"
+import { flagValues } from "../terminal/args"
+import { ago, fail, tokens } from "../terminal/ui"
+import { type SessionCandidate, sessionCandidates } from "./source"
+
+const ASK_CHARS = 160
+
+export const shortId = (sessionId: string) => sessionId.slice(0, 8)
+
+function byPrefix<T>(input: string, items: T[], idOf: (item: T) => string): T | null {
+  if (!isSessionId(input)) fail(`Not a session id: ${input}`)
+  const exact = items.find((item) => idOf(item) === input)
+  if (exact) return exact
+  const matches = items.filter((item) => idOf(item).startsWith(input))
+  if (matches.length > 1) fail(`${input} matches ${matches.length} sessions`, "Use more of the id.")
+  return matches[0] ?? null
+}
+
+export function sessionArgs(args: string[]): string[] {
+  const seen = seenSessions().map(([id]) => id)
+  return [...new Set(flagValues(args, "--session").map((input) => byPrefix(input, seen, (id) => id) ?? input))]
+}
+
+export function isKnown(sessionId: string) {
+  return seenSessions().some(([id]) => id === sessionId)
+}
+
+export const candidatesHere = () => sessionCandidates(process.env.CLAUDE_CODE_SESSION_ID ?? "", process.cwd(), claudeConfigDirs(readConfig()))
+
+export function candidateOf(input: string | undefined, candidates: SessionCandidate[]): SessionCandidate {
+  if (!input) fail("Say which session: eunoe sessions lists them.")
+  return byPrefix(input, candidates, (cand) => cand.id) ?? fail(`No earlier session ${input} in this directory.`, "eunoe sessions lists them.")
+}
+
+const tokensOf = (cand: SessionCandidate) => tokens(Math.round(foldedView(cand.messages, FOLD_CAP_CHARS).length * DEFAULT_RATIO))
+
+export const titleOf = (cand: SessionCandidate) => cand.label || shortId(cand.id)
+
+export const metaOf = (cand: SessionCandidate) => `${cand.asks.length} turns · ~${tokensOf(cand)} tokens · ${ago(new Date(cand.mtime).toISOString())}`
+
+export function askOf(text: string | undefined): string {
+  const flat = (text ?? "").replace(/\s+/g, " ").trim()
+  if (flat.length <= ASK_CHARS) return flat
+  const cut = flat.slice(0, ASK_CHARS)
+  return `${cut.slice(0, Math.max(cut.lastIndexOf(" "), ASK_CHARS / 2))}…`
+}
+
+export const continuePrompt = (id: string) => continueToken(shortId(id))
+
+export function copy(text: string): boolean {
+  const clipboards: Array<[string, string[]]> = [
+    ["pbcopy", []],
+    ["wl-copy", []],
+    ["xclip", ["-selection", "clipboard"]],
+  ]
+  return clipboards.some(([cmd, args]) => {
+    const result = spawnSync(cmd, args, { input: text })
+    return !result.error && result.status === 0
+  })
+}
+
+export function peekText(cand: SessionCandidate, words: string): string | null {
+  const chunks = [...sourceChunks(cand.messages, titleOf(cand), true), ...subagentChunks(cand.file)]
+  const found = recallFor(words, chunks, { maxChars: 12_000, maxCharsMulti: 12_000, perQuery: 6, minTerms: 1 })
+  if (!found) return null
+  const excerpts = found.replace(/^<recalled-context>\n[^\n]*\n\n|\n<\/recalled-context>$/g, "")
+  return `Excerpts of session ${shortId(cand.id)} "${titleOf(cand)}" that match "${words}", quoted exactly, oldest first:\n\n${excerpts}`
+}

package/src/cli/sessions/source.ts

@@ -0,0 +1,74 @@
+import { statSync } from "node:fs"
+import path from "node:path"
+import { type Message, textOf } from "../../context/content"
+import { isPrompt, splitTurns } from "../../context/fold/turns"
+import { type RecallChunk, rank, terms } from "../../context/recall"
+import { cwdOf, seenSessions, titleOf } from "../../proxy/sessions"
+import { findSessionFile, listEntries, projectFolderName } from "../../transcript/locate"
+import { sessionMessages } from "../../transcript/messages"
+
+export interface SessionCandidate {
+  id: string
+  file: string
+  label: string
+  mtime: number
+  asks: string[]
+  outline: string
+  messages: Message[]
+}
+
+export const SESSION_SOURCE_MIN_TURNS = 2
+export const SESSION_SOURCE_CANDIDATES = 12
+export const SESSION_MIN_TERMS = 2
+
+const promptText = (message: Message) =>
+  textOf(message)
+    .replace(/<[a-z-]+(?:\s[^>]*)?>[\s\S]*?<\/[a-z-]+>/g, "")
+    .trim()
+
+export function outlineOf(messages: Message[]): string[] {
+  return splitTurns(messages)
+    .turns.filter((turn) => isPrompt(turn[0]))
+    .map((turn) => promptText(turn[0]))
+    .filter(Boolean)
+    .map((text) => text.slice(0, 240))
+}
+
+function sessionFiles(sessionId: string, cwd: string, configDirs: string[]): Array<{ id: string; file: string; mtime: number }> {
+  const files = new Map<string, { file: string; mtime: number }>()
+  const add = (id: string, file: string) => {
+    if (id === sessionId || files.has(id)) return
+    try {
+      files.set(id, { file, mtime: statSync(file).mtimeMs })
+    } catch {}
+  }
+  for (const [id, seen] of seenSessions()) {
+    if (seen.cwd !== cwd) continue
+    const file = findSessionFile(id, configDirs)
+    if (file) add(id, file)
+  }
+  for (const dir of configDirs) {
+    const folder = path.join(dir, "projects", projectFolderName(cwd))
+    for (const name of listEntries(folder)) if (name.endsWith(".jsonl")) add(name.slice(0, -".jsonl".length), path.join(folder, name))
+  }
+  return [...files].map(([id, entry]) => ({ id, ...entry })).sort((a, b) => b.mtime - a.mtime)
+}
+
+export function sessionCandidates(sessionId: string, cwd: string, configDirs: string[]): SessionCandidate[] {
+  const out: SessionCandidate[] = []
+  for (const { id, file, mtime } of sessionFiles(sessionId, cwd, configDirs)) {
+    const recorded = cwdOf(file)
+    if (recorded && recorded !== cwd) continue
+    const messages = sessionMessages(file)
+    const asks = outlineOf(messages)
+    if (asks.length < SESSION_SOURCE_MIN_TURNS) continue
+    out.push({ id, file, label: titleOf(file) ?? "", mtime, asks, outline: asks.map((ask, i) => `${i + 1}. ${ask}`).join("\n"), messages })
+    if (out.length >= SESSION_SOURCE_CANDIDATES) break
+  }
+  return out
+}
+
+export function rankCandidates(prompt: string, candidates: SessionCandidate[]): SessionCandidate[] {
+  const chunks: RecallChunk[] = candidates.map((cand, i) => ({ turn: i, call: cand.id, lines: [cand.outline], terms: terms(cand.outline) }))
+  return rank(terms(prompt), chunks, SESSION_MIN_TERMS).map((r) => candidates[r.index])
+}

package/src/cli/{help.ts → terminal/help.ts}

@@ -1,20 +1,36 @@
-import { VERSION } from "../version"
-import { GLOBAL_OPTIONS, TAGLINE } from "./constants"
-import { withLogo } from "./logo"
-import type { Command } from "./types"
+import { VERSION } from "../../version"
+import type { Command, OptionRow } from "../command"
+import { withLogo } from "../logo"
 import { c, line } from "./ui"
 
+const GROUPS: Array<[title: string, names: string[]]> = [
+  ["Proxy", ["start", "stop", "status", "replay", "uninstall"]],
+  ["Context", ["mode", "settings"]],
+  ["Sessions", ["sessions"]],
+]
+
+const GLOBAL_OPTIONS: OptionRow[] = [
+  ["-h, --help", "Show help for a command"],
+  ["-v, --version", "Show the version"],
+]
+
 export function printHelp(commands: Record<string, Command>) {
   const width = Math.max(...Object.keys(commands).map((name) => name.length), ...GLOBAL_OPTIONS.map(([flag]) => flag.length))
   line()
-  for (const row of withLogo([`${c.bold("eunoe")} ${c.dim(VERSION)}`, c.italic(TAGLINE)])) line(row)
+  for (const row of withLogo([`${c.bold("eunoe")} ${c.dim(VERSION)}`, c.italic("Context management for Claude Code that never forgets what matters.")])) line(row)
   line()
   line(`  ${c.dim("Usage")}`)
   line(`    eunoe ${c.cyan("<command>")} ${c.dim("[options]")}`)
   line()
-  line(`  ${c.dim("Commands")}`)
-  for (const [name, command] of Object.entries(commands).filter(([, command]) => !command.hidden)) line(`    ${c.cyan(name.padEnd(width))}   ${command.summary}`)
-  line()
+  const visible = Object.keys(commands).filter((name) => !commands[name].hidden)
+  const grouped = new Set(GROUPS.flatMap(([, names]) => names))
+  for (const [title, names] of [...GROUPS, ["Other", visible.filter((name) => !grouped.has(name))] as const]) {
+    const shown = names.filter((name) => visible.includes(name))
+    if (shown.length === 0) continue
+    line(`  ${c.dim(title)}`)
+    for (const name of shown) line(`    ${c.cyan(name.padEnd(width))}   ${commands[name].summary}`)
+    line()
+  }
   line(`  ${c.dim("Options")}`)
   for (const [flag, description] of GLOBAL_OPTIONS) line(`    ${flag.padEnd(width)}   ${description}`)
   line()

package/src/cli/terminal/prompt.ts

@@ -0,0 +1,114 @@
+import { c, useColor } from "./ui"
+
+const ESC = "\x1b"
+const KEY_SEQUENCE = new RegExp(`${ESC}\\[[0-9;]*[A-Za-z~]|${ESC}.|[\\s\\S]`, "g")
+
+interface Choice<T extends string = string> {
+  value: T
+  label?: string
+  hint?: string
+}
+
+export const keys = {
+  up: "\x1b[A",
+  down: "\x1b[B",
+  enter: ["\r", "\n"],
+  escape: ["\x1b", "\x03"],
+  backspace: ["\x7f", "\b"],
+  clear: "\x15",
+}
+
+export const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY)
+
+export const printable = (key: string) => key >= " " && !key.startsWith("\x1b")
+
+function readKeys(onKey: (key: string) => boolean | undefined): Promise<void> {
+  return new Promise((resolve) => {
+    const stdin = process.stdin
+    stdin.setRawMode(true)
+    stdin.resume()
+    stdin.setEncoding("utf8")
+    const handler = (chunk: string) => {
+      for (const key of chunk.match(KEY_SEQUENCE) ?? []) {
+        if (onKey(key) !== true) continue
+        stdin.off("data", handler)
+        stdin.setRawMode(false)
+        stdin.pause()
+        resolve()
+        return
+      }
+    }
+    stdin.on("data", handler)
+  })
+}
+
+export async function interact(render: () => string[], onKey: (key: string) => boolean | undefined, hideCursor = true): Promise<void> {
+  let drawn = 0
+  const draw = () => {
+    const lines = render()
+    if (drawn) process.stdout.write(`\x1b[${drawn}A\x1b[J`)
+    process.stdout.write(`${lines.join("\n")}\n`)
+    drawn = lines.length
+  }
+  const toggleCursor = hideCursor && useColor
+  if (toggleCursor) process.stdout.write("\x1b[?25l")
+  draw()
+  await readKeys((key) => {
+    if (onKey(key) === true) return true
+    draw()
+  })
+  process.stdout.write(`\x1b[${drawn}A\x1b[J`)
+  if (toggleCursor) process.stdout.write("\x1b[?25h")
+}
+
+function renderChoices(title: string, choices: Choice[], index: number, width: number) {
+  const lines = [`  ${c.bold(title)}`, ""]
+  for (const [i, choice] of choices.entries()) {
+    const label = (choice.label ?? choice.value).padEnd(width)
+    const marker = i === index ? c.green("●") : c.dim("○")
+    lines.push(`  ${marker} ${i === index ? c.bold(label) : label}${choice.hint ? `  ${c.dim(choice.hint)}` : ""}`)
+  }
+  lines.push("", `  ${c.dim("↑↓ move · enter choose · esc cancel")}`)
+  return lines
+}
+
+export async function select<T extends string>(title: string, choices: Choice<T>[], current?: T): Promise<T | null> {
+  let index = Math.max(
+    0,
+    choices.findIndex((choice) => choice.value === current),
+  )
+  const width = Math.max(...choices.map((choice) => (choice.label ?? choice.value).length))
+  let chosen: T | null = null
+  await interact(
+    () => renderChoices(title, choices, index, width),
+    (key) => {
+      if (key === keys.up || key === "k") index = (index + choices.length - 1) % choices.length
+      else if (key === keys.down || key === "j") index = (index + 1) % choices.length
+      else if (keys.enter.includes(key)) {
+        chosen = choices[index].value
+        return true
+      } else if (keys.escape.includes(key) || key === "q") return true
+    },
+  )
+  return chosen
+}
+
+export async function input(title: string, placeholder: string, initial = ""): Promise<string | null> {
+  let value = initial
+  let result: string | null = null
+  const render = () => [`  ${c.bold(title)}`, `  ${c.cyan("›")} ${value || c.dim(placeholder)}`, "", `  ${c.dim("enter save · esc cancel")}`]
+  await interact(
+    render,
+    (key) => {
+      if (keys.enter.includes(key)) {
+        result = value
+        return true
+      }
+      if (keys.escape.includes(key)) return true
+      if (keys.backspace.includes(key)) value = value.slice(0, -1)
+      else if (printable(key)) value += key
+    },
+    false,
+  )
+  return result
+}