flashlite 0.0.0-stage → 0.1.1

package/dist/lineinput.js

@@ -0,0 +1,982 @@
+// lineinput.ts — raw-mode line editor for the REPL (macOS Terminal).
+// Bracketed paste submits multi-line pastes as one turn; Ctrl+C interrupts, Ctrl+D
+// exits, arrows walk history, Ctrl+A/E and left/right move the cursor. Piped stdin
+// falls back to plain readline so `echo "…" | flash` keeps working.
+import readline from 'node:readline';
+import { StringDecoder } from 'node:string_decoder';
+import { ui, orange, bold, dim } from "./ui.js";
+import { matchingCommands } from "./commands.js";
+const PASTE_START = '\x1b[200~';
+const PASTE_END = '\x1b[201~';
+/** Visible rows in the picker menu; the list scrolls under this window when longer. */
+const MENU_HEIGHT = 15;
+/** Pure key-to-action core — separated so the editor logic stays testable. */
+export function editLine(chars, state) {
+    const out = { ...state };
+    for (const c of chars) {
+        if (c === '\r' || c === '\n') {
+            return { ...out, submit: out.buffer };
+        }
+        if (c === '\x03') {
+            return { buffer: '', cursor: 0, interrupt: true };
+        }
+        if (c === '\x7f' || c === '\b') {
+            if (out.cursor > 0) {
+                out.buffer = out.buffer.slice(0, out.cursor - 1) + out.buffer.slice(out.cursor);
+                out.cursor--;
+            }
+            continue;
+        }
+        if (c === '\x01') {
+            out.cursor = 0; // Ctrl+A home
+            continue;
+        }
+        if (c === '\x05') {
+            out.cursor = out.buffer.length; // Ctrl+E end
+            continue;
+        }
+        if (c === '\x15') {
+            out.buffer = ''; // Ctrl+U kill line
+            out.cursor = 0;
+            continue;
+        }
+        if (c === '\x0b') {
+            out.buffer = out.buffer.slice(0, out.cursor); // Ctrl+K kill to end
+            continue;
+        }
+        if (c >= ' ') {
+            out.buffer = out.buffer.slice(0, out.cursor) + c + out.buffer.slice(out.cursor);
+            out.cursor++;
+        }
+        // other control chars are ignored
+    }
+    return out;
+}
+export class LineInput {
+    handlers;
+    prompt = orange('❯ ');
+    model = '';
+    buffer = '';
+    cursor = 0;
+    history = [];
+    histIndex = 0;
+    historyDraft = null;
+    pasting = false;
+    pasteBuf = '';
+    esc = '';
+    decoder = new StringDecoder('utf8');
+    fallback = null;
+    questionResolve = null;
+    echoQuestion = true;
+    maskQuestion = false;
+    stopped = false;
+    paused = false;
+    working = false;
+    questionDraft = null;
+    selectDraft = null;
+    selectItems = null;
+    selectIndex = 0;
+    selectTop = 0;
+    selectResolve = null;
+    selectEsc = '';
+    menuShown = false;
+    dockMenu = false;
+    selectEscapeTimer = null;
+    paletteOpen = false;
+    paletteIndex = 0;
+    paletteText = '';
+    paletteDismissed = false;
+    viewResolve = null;
+    viewRefresh = null;
+    viewEsc = '';
+    viewRefreshing = false;
+    completer = null;
+    navigation = '';
+    navigationTimer = null;
+    // Bash-style reverse history search: Ctrl+R opens it, ✔→older/↑→older, ↓→newer,
+    // Enter accepts the match into the draft, Esc restores the pre-search draft.
+    searching = false;
+    searchQuery = '';
+    searchMatches = [];
+    searchPos = 0;
+    searchDraft = null;
+    /** Live read-only command panel; arrows scroll, r refreshes, Enter/Esc dismisses. */
+    view(lines, refresh) {
+        this.closePalette();
+        if (!ui.panel(lines, () => this.closeView())) {
+            lines.forEach((line) => ui.say(line));
+            return Promise.resolve();
+        }
+        this.viewRefresh = refresh;
+        return new Promise((resolve) => { this.viewResolve = resolve; });
+    }
+    updateView(lines) {
+        if (this.viewResolve)
+            ui.panel(lines);
+    }
+    closeView() {
+        const resolve = this.viewResolve;
+        this.viewResolve = null;
+        this.viewRefresh = null;
+        this.viewEsc = '';
+        this.viewRefreshing = false;
+        if (this.selectEscapeTimer)
+            clearTimeout(this.selectEscapeTimer);
+        this.selectEscapeTimer = null;
+        ui.closePanel();
+        resolve?.();
+    }
+    closePalette() {
+        if (this.paletteOpen)
+            ui.closeMenu();
+        this.paletteOpen = false;
+        if (this.selectEscapeTimer)
+            clearTimeout(this.selectEscapeTimer);
+        this.selectEscapeTimer = null;
+        this.esc = '';
+    }
+    constructor(handlers) {
+        this.handlers = handlers;
+    }
+    /** Enable the editor; piped stdin falls back to plain readline. */
+    start() {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            this.fallback = readline.createInterface({ input: process.stdin, output: process.stdout });
+            this.fallback.on('line', (line) => {
+                if (this.questionResolve) {
+                    this.answerQuestion(line);
+                    return;
+                }
+                this.handlers.onLine(line);
+            });
+            this.fallback.on('SIGINT', () => {
+                if (this.questionResolve)
+                    this.answerQuestion('n');
+                this.handlers.onInterrupt();
+            });
+            this.fallback.on('close', () => {
+                if (this.questionResolve)
+                    this.answerQuestion('n');
+                this.handlers.onEof();
+            });
+            return;
+        }
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.on('data', this.onData);
+        process.on('SIGTERM', this.onSigterm);
+        this.redraw();
+    }
+    stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        if (this.navigationTimer)
+            clearTimeout(this.navigationTimer);
+        this.navigationTimer = null;
+        this.navigation = '';
+        if (this.searching)
+            this.searchCancel();
+        this.closePalette();
+        if (this.viewResolve)
+            this.closeView();
+        ui.clearComposer();
+        if (this.selectResolve)
+            this.selectFinish(null);
+        ui.closeDock();
+        if (this.fallback) {
+            this.fallback.close();
+            return;
+        }
+        process.stdin.off('data', this.onData);
+        process.off('SIGTERM', this.onSigterm);
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(false);
+        process.stdin.pause();
+    }
+    /** Stop and fire onEof exactly once (the /exit and Ctrl+D path). */
+    close() {
+        if (this.stopped)
+            return;
+        if (this.fallback) {
+            this.fallback.close(); // its 'close' handler fires onEof
+            return;
+        }
+        this.stop();
+        this.handlers.onEof();
+    }
+    /** Pause normal editing during command/clipboard loading; interrupts stay responsive. */
+    pause() {
+        this.paused = true;
+        ui.clearComposer();
+    }
+    resume() {
+        this.paused = false;
+        this.redraw();
+    }
+    /** Live drafting during agent turns; submitted steering renders at a safe boundary. */
+    setWorking(working) {
+        this.working = working;
+        this.redraw();
+    }
+    /** Release an open command panel/picker before an agent permission question. */
+    cancelControls() {
+        if (this.searching)
+            this.searchCancel();
+        if (this.viewResolve)
+            this.closeView();
+        if (this.selectResolve)
+            this.selectFinish(null);
+        if (this.questionResolve)
+            this.answerQuestion('n');
+        this.closePalette();
+    }
+    /** Put unsent steering back in the editor after cancellation/error/round limit. */
+    restoreDraft(lines) {
+        if (!lines.length)
+            return;
+        const prefix = lines.join(' ') + (this.buffer ? ' ' : '');
+        this.buffer = prefix + this.buffer;
+        this.cursor += prefix.length;
+        this.redraw();
+    }
+    answerQuestion(answer) {
+        const resolve = this.questionResolve;
+        this.questionResolve = null;
+        ui.closeApproval();
+        this.echoQuestion = true;
+        this.maskQuestion = false;
+        if (this.questionDraft) {
+            const draft = this.questionDraft;
+            this.buffer = draft.buffer;
+            this.cursor = draft.cursor;
+            this.histIndex = draft.histIndex;
+            this.prompt = draft.prompt;
+            this.questionDraft = null;
+        }
+        this.redraw();
+        resolve?.(answer);
+    }
+    /** One-shot question mode temporarily replaces, then restores, the current draft. */
+    question(prompt, echoAnswer = true, maskInput = false) {
+        if (maskInput && this.fallback)
+            return Promise.resolve('');
+        this.questionDraft = { buffer: this.buffer, cursor: this.cursor, histIndex: this.histIndex, prompt: this.prompt };
+        this.echoQuestion = echoAnswer;
+        this.maskQuestion = maskInput;
+        this.prompt = prompt;
+        this.buffer = '';
+        this.cursor = 0;
+        return new Promise((resolve) => {
+            this.questionResolve = resolve;
+            this.redraw();
+        });
+    }
+    /** Interactive picker: arrow-key menu in a TTY, numbered list in a pipe. Resolves to
+     *  the chosen index (0-based) or null when cancelled. `current` pre-highlights a row. */
+    select(items, current = 0) {
+        if (items.length === 0)
+            return Promise.resolve(null);
+        if (this.fallback) {
+            const width = String(items.length).length;
+            items.forEach((label, i) => ui.say(`${String(i + 1).padStart(width)}. ${label}`));
+            return this.question('pick a number (Enter to cancel): ').then((answer) => {
+                const n = Number(answer);
+                return Number.isInteger(n) && n >= 1 && n <= items.length ? n - 1 : null;
+            });
+        }
+        this.closePalette();
+        this.selectDraft = { buffer: this.buffer, cursor: this.cursor, histIndex: this.histIndex };
+        this.selectItems = items;
+        this.selectIndex = Math.max(0, Math.min(current, items.length - 1));
+        this.selectTop = 0;
+        this.selectEsc = '';
+        ui.clearLine(); // the menu replaces the prompt line
+        this.menuShown = false;
+        this.renderMenu();
+        return new Promise((resolve) => {
+            this.selectResolve = resolve;
+        });
+    }
+    setModel(model) {
+        this.model = model;
+    }
+    /** Optional path/mention completer invoked on Tab; returns new buffer state or null. */
+    setCompleter(completer) {
+        this.completer = completer;
+    }
+    /** Re-render prompt + buffer (called after output lands on the terminal). */
+    redraw() {
+        if (this.stopped || this.paused || this.fallback || this.selectItems || this.viewResolve)
+            return;
+        if (this.questionResolve) {
+            const shown = this.maskQuestion ? '*'.repeat([...this.buffer].length) : this.buffer;
+            if (!ui.setApprovalChoice(shown, Math.min(this.cursor, shown.length)))
+                ui.line(this.prompt, shown, Math.min(this.cursor, shown.length));
+        }
+        else {
+            if (this.buffer !== this.paletteText) {
+                this.paletteText = this.buffer;
+                this.paletteIndex = 0;
+                this.paletteDismissed = false;
+            }
+            const commands = this.searching || this.paletteDismissed ? [] : matchingCommands(this.buffer);
+            if (commands.length) {
+                this.paletteIndex = Math.min(this.paletteIndex, commands.length - 1);
+                this.paletteOpen = ui.menu(commands.map((c) => `${c.id.padEnd(9)} ${c.description}`), this.paletteIndex, 0, () => { this.paletteDismissed = true; this.closePalette(); }, '↑/↓ choose · tab complete · enter run · esc close');
+            }
+            else
+                this.closePalette();
+            ui.composer(this.model, this.prompt, this.buffer, this.cursor);
+        }
+    }
+    setLine(text) {
+        this.buffer = text;
+        this.cursor = text.length;
+    }
+    submit(text) {
+        this.closePalette();
+        if (this.working && !this.questionResolve)
+            ui.clearComposer(); // queued steering renders at the next safe boundary
+        else if (text.trimStart().startsWith('/') && !this.questionResolve && process.stdout.isTTY)
+            ui.clearComposer();
+        else if ((!this.questionResolve || this.echoQuestion) && !ui.hasApproval())
+            ui.submitInput(this.prompt, text);
+        this.buffer = '';
+        this.cursor = 0;
+        this.prompt = orange('❯ ');
+        if (this.questionResolve) {
+            this.answerQuestion(text);
+            return;
+        }
+        if (text !== '' && this.history.at(-1) !== text) {
+            this.history.push(text);
+        }
+        this.histIndex = this.history.length;
+        this.historyDraft = null;
+        this.handlers.onLine(text);
+    }
+    onData = (chunk) => {
+        for (const c of this.decoder.write(chunk)) {
+            if (this.stopped)
+                return;
+            if (this.pasting) {
+                this.pasteBuf += c;
+                if (this.pasteBuf.endsWith(PASTE_END)) {
+                    this.pasteBuf = this.pasteBuf.slice(0, -PASTE_END.length);
+                    this.deliver(PASTE_END);
+                }
+                continue;
+            }
+            if (c === '\x03' || c === '\x04') {
+                if (this.navigationTimer)
+                    clearTimeout(this.navigationTimer);
+                this.navigationTimer = null;
+                this.navigation = '';
+                this.deliver(c);
+                continue;
+            }
+            if (this.navigation || c === '\x1b') {
+                this.navigation += c;
+                if (this.navigationTimer)
+                    clearTimeout(this.navigationTimer);
+                this.navigationTimer = null;
+                if (/^\x1b\[[\d;<?]*[A-Za-z~]$/.test(this.navigation) || this.navigation.length > 80 ||
+                    this.navigation.length > 1 && !this.navigation.startsWith('\x1b[')) {
+                    const sequence = this.navigation;
+                    this.navigation = '';
+                    if (!this.scrollKey(sequence))
+                        this.deliver(sequence);
+                }
+                else {
+                    this.navigationTimer = setTimeout(() => {
+                        const sequence = this.navigation;
+                        this.navigation = '';
+                        this.navigationTimer = null;
+                        if (sequence === '\x1b' && !this.paused) {
+                            if (this.viewResolve)
+                                this.closeView();
+                            else if (this.selectResolve)
+                                this.selectFinish(null);
+                            else if (this.questionResolve)
+                                this.answerQuestion('n');
+                            else if (this.searching)
+                                this.searchCancel();
+                            else {
+                                this.paletteDismissed = true;
+                                this.closePalette();
+                                this.redraw();
+                            }
+                        }
+                    }, 100);
+                }
+                continue;
+            }
+            this.deliver(c);
+        }
+    };
+    deliver(chars) {
+        if (this.stopped)
+            return;
+        if (this.paused) {
+            if (chars.includes('\x04'))
+                this.close();
+            else if (chars.includes('\x03'))
+                this.handlers.onInterrupt();
+        }
+        else
+            this.handle(chars);
+    }
+    scrollKey(sequence) {
+        const mouse = /^\x1b\[<(\d+);\d+;\d+[Mm]$/.exec(sequence);
+        const page = sequence === '\x1b[5~' ? -1 : sequence === '\x1b[6~' ? 1 : 0;
+        if (!mouse && !page)
+            return false;
+        const button = mouse ? Number(mouse[1]) : 0;
+        if (mouse && (button & 64) === 0)
+            return true; // discard click reports
+        const direction = page || ((button & 1) === 0 ? -1 : 1);
+        const delta = direction * (page ? 8 : 3);
+        if (this.viewResolve)
+            ui.scrollPanel(delta);
+        else if (this.selectItems)
+            this.selectMove(delta);
+        else if (this.paletteOpen) {
+            this.paletteIndex = Math.max(0, Math.min(matchingCommands(this.buffer).length - 1, this.paletteIndex + direction));
+            this.redraw();
+        }
+        else if (this.questionResolve && ui.hasApproval())
+            ui.scrollApproval(delta);
+        else
+            ui.scrollChat(-delta);
+        return true;
+    }
+    onSigterm = () => {
+        this.stop();
+        process.exit(0);
+    };
+    handle(chars) {
+        if (this.viewResolve) {
+            this.handleView(chars);
+            return;
+        }
+        if (this.selectResolve) {
+            this.handleSelect(chars);
+            return;
+        }
+        let i = 0;
+        while (i < chars.length) {
+            const c = chars[i];
+            if (this.searching) {
+                i = this.handleSearch(chars, i);
+                continue;
+            }
+            if (this.pasting) {
+                const end = chars.indexOf(PASTE_END, i);
+                if (end === -1) {
+                    this.pasteBuf += chars.slice(i);
+                    return;
+                }
+                this.pasteBuf += chars.slice(i, end);
+                i = end + PASTE_END.length;
+                this.pasting = false;
+                const pasted = this.pasteBuf;
+                this.pasteBuf = '';
+                if (pasted.includes('\n')) {
+                    if (pasted.trimEnd() !== '')
+                        this.setLine(pasted.replace(/\n/g, ' ').trimEnd());
+                    // A trailing-newline paste submits as one turn (bracketed-paste contract).
+                    if (pasted.endsWith('\n')) {
+                        this.submit(this.buffer);
+                        this.redraw();
+                        return;
+                    }
+                    this.redraw();
+                    continue;
+                }
+                this.insert(pasted);
+                this.redraw();
+                continue;
+            }
+            if (this.esc) {
+                if (this.selectEscapeTimer)
+                    clearTimeout(this.selectEscapeTimer);
+                this.selectEscapeTimer = null;
+                this.esc += c;
+                if (this.escIsComplete()) {
+                    this.handleEscape(this.esc);
+                    this.esc = '';
+                }
+                i++;
+                continue;
+            }
+            if (c === '\x1b') {
+                this.esc = c;
+                if (this.paletteOpen) {
+                    this.selectEscapeTimer = setTimeout(() => {
+                        this.esc = '';
+                        this.paletteDismissed = true;
+                        this.closePalette();
+                        this.redraw();
+                    }, 100);
+                }
+                i++;
+                continue;
+            }
+            if (!this.questionResolve && c === '\x0f') { // Ctrl+O: expand/collapse the latest tool result
+                ui.toggleToolDetails();
+                i++;
+                continue;
+            }
+            if (!this.questionResolve && (c === '\x16' || c === '\x18')) {
+                this.closePalette();
+                this.paletteDismissed = true;
+                if (c === '\x16')
+                    this.handlers.onPasteImage?.();
+                else
+                    this.handlers.onClearImages?.();
+                i++;
+                continue;
+            }
+            if (c === '\t') {
+                if (this.paletteOpen) {
+                    const chosen = matchingCommands(this.buffer)[this.paletteIndex];
+                    if (chosen)
+                        this.setLine(chosen.id + ' ');
+                    this.redraw();
+                    i++;
+                    continue;
+                }
+                if (this.completer) {
+                    const next = this.completer(this.buffer, this.cursor);
+                    if (next) {
+                        this.buffer = next.buffer;
+                        this.cursor = next.cursor;
+                        this.redraw();
+                    }
+                }
+                i++;
+                continue;
+            }
+            if (c === '\r' || c === '\n') {
+                const chosen = this.paletteOpen ? matchingCommands(this.buffer)[this.paletteIndex] : undefined;
+                this.submit(chosen?.id ?? this.buffer);
+                i++;
+                continue;
+            }
+            if (c === '\x03') {
+                if (!this.working || this.questionResolve)
+                    this.setLine('');
+                this.redraw();
+                if (this.questionResolve)
+                    this.answerQuestion('n'); // cancellation must never approve a write
+                this.handlers.onInterrupt();
+                i++;
+                continue;
+            }
+            if (c === '\x12' && !this.questionResolve) {
+                if (!this.searching && this.history.length > 0) {
+                    this.closePalette();
+                    this.searchStart();
+                }
+                this.redraw();
+                i++;
+                continue;
+            }
+            if (c === '\x04') {
+                if (this.buffer === '' || this.questionResolve) {
+                    if (this.questionResolve)
+                        this.answerQuestion('n');
+                    this.close();
+                }
+                i++;
+                continue;
+            }
+            const result = editLine(c, { buffer: this.buffer, cursor: this.cursor });
+            this.buffer = result.buffer;
+            this.cursor = result.cursor;
+            if (result.submit !== undefined)
+                this.submit(result.submit);
+            else
+                this.redraw();
+            i++;
+        }
+    }
+    insert(text) {
+        this.buffer = this.buffer.slice(0, this.cursor) + text + this.buffer.slice(this.cursor);
+        this.cursor += text.length;
+    }
+    escIsComplete() {
+        const e = this.esc;
+        if (e === PASTE_START || e === PASTE_END)
+            return true;
+        if (!e.startsWith('\x1b['))
+            return e.length >= 2;
+        const last = e.at(-1);
+        return last === '~' || last === 'A' || last === 'B' || last === 'C' || last === 'D' || last === 'H' || last === 'F' || last === 'Z';
+    }
+    handleEscape(seq) {
+        if (this.paletteOpen && (seq === '\x1b[A' || seq === '\x1b[B')) {
+            const delta = seq === '\x1b[A' ? -1 : 1;
+            this.paletteIndex = Math.max(0, Math.min(matchingCommands(this.buffer).length - 1, this.paletteIndex + delta));
+            this.redraw();
+            return;
+        }
+        if (seq === PASTE_START) {
+            this.pasting = true;
+            this.pasteBuf = '';
+            return;
+        }
+        if (seq === PASTE_END) {
+            this.pasting = false;
+            return;
+        }
+        switch (seq) {
+            case '\x1b[Z': // shift+tab — cycle the permission mode
+                if (!this.questionResolve)
+                    this.handlers.onCycleMode?.();
+                break;
+            case '\x1b[1;4Z': // shift+alt+tab (xterm modifier 4)
+                if (!this.questionResolve)
+                    this.handlers.onToggleBoost?.();
+                break;
+            case '\x1b[A': // up — history
+                if (!this.questionResolve && this.history.length > 0) {
+                    if (this.histIndex === this.history.length)
+                        this.historyDraft = { buffer: this.buffer, cursor: this.cursor };
+                    this.histIndex = Math.max(0, this.histIndex - 1);
+                    this.setLine(this.history[this.histIndex] ?? '');
+                    this.redraw();
+                }
+                break;
+            case '\x1b[B': // down — history
+                if (!this.questionResolve && this.histIndex < this.history.length) {
+                    this.histIndex = Math.min(this.history.length, this.histIndex + 1);
+                    if (this.histIndex === this.history.length && this.historyDraft) {
+                        this.buffer = this.historyDraft.buffer;
+                        this.cursor = this.historyDraft.cursor;
+                        this.historyDraft = null;
+                    }
+                    else
+                        this.setLine(this.history[this.histIndex] ?? '');
+                    this.redraw();
+                }
+                break;
+            case '\x1b[C': // right
+                if (this.cursor < this.buffer.length) {
+                    this.cursor++;
+                    this.redraw();
+                }
+                break;
+            case '\x1b[D': // left
+                if (this.cursor > 0) {
+                    this.cursor--;
+                    this.redraw();
+                }
+                break;
+            case '\x1b[H': // home
+                this.cursor = 0;
+                this.redraw();
+                break;
+            case '\x1b[F': // end
+                this.cursor = this.buffer.length;
+                this.redraw();
+                break;
+            default:
+                break; // unknown sequences ignored
+        }
+    }
+    handleView(chars) {
+        for (const c of chars) {
+            if (this.viewEsc) {
+                if (this.selectEscapeTimer)
+                    clearTimeout(this.selectEscapeTimer);
+                this.selectEscapeTimer = null;
+                this.viewEsc += c;
+                if (this.viewEsc === '\x1b[A' || this.viewEsc === '\x1b[B') {
+                    ui.scrollPanel(this.viewEsc === '\x1b[A' ? -1 : 1);
+                    this.viewEsc = '';
+                }
+                else if (!this.viewEsc.startsWith('\x1b[') || this.viewEsc.length > 3)
+                    this.viewEsc = '';
+                continue;
+            }
+            if (c === '\x1b') {
+                this.viewEsc = c;
+                this.selectEscapeTimer = setTimeout(() => this.closeView(), 100);
+            }
+            else if (c === '\r' || c === '\n' || c === '\x03') {
+                this.closeView();
+                return;
+            }
+            else if (c === '\x04') {
+                this.close();
+                return;
+            }
+            else if (c.toLowerCase() === 'r' && this.viewRefresh && !this.viewRefreshing) {
+                this.viewRefreshing = true;
+                const view = this.viewResolve;
+                void this.viewRefresh()
+                    .then((lines) => { if (this.viewResolve === view)
+                    this.updateView(lines); })
+                    .catch(() => { if (this.viewResolve === view)
+                    this.updateView(['Usage unavailable — r to retry']); })
+                    .finally(() => { if (this.viewResolve === view)
+                    this.viewRefreshing = false; });
+            }
+        }
+    }
+    /** Select-mode keys: ↑/↓ (and j/k) move, Enter confirms, Ctrl+C cancels. */
+    handleSelect(chars) {
+        for (const c of chars) {
+            if (this.selectEsc) {
+                if (this.selectEscapeTimer)
+                    clearTimeout(this.selectEscapeTimer);
+                this.selectEscapeTimer = null;
+                this.selectEsc += c;
+                if (this.selectEsc === '\x1b[A') {
+                    this.selectMove(-1);
+                    this.selectEsc = '';
+                }
+                else if (this.selectEsc === '\x1b[B') {
+                    this.selectMove(1);
+                    this.selectEsc = '';
+                }
+                else if (!this.selectEsc.startsWith('\x1b[') || this.selectEsc.length > 3) {
+                    this.selectEsc = ''; // stray escape — ignore
+                }
+                continue;
+            }
+            if (c === '\x1b') {
+                this.selectEsc = c;
+                this.selectEscapeTimer = setTimeout(() => this.selectFinish(null), 100);
+                continue;
+            }
+            if (c === '\r' || c === '\n') {
+                this.selectFinish(this.selectIndex);
+                return;
+            }
+            if (c === '\x03' || c === '\x04') {
+                this.selectFinish(null);
+                return;
+            }
+            if (c === 'j' || c === 'J')
+                this.selectMove(1);
+            else if (c === 'k' || c === 'K')
+                this.selectMove(-1);
+            // other keys are ignored while the menu is open
+        }
+    }
+    selectMove(delta) {
+        if (this.selectItems === null)
+            return;
+        const n = this.selectItems.length;
+        this.selectIndex = Math.max(0, Math.min(n - 1, this.selectIndex + delta));
+        this.renderMenu();
+    }
+    selectFinish(result) {
+        const resolve = this.selectResolve;
+        const n = this.selectItems?.length ?? 0;
+        this.selectResolve = null;
+        this.selectItems = null;
+        this.selectEsc = '';
+        this.selectIndex = 0;
+        this.selectTop = 0;
+        if (this.selectEscapeTimer)
+            clearTimeout(this.selectEscapeTimer);
+        this.selectEscapeTimer = null;
+        if (this.dockMenu)
+            ui.closeMenu();
+        if (this.menuShown && !this.dockMenu && n > 0) {
+            const total = Math.min(n, MENU_HEIGHT) + 1; // items + hint line
+            process.stdout.write(`\x1b[${total}A\r\x1b[J`); // erase the menu in place
+        }
+        this.menuShown = false;
+        this.dockMenu = false;
+        // Restore the draft that was live before the picker opened, so a menu never
+        // cancels what you were typing.
+        if (this.selectDraft) {
+            this.buffer = this.selectDraft.buffer;
+            this.cursor = this.selectDraft.cursor;
+            this.histIndex = this.selectDraft.histIndex;
+            this.selectDraft = null;
+            this.redraw();
+        }
+        resolve?.(result);
+    }
+    /** Draw the menu; re-renders in place by rewinding `total` lines when already shown. */
+    renderMenu() {
+        if (this.selectItems === null)
+            return;
+        const n = this.selectItems.length;
+        if (ui.menu(this.selectItems, this.selectIndex, this.selectTop, () => this.selectFinish(null))) {
+            this.dockMenu = true;
+            this.menuShown = true;
+            return;
+        }
+        const height = Math.min(n, MENU_HEIGHT);
+        if (this.selectIndex < this.selectTop)
+            this.selectTop = this.selectIndex;
+        if (this.selectIndex >= this.selectTop + height)
+            this.selectTop = this.selectIndex - height + 1;
+        const total = height + 1;
+        if (this.menuShown)
+            process.stdout.write(`\x1b[${total}A`);
+        for (let i = 0; i < height; i++) {
+            process.stdout.write('\r\x1b[K' + this.renderMenuItem(this.selectTop + i) + '\n');
+        }
+        process.stdout.write('\r\x1b[K' + dim(`↑/↓ move · enter select · ctrl+c cancel  (${n} options)`) + '\n');
+        this.menuShown = true;
+    }
+    renderMenuItem(i) {
+        const label = this.selectItems[i];
+        return i === this.selectIndex ? `${orange('›')} ${bold(label)}` : `${dim('  ' + label)}`;
+    }
+    /** Enter reverse history search; the draft is saved so Esc restores it untouched. */
+    searchStart() {
+        if (!this.history.length || this.questionResolve)
+            return;
+        this.searchDraft = { buffer: this.buffer, cursor: this.cursor, histIndex: this.histIndex };
+        this.searching = true;
+        this.searchQuery = '';
+        this.searchRecompute();
+        this.searchPos = Math.max(0, this.searchMatches.length - 1);
+        this.searchApply();
+    }
+    searchRecompute() {
+        const query = this.searchQuery.toLowerCase();
+        this.searchMatches = [];
+        for (let index = 0; index < this.history.length; index++) {
+            if (!query || this.history[index].toLowerCase().includes(query))
+                this.searchMatches.push(index);
+        }
+    }
+    /** Walk the matching history: -1 is older (Ctrl+R/↑), +1 newer (↓). */
+    searchMove(delta) {
+        if (!this.searchMatches.length)
+            return;
+        const next = Math.max(0, Math.min(this.searchMatches.length - 1, this.searchPos + delta));
+        if (next === this.searchPos)
+            return;
+        this.searchPos = next;
+        this.searchApply();
+    }
+    searchApply() {
+        const match = this.searchMatches[this.searchPos];
+        if (match !== undefined && this.history[match] !== undefined)
+            this.setLine(this.history[match]);
+        this.renderSearch();
+        this.redraw();
+    }
+    searchAppend(char) {
+        this.searchQuery += char;
+        this.searchRecompute();
+        this.searchPos = Math.max(0, this.searchMatches.length - 1);
+        this.searchApply();
+    }
+    searchBackspace() {
+        this.searchQuery = this.searchQuery.slice(0, -1);
+        this.searchRecompute();
+        this.searchPos = Math.max(0, this.searchMatches.length - 1);
+        this.searchApply();
+    }
+    /** Keep the matched history line as the draft (press Enter again to submit). */
+    searchAccept() {
+        const found = this.searchMatches.length > 0;
+        this.searching = false;
+        this.searchMatches = [];
+        this.searchQuery = '';
+        if (this.selectEscapeTimer)
+            clearTimeout(this.selectEscapeTimer);
+        this.selectEscapeTimer = null;
+        this.esc = '';
+        ui.clearSearch();
+        if (found) {
+            this.cursor = this.buffer.length;
+        }
+        else if (this.searchDraft) {
+            this.buffer = this.searchDraft.buffer;
+            this.cursor = this.searchDraft.cursor;
+        }
+        this.searchDraft = null;
+        this.redraw();
+    }
+    /** Restore the exact pre-search draft and close the search row. */
+    searchCancel() {
+        if (!this.searching)
+            return;
+        this.searching = false;
+        if (this.selectEscapeTimer)
+            clearTimeout(this.selectEscapeTimer);
+        this.selectEscapeTimer = null;
+        this.esc = '';
+        this.searchMatches = [];
+        this.searchQuery = '';
+        if (this.searchDraft) {
+            this.buffer = this.searchDraft.buffer;
+            this.cursor = this.searchDraft.cursor;
+            this.histIndex = this.searchDraft.histIndex;
+        }
+        this.searchDraft = null;
+        ui.clearSearch();
+        this.redraw();
+    }
+    renderSearch() {
+        if (!this.searching)
+            return;
+        const total = this.searchMatches.length;
+        if (!total) {
+            ui.setSearch(this.searchQuery, this.buffer, 0, 0);
+            return;
+        }
+        const match = this.history[this.searchMatches[this.searchPos]] ?? '';
+        ui.setSearch(this.searchQuery, match, total - this.searchPos, total); // newest-first rank
+    }
+    /** Search-mode keys run here; everything else (paste/panels) is intentionally bypassed. */
+    handleSearch(chars, i) {
+        const c = chars[i];
+        if (this.esc) {
+            if (this.selectEscapeTimer) {
+                clearTimeout(this.selectEscapeTimer);
+                this.selectEscapeTimer = null;
+            }
+            this.esc += c;
+            if (this.escIsComplete()) {
+                const sequence = this.esc;
+                this.esc = '';
+                if (sequence === '\x1b[A')
+                    this.searchMove(-1);
+                else if (sequence === '\x1b[B')
+                    this.searchMove(1);
+                // other sequences are ignored while searching
+            }
+            return i + 1;
+        }
+        if (c === '\x1b') {
+            this.esc = c;
+            this.selectEscapeTimer = setTimeout(() => { this.esc = ''; this.searchCancel(); }, 100);
+            return i + 1;
+        }
+        if (c === '\x12') {
+            this.searchMove(-1);
+            return i + 1;
+        }
+        if (c === '\r' || c === '\n') {
+            this.searchAccept();
+            return chars.length;
+        }
+        if (c === '\x03' || c === '\x04') {
+            this.searchCancel();
+            return chars.length;
+        }
+        if (c === '\x7f' || c === '\b') {
+            this.searchBackspace();
+            return i + 1;
+        }
+        if (c >= ' ') {
+            this.searchAppend(c);
+            return i + 1;
+        }
+        return i + 1;
+    }
+}