@pugi/cli 0.1.0-beta.98 → 1.0.0-alpha.1

package/dist/tui/input-box.js

@@ -1,732 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/**
- * REPL input box - Sprint (REPL UX P0 wave 1).
- *
- * Bordered, cursor-aware input box matching the upstream tool / peer CLI
- * aesthetics. Layered upgrade over :
- *
- *  - Top divider (full-width cyan rule) anchors the input below the
- *    main pane and gives the operator a clear visual seam.
- *  - Rounded cyan border wraps the prompt + line + cursor.
- *  - Cursor follows the caret position (left/right arrows + Home/End
- *    reposition without losing the trailing text).
- *  - Single-arrow `›` prompt in brand cyan; dim continuation prompt
- *    `┊` when the input wraps past the available width so the operator
- *    sees that they are still inside one logical line.
- *  - History navigation (↑/↓), slash palette inline suggestion, Esc
- *    cancel, Ctrl+C ×2 exit remain wired identically to .
- *
- * State that belongs in this component:
- *  - `line` (string)            - current buffer
- *  - `cursor` (number)          - caret offset into `line`
- *  - `history` (string[])       - session-local; persistence lands in
- *                                  commit 2 (per-workspace JSONL).
- *  - `historyIndex` (number)    - -1 when not navigating
- *
- * Brand voice gate: no forbidden words. ASCII-only glyphs.
- */
-import { useEffect, useMemo, useRef, useState } from 'react';
-import { Box, Text, useInput, useStdout } from 'ink';
-import { append as appendHistory, read as readHistory, } from '../core/repl/history.js';
-import { applyQuery, currentBrief, cycle, initialSearchState, } from '../core/repl/history-search.js';
-import { SlashPalette, completePalette, filterPalette, } from './slash-palette.js';
-import { EMPTY_KILL_RING, killToLineEnd, killToLineStart, killWordBackward, yankAtCursor, } from '../core/repl/kill-ring.js';
-import { readClipboard } from '../core/repl/clipboard-read.js';
-const CTRL_C_DOUBLE_TAP_MS = 1_000;
-/**
- * BT 8 (the upstream tool parity): Esc-Esc walks the conversation back
- * one turn. 500ms is tight enough that an operator clearing the buffer +
- * later changing their mind does NOT accidentally pop a turn, while
- * still feeling like one motion. Matches the upstream tool's documented
- * double-Esc window.
- */
-const ESCAPE_DOUBLE_TAP_MS = 500;
-/** Width subtracted from the terminal width so the border + padding fit. */
-const FRAME_OVERHEAD_COLUMNS = 4;
-/** Fallback width when ink cannot read stdout (e.g. test harness). */
-const FALLBACK_COLUMNS = 80;
-/** Cursor blink interval (ms). 530ms matches the GNOME / iTerm2 default. */
-const CURSOR_BLINK_MS = 530;
-/**
- * Strip ANSI escape sequences, bracketed-paste markers, and C0 control
- * bytes (except `\n` and `\t`) from clipboard text before splicing it
- * into the buffer. Keystroke input never reaches the input box with
- * escapes (ink filters them), so the buffer assumes printable text +
- * the two whitespace forms we preserve. Clipboard text bypasses ink's
- * filter, so we re-apply the same constraint here to neutralise any
- * escape sequence a hostile or accidental copy might carry into the
- * operator's terminal.
- */
-export function sanitiseClipboardText(raw) {
-    return raw
-        .replace(/\x1b\[200~/g, '')
-        .replace(/\x1b\[201~/g, '')
-        .replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '')
-        .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '')
-        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '');
-}
-export function InputBox(props) {
-    // Seed history from disk on mount so the operator can ↑ to last
-    // session's brief immediately. Memoised so we read the file once per
-    // workspace, not on every render.
-    const seededHistory = useMemo(() => {
-        if (!props.workspaceSlug)
-            return [];
-        const entries = readHistory({
-            home: props.historyHome,
-            workspaceSlug: props.workspaceSlug,
-        });
-        return entries.map((e) => e.brief);
-    }, [props.workspaceSlug, props.historyHome]);
-    const [line, setLine] = useState(props.initial ?? '');
-    const [cursor, setCursor] = useState(props.initial?.length ?? 0);
-    const [history, setHistory] = useState(seededHistory);
-    const [historyIndex, setHistoryIndex] = useState(-1);
-    const [lastCtrlCAt, setLastCtrlCAt] = useState(undefined);
-    // CEO P0 #2 : the upstream tool parity — surface а visible
-    // "Press Ctrl+C again to exit" toast on the first Ctrl+C press so
-    // the operator knows the second press will terminate the REPL.
-    // Auto-clears after CTRL_C_DOUBLE_TAP_MS so it never lingers past
-    // the double-tap window.
-    const [ctrlCToast, setCtrlCToast] = useState(null);
-    const ctrlCToastTimerRef = useRef(null);
-    // BT 8: Esc-Esc walkback double-tap window. Tracks the epoch
-    // ms of the most recent Esc press so the next Esc within
-    // ESCAPE_DOUBLE_TAP_MS triggers the walkback handler instead of
-    // re-clearing the buffer.
-    const [lastEscapeAt, setLastEscapeAt] = useState(undefined);
-    const [cursorVisible, setCursorVisible] = useState(true);
-    // Ctrl+R / Ctrl+S reverse-search mode. Undefined when idle, a
-    // HistorySearchState while the operator is searching.
-    const [search, setSearch] = useState(undefined);
-    // Draft preserved while the operator searches so Esc returns the
-    // pre-search buffer instead of dropping it on the floor.
-    const [draftBeforeSearch, setDraftBeforeSearch] = useState('');
-    // Slash palette state. When the buffer starts with `/` the palette
-    // renders, ↑/↓ selects a row, Tab autocompletes, Enter runs.
-    const [paletteIndex, setPaletteIndex] = useState(0);
-    // Operator-toggled palette suppression. Esc closes the palette
-    // without clearing the buffer (useful for `/help` text dispatch).
-    const [paletteSuppressed, setPaletteSuppressed] = useState(false);
-    // Readline-style kill ring backing Ctrl+U / Ctrl+K / Ctrl+W / Ctrl+Y.
-    const [killRing, setKillRing] = useState(EMPTY_KILL_RING);
-    // Soft counter; bumping forces Ink to re-render the surrounding
-    // panes when Ctrl+L wipes the terminal (the parent React tree is
-    // otherwise stable and would not redraw on a stdout.write alone).
-    const [, setRedrawTick] = useState(0);
-    // Shift+Tab toast — flashed for 2s after a mode cycle so the
-    // operator sees `Mode → acceptEdits` под the input divider. Cleared
-    // by a setTimeout so a quick second Shift+Tab refreshes the toast.
-    const [modeCycleToast, setModeCycleToast] = useState(null);
-    const modeCycleTimerRef = useRef(null);
-    const now = props.now ?? Date.now;
-    const { stdout } = useStdout();
-    const columns = stdout?.columns ?? FALLBACK_COLUMNS;
-    const innerWidth = Math.max(20, columns - FRAME_OVERHEAD_COLUMNS);
-    // Refs mirror the latest committed line + cursor so the async clipboard
-    // paste handler can splice against current values without re-entering
-    // React's setState updater (which strict mode invokes twice and would
-    // double-insert the pasted text). The setState updater pattern used to
-    // capture latest line/cursor (see Codex P2 below) is correct under
-    // single-render mode but broken under React 18 strict mode + the
-    // setLine-inside-setCursor nesting we ended up with. Refs are the
-    // canonical escape hatch for "use the most recently committed value
-    // inside a one-shot async callback".
-    const lineRef = useRef(line);
-    const cursorRef = useRef(cursor);
-    useEffect(() => {
-        lineRef.current = line;
-    }, [line]);
-    useEffect(() => {
-        cursorRef.current = cursor;
-    }, [cursor]);
-    // Soft blink so the operator can spot where typing will land. Ink
-    // re-renders only when state changes, so a 530ms toggle is the cheapest
-    // honest cursor we can show without a custom raw-mode dance. Tests
-    // disable the interval so node:test does not see a dangling timer.
-    const blinkEnabled = props.blinkCursor ?? true;
-    useEffect(() => {
-        if (!blinkEnabled)
-            return undefined;
-        const interval = setInterval(() => {
-            setCursorVisible((prev) => !prev);
-        }, CURSOR_BLINK_MS);
-        return () => clearInterval(interval);
-    }, [blinkEnabled]);
-    useInput((input, key) => {
-        if (key.ctrl && input === 'c') {
-            const t = now();
-            // : the upstream tool-style double-press semantics. First Ctrl+C
-            // ALWAYS attempts to cancel an in-flight dispatch (when the
-            // session reports non-idle); second Ctrl+C within 1s exits the
-            // process. If onCancel is omitted (legacy callers, tests), the
-            // old behaviour is preserved: first Ctrl+C clears the buffer +
-            // arms the exit timer, second Ctrl+C exits.
-            const withinDoubleTapWindow = typeof lastCtrlCAt === 'number' && t - lastCtrlCAt <= CTRL_C_DOUBLE_TAP_MS;
-            if (withinDoubleTapWindow) {
-                // Second press inside the window — always exit. This matches
-                // the upstream tool: even mid-dispatch, the second Ctrl+C wins so
-                // the operator can always escape a stuck REPL.
-                props.onExit();
-                return;
-            }
-            // First press in a fresh window. If the host wired a cancel
-            // surface and there is something to cancel, abort the dispatch.
-            // The buffer is left untouched on a cancel (the operator's
-            // current input is NOT trashed by an accidental Ctrl+C while a
-            // tool is running).
-            //
-            // Three-valued onCancel return (see prop docstring):
-            //  - true      → dispatch cancelled, keep buffer, arm exit timer
-            //  - false     → idle, clear buffer (legacy), arm exit timer
-            //  - undefined → handler bypassed (modal owns input); NO state
-            //                 change at all. Buffer stays, exit timer NOT
-            //                 armed (otherwise the modal would silently
-            //                 promote a Ctrl+C to "press again to exit",
-            //                 which is wrong context for a modal cancel).
-            let cancelResult;
-            if (props.onCancel) {
-                cancelResult = props.onCancel();
-            }
-            if (cancelResult === undefined && props.onCancel) {
-                // Bypass path - modal owns the input. Drop the press silently
-                // so the modal's own cancel surface (Esc / its own Ctrl+C
-                // binding inside the modal component) takes effect on its own
-                // terms. P2 fix: previously this fell through to the
-                // legacy buffer-clear + setLastCtrlCAt path and wiped modal
-                // draft text on first Ctrl+C.
-                return;
-            }
-            setLastCtrlCAt(t);
-            // CEO P0 #2 : surface the "Press Ctrl+C again to
-            // exit" toast on the first press so the operator sees the
-            // double-tap semantics in the UI, not just в the bottom hint
-            // line. Mirrors the standard tool's exit affordance verbatim. The
-            // toast string varies by which branch fired (cancel vs idle
-            // clear) so the operator learns what the press just did:
-            //
-            //  - cancelResult === true → "Aborted. Press Ctrl+C again to exit."
-            //  - cancelResult === false → "Press Ctrl+C again to exit."
-            //
-            // (The undefined branch already returned above — а modal owns
-            // input и the toast is suppressed.)
-            const toastCopy = cancelResult === true
-                ? 'Aborted. Press Ctrl+C again to exit.'
-                : 'Press Ctrl+C again to exit.';
-            setCtrlCToast(toastCopy);
-            if (ctrlCToastTimerRef.current)
-                clearTimeout(ctrlCToastTimerRef.current);
-            ctrlCToastTimerRef.current = setTimeout(() => {
-                setCtrlCToast(null);
-                ctrlCToastTimerRef.current = null;
-            }, CTRL_C_DOUBLE_TAP_MS);
-            // Legacy behaviour: on idle (or no onCancel wired), clear the
-            // buffer + reset search so the operator's screen is calm before
-            // they confirm exit. When we DID cancel a live dispatch, keep
-            // the buffer so a half-typed brief is not lost.
-            if (cancelResult !== true) {
-                setLine('');
-                setCursor(0);
-                setSearch(undefined);
-            }
-            return;
-        }
-        // — the upstream tool parity: Shift+Tab cycles permission mode.
-        // The host owns the cycle logic + persistence; we just intercept
-        // the chord and surface a one-line toast on success. Place this
-        // BEFORE the search-mode and palette branches so a Shift+Tab fires
-        // even while reverse-search is active (operator habit-driven).
-        if (key.shift && key.tab && props.onCyclePermissionMode) {
-            const nextMode = props.onCyclePermissionMode();
-            if (nextMode) {
-                setModeCycleToast(`Mode → ${nextMode}`);
-                if (modeCycleTimerRef.current)
-                    clearTimeout(modeCycleTimerRef.current);
-                modeCycleTimerRef.current = setTimeout(() => {
-                    setModeCycleToast(null);
-                    modeCycleTimerRef.current = null;
-                }, 2_000);
-            }
-            return;
-        }
-        // Search-mode key handling. Ctrl+R / Ctrl+S cycle, Enter accepts,
-        // Esc cancels (restoring the pre-search draft), backspace shortens
-        // the query, typed characters extend it.
-        if (search) {
-            if (key.ctrl && input === 'r') {
-                setSearch((s) => (s ? cycle(s, 1) : s));
-                return;
-            }
-            if (key.ctrl && input === 's') {
-                setSearch((s) => (s ? cycle(s, -1) : s));
-                return;
-            }
-            if (key.escape) {
-                setSearch(undefined);
-                setLine(draftBeforeSearch);
-                setCursor(draftBeforeSearch.length);
-                return;
-            }
-            // Bare LF accepts the focused match, same as CR (`key.return`).
-            // See the post-search block below for the rationale.
-            if (key.return || (input === '\n' && !key.meta && !key.ctrl && !key.shift)) {
-                const picked = currentBrief(search);
-                setSearch(undefined);
-                if (picked !== null) {
-                    setLine(picked);
-                    setCursor(picked.length);
-                }
-                else {
-                    setLine(draftBeforeSearch);
-                    setCursor(draftBeforeSearch.length);
-                }
-                return;
-            }
-            if (key.backspace || key.delete) {
-                const nextQuery = search.query.slice(0, -1);
-                setSearch(applyQuery(search, nextQuery, history));
-                return;
-            }
-            if (input && !key.meta && !key.ctrl) {
-                // Drop a bare LF from the search query — the Enter-accept
-                // branch above already handled it; falling through here would
-                // splice a newline into the search string.
-                if (input === '\n')
-                    return;
-                const nextQuery = search.query + input;
-                setSearch(applyQuery(search, nextQuery, history));
-                return;
-            }
-            // Any other key inside search mode is ignored - the operator can
-            // still escape with Esc or cancel via Ctrl+C handled above.
-            return;
-        }
-        if (key.ctrl && input === 'r') {
-            // Enter reverse-search mode. Stash the current buffer so Esc
-            // restores it untouched.
-            setDraftBeforeSearch(line);
-            setSearch(initialSearchState(history));
-            return;
-        }
-        if (key.ctrl && input === 's') {
-            // Symmetric forward search entry. Cycle direction differs once
-            // active; entry seeds the same browse state.
-            setDraftBeforeSearch(line);
-            setSearch(initialSearchState(history));
-            return;
-        }
-        // P0 fix (CEO dogfood, second iteration): bare LF (`\n`)
-        // MUST submit the brief, same as bare CR (`\r`). Ink's parseKeypress
-        // maps `\r` to `key.return` and `\n` to `key.name === 'enter'`
-        // WITHOUT setting `key.return`. Most real terminals deliver CR for
-        // Enter (ICRNL on by default), so the `key.return` branch below
-        // catches them. But when stdin is a PTY whose parent writes raw
-        // `\n` (Python's `pty.fork` + `os.write(fd, b"\n")`, automation
-        // harnesses, certain SSH multiplexers), the LF arrives as a
-        // printable char.
-        //
-        // PR (beta.45) fixed the case where `input === '\n'` exactly.
-        // CEO PTY smoke surfaced the REAL shape: when the parent
-        // writes the brief AND the Enter as separate `os.write` calls (or
-        // even when it doesn't), Node's stdin buffer COALESCES them into
-        // ONE chunk before Ink delivers the `useInput` event. The repro
-        // confirmed via stderr instrumentation: typing `hi\n` arrives in
-        // input-box as `bytes=[68 69 0a] len=3 flags=-` — a SINGLE 3-char
-        // chunk "hi\n" with no key flags. The PR branch (`input ===
-        // '\n'`) does not match, so `hi\n` falls through to the printable-
-        // char branch and the literal newline lands in the buffer as
-        // `› hi\n █` (multi-line composer, brief never dispatches, status
-        // stays `idle` forever).
-        //
-        // Fix: detect a TRAILING `\n` in a printable chunk with no
-        // modifiers — type the prefix into the buffer, then submit. The
-        // discriminator that keeps multi-line paste working: the chunk
-        // must contain EXACTLY ONE `\n` (the trailing one) and no other
-        // newlines. Multi-line pastes have ≥2 `\n` characters (or arrive
-        // wrapped in bracketed-paste markers handled below), so they
-        // still preserve interior newlines via the printable-char branch.
-        //
-        // Detection contract:
-        //  - `input` ends with `\n`
-        //  - no Ctrl / Meta / Shift modifiers
-        //  - exactly ONE `\n` in the chunk (the trailing one)
-        //  - chunk is not bracketed-paste wrapped (markers stripped below)
-        //
-        // Edge cases covered by `test/input-box-lf-submit.spec.tsx`:
-        //  - bare `\n`                 → submit empty (no-op on empty buf)
-        //  - `hi\n`                    → splice `hi` + submit
-        //  - `hi\nthere\n` (multi-line) → printable branch, preserves \n
-        //  - `\r` (CR)                 → key.return branch unchanged
-        //  - `hi\r\n` (CRLF)           → key.return branch (CR wins first)
-        const endsWithLf = input.length > 0 && input.charCodeAt(input.length - 1) === 0x0a;
-        const newlineCount = (input.match(/\n/g) || []).length;
-        if (endsWithLf
-            && newlineCount === 1
-            && !key.meta
-            && !key.ctrl
-            && !key.shift) {
-            // Splice the prefix (everything before the trailing `\n`) into
-            // the buffer at the cursor, then run the canonical submit path.
-            // Refs (cursorRef / lineRef) hold the latest committed values so
-            // the splice runs against the operator's most recent edits even
-            // if a previous async paste / setState is still mid-flight.
-            const prefix = input.slice(0, -1);
-            let mergedLine = lineRef.current;
-            let mergedCursor = cursorRef.current;
-            if (prefix.length > 0) {
-                // Same sanitisation as the printable-char branch below — strip
-                // bracketed-paste markers so a stray escape sequence never
-                // lands in the submitted brief.
-                const stripped = prefix
-                    .replace(/\x1b\[200~/g, '')
-                    .replace(/\x1b\[201~/g, '')
-                    .replace(/\[200~/g, '')
-                    .replace(/\[201~/g, '');
-                if (stripped.length > 0) {
-                    mergedLine =
-                        mergedLine.slice(0, mergedCursor) + stripped + mergedLine.slice(mergedCursor);
-                    mergedCursor = mergedCursor + stripped.length;
-                }
-            }
-            // Synthesise the same payload-shape the `key.return` branch
-            // below uses so palette completion + history dedup + onSubmit
-            // dispatch all run identically.
-            const paletteHere = !paletteSuppressed
-                ? filterPalette(mergedLine)
-                : { rows: [], totalBeforeLimit: 0 };
-            const paletteOpenHere = paletteHere.rows.length > 0;
-            const paletteFocusedIndexHere = paletteHere.rows.length === 0
-                ? 0
-                : Math.min(paletteIndex, paletteHere.rows.length - 1);
-            let payload = mergedLine;
-            if (paletteOpenHere) {
-                const completed = completePalette(mergedLine, paletteHere.rows, paletteFocusedIndexHere);
-                if (completed !== null)
-                    payload = completed;
-            }
-            const trimmed = payload.trim();
-            if (trimmed.length > 0) {
-                setHistory((prev) => {
-                    if (prev[prev.length - 1] === trimmed)
-                        return prev;
-                    return [...prev, trimmed];
-                });
-                setHistoryIndex(-1);
-                if (props.workspaceSlug) {
-                    appendHistory({
-                        home: props.historyHome,
-                        workspaceSlug: props.workspaceSlug,
-                        brief: trimmed,
-                    });
-                }
-                props.onSubmit(trimmed);
-            }
-            setLine('');
-            setCursor(0);
-            setPaletteSuppressed(false);
-            setPaletteIndex(0);
-            return;
-        }
-        // Readline-style kill ring shortcuts. All four kills push the
-        // removed slice onto the ring; Ctrl+Y yanks the most recent.
-        if (key.ctrl && input === 'u') {
-            const next = killToLineStart(line, cursor, killRing);
-            setLine(next.line);
-            setCursor(next.cursor);
-            setKillRing(next.ring);
-            return;
-        }
-        if (key.ctrl && input === 'k') {
-            const next = killToLineEnd(line, cursor, killRing);
-            setLine(next.line);
-            setCursor(next.cursor);
-            setKillRing(next.ring);
-            return;
-        }
-        if (key.ctrl && input === 'w') {
-            const next = killWordBackward(line, cursor, killRing);
-            setLine(next.line);
-            setCursor(next.cursor);
-            setKillRing(next.ring);
-            return;
-        }
-        if (key.ctrl && input === 'y') {
-            const next = yankAtCursor(line, cursor, killRing);
-            setLine(next.line);
-            setCursor(next.cursor);
-            return;
-        }
-        if (key.ctrl && input === 'l') {
-            // Clear the terminal viewport. ANSI 2J = erase entire screen,
-            // 0;0H = home cursor. We bump the redraw tick so Ink repaints
-            // the surrounding REPL panes on the next frame; without this
-            // ink keeps its diff buffer and we get a half-wiped screen.
-            if (stdout && typeof stdout.write === 'function') {
-                stdout.write('\x1b[2J\x1b[0;0H');
-            }
-            setRedrawTick((t) => t + 1);
-            return;
-        }
-        if (key.ctrl && input === 'v') {
-            // Ctrl+V: read the OS clipboard and insert at cursor. The
-            // platform helper (pbpaste / wl-paste / xclip -o / Get-Clipboard)
-            // is async + best-effort; on failure the buffer is left
-            // untouched and the operator falls back to terminal paste
-            // (Cmd+V on macOS, right-click on Linux).
-            //
-            // Multi-line pastes preserve interior newlines so the operator
-            // sees the full text in the buffer; the Enter-on-buffered-LF
-            // case is left to the operator (they press Enter when ready).
-            //
-            // Refs (lineRef / cursorRef) hold the latest committed values so
-            // the splice runs against the operator's most recent edits even
-            // if they kept typing while pbpaste was in flight. The previous
-            // setLine-inside-setCursor nesting double-inserted under React
-            // 18 strict mode because each setState updater runs twice in
-            // development. Claude P1.
-            //
-            // sanitiseClipboardText strips ANSI escapes, bracketed-paste
-            // markers, and C0 control bytes so a hostile or accidental copy
-            // cannot inject terminal-control sequences. Claude P2.
-            readClipboard()
-                .then((res) => {
-                if (res.text === null)
-                    return;
-                const sanitised = sanitiseClipboardText(res.text);
-                if (sanitised.length === 0)
-                    return;
-                const currentLine = lineRef.current;
-                const currentCursor = cursorRef.current;
-                const newLine = currentLine.slice(0, currentCursor) +
-                    sanitised +
-                    currentLine.slice(currentCursor);
-                const newCursor = currentCursor + sanitised.length;
-                setLine(newLine);
-                setCursor(newCursor);
-            })
-                .catch(() => {
-                // Helper already swallows errors; the catch here is belt +
-                // suspenders so a TypeError never bubbles into the render.
-            });
-            return;
-        }
-        // Compute palette visibility FIRST so Enter can run the focused
-        // palette row instead of submitting a partial `/he` as unknown.
-        // Palette is hidden when the operator pressed Esc on it.
-        const palette = !paletteSuppressed ? filterPalette(line) : { rows: [], totalBeforeLimit: 0 };
-        const paletteOpen = palette.rows.length > 0;
-        const paletteFocusedIndex = palette.rows.length === 0
-            ? 0
-            : Math.min(paletteIndex, palette.rows.length - 1);
-        if (key.return) {
-            // When the palette is open, Enter expands the buffer to the
-            // complete command name (preserving any args past the head)
-            // before submission. Codex review P2.
-            let payload = line;
-            if (paletteOpen) {
-                const completed = completePalette(line, palette.rows, paletteFocusedIndex);
-                if (completed !== null)
-                    payload = completed;
-            }
-            const trimmed = payload.trim();
-            if (trimmed.length > 0) {
-                setHistory((prev) => {
-                    // In-session dedup of consecutive identical entries mirrors
-                    // the on-disk dedup so ↑ never shows duplicates.
-                    if (prev[prev.length - 1] === trimmed)
-                        return prev;
-                    return [...prev, trimmed];
-                });
-                setHistoryIndex(-1);
-                if (props.workspaceSlug) {
-                    // Fire-and-forget. Helper never throws - it returns null
-                    // when storage is unavailable and history degrades to
-                    // session-local for this turn.
-                    appendHistory({
-                        home: props.historyHome,
-                        workspaceSlug: props.workspaceSlug,
-                        brief: trimmed,
-                    });
-                }
-                props.onSubmit(trimmed);
-            }
-            setLine('');
-            setCursor(0);
-            setPaletteSuppressed(false);
-            setPaletteIndex(0);
-            return;
-        }
-        if (key.escape) {
-            if (paletteOpen) {
-                // Close the palette without clearing the buffer so the operator
-                // can still send `/help` as plain text if they want. Palette
-                // takes precedence over walkback because the operator's mental
-                // model is "Esc closes the visible overlay first".
-                setPaletteSuppressed(true);
-                setLastEscapeAt(undefined);
-                return;
-            }
-            // BT 8: Esc-Esc walkback. Two presses within
-            // ESCAPE_DOUBLE_TAP_MS step the conversation back by one turn.
-            // First press still clears the buffer (legacy behaviour for the
-            // single-Esc cancel UX); the second press calls the host's
-            // walkback handler. Buffer-clear on the first press is what makes
-            // the double-tap feel "free" - the operator did not have to
-            // memorise a new chord; they just have to keep pressing.
-            const tEsc = now();
-            const withinEscapeWindow = typeof lastEscapeAt === 'number'
-                && tEsc - lastEscapeAt <= ESCAPE_DOUBLE_TAP_MS;
-            if (withinEscapeWindow && props.onWalkback) {
-                // Second tap inside the window. Buffer was already cleared on
-                // the first press, so the host sees a clean input box AND the
-                // walkback result. We clear the window so a third tap restarts
-                // the cycle (no run-on walkbacks from a stuck Esc key).
-                const verdict = props.onWalkback();
-                setLastEscapeAt(undefined);
-                if (verdict !== 'walked-back') {
-                    // Host refused (dispatch in flight, no turns to pop). The
-                    // host owns the refusal copy via its own writeOutput path;
-                    // we do not double-message here.
-                    return;
-                }
-                return;
-            }
-            // First Esc (or no walkback wired). Arm the window + clear the
-            // buffer per the long-standing single-Esc cancel contract.
-            setLastEscapeAt(tEsc);
-            setLine('');
-            setCursor(0);
-            setHistoryIndex(-1);
-            return;
-        }
-        if (key.tab && paletteOpen) {
-            const completed = completePalette(line, palette.rows, paletteFocusedIndex);
-            if (completed !== null) {
-                setLine(completed);
-                setCursor(completed.length);
-            }
-            return;
-        }
-        if (key.upArrow) {
-            if (paletteOpen) {
-                setPaletteIndex((i) => (palette.rows.length === 0 ? 0 : (i - 1 + palette.rows.length) % palette.rows.length));
-                return;
-            }
-            if (history.length === 0)
-                return;
-            const nextIndex = historyIndex === -1 ? history.length - 1 : Math.max(0, historyIndex - 1);
-            const entry = history[nextIndex] ?? '';
-            setHistoryIndex(nextIndex);
-            setLine(entry);
-            setCursor(entry.length);
-            return;
-        }
-        if (key.downArrow) {
-            if (paletteOpen) {
-                setPaletteIndex((i) => (palette.rows.length === 0 ? 0 : (i + 1) % palette.rows.length));
-                return;
-            }
-            if (history.length === 0)
-                return;
-            if (historyIndex === -1)
-                return;
-            const nextIndex = historyIndex + 1;
-            if (nextIndex >= history.length) {
-                setHistoryIndex(-1);
-                setLine('');
-                setCursor(0);
-                return;
-            }
-            const entry = history[nextIndex] ?? '';
-            setHistoryIndex(nextIndex);
-            setLine(entry);
-            setCursor(entry.length);
-            return;
-        }
-        if (key.leftArrow) {
-            setCursor((c) => Math.max(0, c - 1));
-            return;
-        }
-        if (key.rightArrow) {
-            setCursor((c) => Math.min(line.length, c + 1));
-            return;
-        }
-        if (key.backspace || key.delete) {
-            if (cursor === 0)
-                return;
-            // Read cursor via ref inside the updater so the slice indices come
-            // from the latest committed value, not the closure-captured one.
-            // Same React-18 strict-mode race that bit the Ctrl+V paste path
-            // (Claude P1 on PR wave 1): updaters run twice under strict
-            // mode, and a stale closure `cursor` produces a double-edit on the
-            // second invocation. cursorRef is the canonical fix — do NOT
-            // re-introduce closure `cursor` inside setLine updaters.
-            const cursorAtPress = cursorRef.current;
-            setLine((prev) => prev.slice(0, cursorAtPress - 1) + prev.slice(cursorAtPress));
-            setCursor((c) => Math.max(0, c - 1));
-            // Backspacing past `/` re-opens the palette next render.
-            setPaletteSuppressed(false);
-            setPaletteIndex(0);
-            return;
-        }
-        if (input && !key.meta && !key.ctrl) {
-            // Ink delivers one or more characters per event; concatenate at
-            // the cursor without filtering so non-Latin + emoji sequences
-            // (the operator's own brief copy) survive paste.
-            //
-            // Bracketed-paste mode markers (`ESC[200~ ... ESC[201~`) may
-            // arrive when a modern terminal pastes multi-line text. Strip
-            // them inline so the buffer stays clean; the spec calls out
-            // disabling Enter-as-submit during the burst, but Ink's
-            // useInput delivers the whole paste as one event so the burst
-            // is atomic and Enter cannot fire mid-paste here.
-            //
-            // Ink's escape-sequence parser may consume the leading ESC for
-            // unknown CSI sequences, so we match both forms (with + without
-            // the leading ESC byte) to be safe across terminal emulators.
-            const stripped = input
-                .replace(/\x1b\[200~/g, '')
-                .replace(/\x1b\[201~/g, '')
-                .replace(/\[200~/g, '')
-                .replace(/\[201~/g, '');
-            if (stripped.length === 0)
-                return;
-            // Read cursor via ref inside the updater so the splice indices come
-            // from the latest committed value, not the closure-captured one.
-            // Same React-18 strict-mode race that bit the Ctrl+V paste path
-            // (Claude P1 on PR wave 1): updaters run twice under strict
-            // mode, and a stale closure `cursor` produces a duplicated insert
-            // on the second invocation. cursorRef is the canonical fix — do
-            // NOT re-introduce closure `cursor` inside setLine updaters.
-            const cursorAtPress = cursorRef.current;
-            setLine((prev) => prev.slice(0, cursorAtPress) + stripped + prev.slice(cursorAtPress));
-            setCursor((c) => c + stripped.length);
-            // Typing a new char un-suppresses the palette and resets focus.
-            setPaletteSuppressed(false);
-            setPaletteIndex(0);
-        }
-    });
-    const paletteView = !search && !paletteSuppressed ? filterPalette(line) : { rows: [], totalBeforeLimit: 0 };
-    // Clamp focus to current row count so a shrink (e.g. operator typed
-    // a char that narrowed the list) does not point off-the-end.
-    const clampedPaletteIndex = paletteView.rows.length === 0
-        ? 0
-        : Math.min(paletteIndex, paletteView.rows.length - 1);
-    const divider = '─'.repeat(innerWidth);
-    const focusedMatch = search ? search.matches[search.focusedIndex] : undefined;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "#3da9fc", dimColor: true, children: divider }), _jsx(Box, { paddingX: 1, flexDirection: "column", children: search ? (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", children: '(reverse-i-search) ' }), _jsx(Text, { children: `\`${search.query}\`: ` }), _jsx(Text, { color: "yellow", children: focusedMatch ? focusedMatch.brief : '(no match)' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: `Ctrl+R next · Ctrl+S prev · Enter accept · Esc cancel · ${search.matches.length} match${search.matches.length === 1 ? '' : 'es'}` }) })] })) : (_jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", children: '› ' }), _jsx(Text, { children: renderLineWithCursor(line, cursor, cursorVisible) })] })) }), _jsx(Text, { color: "#3da9fc", dimColor: true, children: divider }), modeCycleToast ? (_jsx(Box, { children: _jsx(Text, { color: "#3da9fc", bold: true, children: ` ${modeCycleToast}` }) })) : null, ctrlCToast ? (_jsx(Box, { children: _jsx(Text, { color: "yellow", bold: true, children: ` ${ctrlCToast}` }) })) : null, line.length > innerWidth - 4 ? (_jsxs(Box, { children: [_jsx(Text, { color: "gray", children: '┊ ' }), _jsx(Text, { dimColor: true, children: 'line wraps - Enter still submits' })] })) : null, _jsx(SlashPalette, { rows: paletteView.rows, focusedIndex: clampedPaletteIndex, totalBeforeLimit: paletteView.totalBeforeLimit }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: '↑/↓ history · Ctrl+R search · / commands · Shift+Tab mode · Enter brief · Esc cancel · Ctrl+C abort / ×2 exit' }) })] }));
-}
-/**
- * Render the line with the cursor glyph inserted at `cursor`. The cursor
- * glyph is an inverted block when visible, a single space when blinked
- * off - keeping the rendered width stable so the surrounding border
- * does not jitter.
- */
-function renderLineWithCursor(line, cursor, visible) {
-    const safeCursor = Math.max(0, Math.min(line.length, cursor));
-    const before = line.slice(0, safeCursor);
-    const after = line.slice(safeCursor);
-    const caret = visible ? '█' : ' ';
-    return `${before}${caret}${after}`;
-}
-//# sourceMappingURL=input-box.js.map