@yjjeong/omg 0.1.0

package/dist/ui/components/CommandInput.js

@@ -0,0 +1,994 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { Box, Text, useApp, useCursor, useInput, useStdin } from "ink";
+import stringWidth from "string-width";
+import { sendCancel, sendInput, sendQuit, sendSlashCommand, } from "../outbound.js";
+import { theme } from "../theme.js";
+import { activeMention, expandFileMentions, extractImageMentions, scanDir, } from "../fileMentions.js";
+import { captureClipboardImage } from "../../core/util/clipboardImage.js";
+import { FileSuggest } from "./FileSuggest.js";
+import { matchSlash, renderHelp } from "../slashCatalog.js";
+import { SlashPalette } from "./SlashPalette.js";
+import { appendInputHistory, loadInputHistory } from "../inputHistory.js";
+import { useLineEditor } from "../hooks/useLineEditor.js";
+import { isMouseSequence } from "../mouse.js";
+// Phase 65: the slash catalog (src/ui/slashCatalog.ts) is the single
+// source of truth for available command names + their descriptions.
+// Phase 135: a paste this big (lines OR chars) collapses to a chip.
+const PASTE_MIN_LINES = 4;
+const PASTE_MIN_CHARS = 300;
+const PROMPT_COLS = 2;
+const MAX_INPUT_VISIBLE_LINES = 6;
+export function absoluteElementOrigin(node) {
+    let x = 0;
+    let y = 0;
+    let cur = node;
+    while (cur) {
+        x += cur.yogaNode?.getComputedLeft() ?? 0;
+        y += cur.yogaNode?.getComputedTop() ?? 0;
+        cur = cur.parentNode;
+    }
+    return { x, y };
+}
+export function inputCursorColumn(leftOfCursor) {
+    return PROMPT_COLS + stringWidth(leftOfCursor);
+}
+export function inputViewportStart(totalLines, cursorLine, maxVisibleLines = MAX_INPUT_VISIBLE_LINES) {
+    if (totalLines <= maxVisibleLines)
+        return 0;
+    const maxStart = Math.max(0, totalLines - maxVisibleLines);
+    return Math.max(0, Math.min(cursorLine - maxVisibleLines + 1, maxStart));
+}
+export function shouldShowInputHardwareCursor(buffer, suppressCursorWhenEmpty = false, suppressHardwareCursor = false) {
+    // Phase 277: compose protection. Once there is text in the buffer the
+    // user may be mid-IME-composition, and any hide drops the macOS
+    // Hangul compose preview to the bottom of the screen. So never hide
+    // the cursor while the buffer is non-empty — a 1-frame stale position
+    // during a layout settle is invisible next to a bounced compose box.
+    // The layout-settle hide (suppressHardwareCursor) and the
+    // hide-while-empty path only apply to the empty input, where there is
+    // nothing to compose.
+    if (buffer.length > 0)
+        return true;
+    if (suppressHardwareCursor)
+        return false;
+    return !suppressCursorWhenEmpty;
+}
+export function inputHardwareCursorPosition(origin, column, visibleLine, fullscreenCursorMode = false) {
+    // Ink's log-update normally renders `output + "\n"`, leaving the
+    // terminal cursor on the row just below the visible output. Its
+    // buildCursorSuffix therefore uses `visibleLineCount - y`.
+    //
+    // In fullscreen mode Ink deliberately renders `output` without the
+    // trailing newline, so the terminal cursor starts on the last visible
+    // row instead. Without this +1, every hardware cursor target appears
+    // one row above the measured Yoga origin in the alternate screen.
+    return {
+        x: origin.x + column,
+        y: origin.y + visibleLine + (fullscreenCursorMode ? 1 : 0),
+    };
+}
+// Phase 289: macOS 2-set (두벌식) Hangul keyboard. When a Korean input
+// source is active, a held Ctrl still arrives with key.ctrl set, but
+// `input` is the jamo the physical key produces in the Korean layout
+// (Ctrl+P → "ㅔ", Ctrl+O → "ㅐ", Ctrl+N → "ㅜ") rather than the Latin
+// letter. So every `input === "p"` shortcut check silently fails and
+// tab-switch / search / undo die under a Korean source. Evidence
+// (OMG_DEBUG_KEYS): Ctrl+P → input="ㅔ" hex=[e3 85 94] flags=[ctrl].
+// Map each jamo back to its QWERTY base key so the existing ctrl-letter
+// bindings work regardless of the active input source.
+const HANGUL_CTRL_TO_QWERTY = {
+    "ㅂ": "q", "ㅈ": "w", "ㄷ": "e", "ㄱ": "r", "ㅅ": "t",
+    "ㅛ": "y", "ㅕ": "u", "ㅑ": "i", "ㅐ": "o", "ㅔ": "p",
+    "ㅁ": "a", "ㄴ": "s", "ㅇ": "d", "ㄹ": "f", "ㅎ": "g",
+    "ㅗ": "h", "ㅓ": "j", "ㅏ": "k", "ㅣ": "l",
+    "ㅋ": "z", "ㅌ": "x", "ㅊ": "c", "ㅍ": "v", "ㅠ": "b",
+    "ㅜ": "n", "ㅡ": "m",
+};
+/** Phase 289: when Ctrl is held, fold a 두벌식 Hangul jamo back to the
+ *  Latin key that physically produced it so ctrl-letter shortcuts match.
+ *  Only rewrites while `ctrl` is true — a bare jamo is intended text. */
+export function normalizeCtrlInput(input, ctrl) {
+    if (!ctrl)
+        return input;
+    return HANGUL_CTRL_TO_QWERTY[input] ?? input;
+}
+function paletteFor(value) {
+    if (!value.startsWith("/"))
+        return [];
+    if (value.includes(" "))
+        return [];
+    const prefix = value.slice(1).toLowerCase();
+    return matchSlash(prefix);
+}
+// Phase 39 word boundary helpers. Word = run of alnum/_/. The
+// classic readline behavior: jump over whitespace, then over the
+// word, stopping at the far boundary.
+function isWordChar(ch) {
+    return /[A-Za-z0-9_]/.test(ch);
+}
+function prevWordIdx(s, idx) {
+    let i = idx;
+    while (i > 0 && !isWordChar(s[i - 1]))
+        i--;
+    while (i > 0 && isWordChar(s[i - 1]))
+        i--;
+    return i;
+}
+function nextWordIdx(s, idx) {
+    let i = idx;
+    while (i < s.length && !isWordChar(s[i]))
+        i++;
+    while (i < s.length && isWordChar(s[i]))
+        i++;
+    return i;
+}
+function startOfLine(s, idx) {
+    const nl = s.lastIndexOf("\n", Math.max(0, idx - 1));
+    return nl === -1 ? 0 : nl + 1;
+}
+function endOfLine(s, idx) {
+    const nl = s.indexOf("\n", idx);
+    return nl === -1 ? s.length : nl;
+}
+const CSI_ARROW_MODIFIER_RE = /^\x1b\[1;(\d+)([CD])$/;
+const MODIFIED_ARROW_DIRECTION = {
+    D: "left",
+    C: "right",
+};
+function arrowModifier(rawInput, direction) {
+    const match = CSI_ARROW_MODIFIER_RE.exec(rawInput);
+    if (!match)
+        return null;
+    if (MODIFIED_ARROW_DIRECTION[match[2]] !== direction)
+        return null;
+    return Number(match[1]);
+}
+function isWordArrowSequence(rawInput, direction) {
+    const modifier = arrowModifier(rawInput, direction);
+    // xterm modifier values: 3/4 = Alt(+Shift), 5/6 = Ctrl(+Shift),
+    // 7/8 = Ctrl+Alt(+Shift). All are readline-style word movement.
+    return modifier !== null && modifier >= 3 && modifier <= 8;
+}
+function isLineArrowSequence(rawInput, direction) {
+    const modifier = arrowModifier(rawInput, direction);
+    // macOS terminals commonly encode Cmd+Arrow as CSI 1;9C/D (with
+    // adjacent shifted/control-combined variants). Kitty exposes Cmd as
+    // key.super; this raw CSI fallback covers terminals that only report
+    // a meta-modified arrow to Ink's parser.
+    return (modifier !== null &&
+        ((modifier >= 9 && modifier <= 16) || modifier === 17 || modifier === 18));
+}
+// Phase 63: vertical cursor motion inside a multi-line buffer.
+//
+// Move up: jump to the previous line, preserving the visual column.
+// Returns -1 if the cursor is already on the first line (caller falls
+// back to history).
+function lineUpIdx(s, idx) {
+    const lineStart = startOfLine(s, idx);
+    if (lineStart === 0)
+        return -1;
+    const col = idx - lineStart;
+    const prevLineEnd = lineStart - 1; // the '\n' itself
+    const prevLineStart = startOfLine(s, prevLineEnd);
+    const prevLineLen = prevLineEnd - prevLineStart;
+    return prevLineStart + Math.min(col, prevLineLen);
+}
+function lineDownIdx(s, idx) {
+    const lineEnd = endOfLine(s, idx);
+    if (lineEnd === s.length)
+        return -1;
+    const lineStart = startOfLine(s, idx);
+    const col = idx - lineStart;
+    const nextLineStart = lineEnd + 1;
+    const nextLineEnd = endOfLine(s, nextLineStart);
+    const nextLineLen = nextLineEnd - nextLineStart;
+    return nextLineStart + Math.min(col, nextLineLen);
+}
+// Phase 39: full-fledged line editor.
+//
+// Keys:
+//   printable          → insert at cursor; multi-char input from a
+//                        terminal paste lands as one chunk
+//   Enter              → submit, unless trailing `\` or Shift/Alt+Enter
+//                        (then insert newline)
+//   Backspace / Delete → delete char before / at cursor
+//   ←  / →             → move cursor by one char
+//   Home / End         → cursor to start / end of line
+//   Cmd-← / Cmd-→      → cursor to start / end of line where supported
+//   Opt-←  / Opt-→     → move cursor by one word (ESC b / ESC f bytes)
+//   Ctrl-A / Ctrl-E    → cursor to start / end of line
+//   Ctrl-W             → delete previous word
+//   Ctrl-U             → delete from start of line to cursor
+//   Ctrl-K             → delete from cursor to end of line
+//   ↑ / ↓              → history navigation (single-line buffer only)
+//   Tab                → autocomplete first slash suggestion
+//   Ctrl-C             → quit
+//   Esc                → cancel the in-flight stream
+export function CommandInput({ onLocalLine, onClearEvents, onToggleThink, cwd, onSetTheme, onToggleVerbose, onToggleReasoning, onUserMessage, prediction, suppressCursorWhenEmpty, suppressHardwareCursor, fullscreenCursorMode, }) {
+    // Phase 205: editor core (buffer/cursor/undo/paste) lives in a hook.
+    // History navigation, palette, mention popup, and search remain here
+    // because they're intertwined with rendering and external IO.
+    const editor = useLineEditor();
+    const { buffer, cursor } = editor;
+    const { exit } = useApp();
+    const { internal_eventEmitter: inputEmitter } = useStdin();
+    const rawInputRef = useRef("");
+    useEffect(() => {
+        const captureRawInput = (input) => {
+            rawInputRef.current = input;
+        };
+        // Capture Ink's unparsed event before `useInput` strips ESC and
+        // collapses several CSI modifier variants into the same key shape.
+        // This is what lets us distinguish Cmd+Arrow (line movement) from
+        // Opt/Ctrl+Arrow (word movement) across macOS terminals.
+        inputEmitter.on("input", captureRawInput);
+        return () => {
+            inputEmitter.removeListener("input", captureRawInput);
+        };
+    }, [inputEmitter]);
+    const historyRef = useRef([]);
+    const [historyIdx, setHistoryIdx] = useState(-1);
+    const draftRef = useRef("");
+    // Phase 114: seed the in-memory ring from persisted history once, so
+    // ↑/↓ recall and ghost suggestions span sessions.
+    const historyLoadedRef = useRef(false);
+    if (!historyLoadedRef.current) {
+        historyLoadedRef.current = true;
+        // Don't touch the real ~/.omg history file under the test runner.
+        if (!process.env.VITEST) {
+            try {
+                historyRef.current = loadInputHistory();
+            }
+            catch {
+                /* non-persisted fallback */
+            }
+        }
+    }
+    // Phase 125: Ctrl-R reverse history search. `null` when inactive;
+    // otherwise the live query + which match (0 = most recent) is shown.
+    const [search, setSearch] = useState(null);
+    const reverseMatches = (q) => {
+        const hist = historyRef.current;
+        const seen = new Set();
+        const res = [];
+        for (let i = hist.length - 1; i >= 0; i--) {
+            const h = hist[i];
+            if ((q === "" || h.includes(q)) && !seen.has(h)) {
+                seen.add(h);
+                res.push(h);
+            }
+        }
+        return res;
+    };
+    // Phase 135 + 126 + paste store now belong to `editor` (Phase 205).
+    const palette = useMemo(() => paletteFor(buffer), [buffer]);
+    const [paletteSel, setPaletteSel] = useState(0);
+    const paletteOpen = palette.length > 0;
+    useEffect(() => {
+        if (paletteSel >= palette.length)
+            setPaletteSel(0);
+    }, [palette.length, paletteSel]);
+    const acceptPalette = () => {
+        if (!paletteOpen)
+            return false;
+        const choice = palette[paletteSel];
+        if (!choice)
+            return false;
+        const filled = "/" + choice.name + (choice.args ? " " : "");
+        setBufAndCursor(filled, filled.length);
+        return true;
+    };
+    const isMultiLine = buffer.includes("\n");
+    // Phase 186: ghost is now ONLY the model-predicted next message on
+    // an empty prompt (opt-in /predict). The fish-style history-prefix
+    // autosuggestion that used to fill mid-buffer was confusing — it
+    // ghosted the user's own past lines, which they rarely wanted
+    // re-suggested. ↑/↓ history recall is unchanged.
+    const ghostMatch = useMemo(() => {
+        if (buffer)
+            return "";
+        if (isMultiLine || historyIdx !== -1 || cursor !== 0)
+            return "";
+        return prediction ?? "";
+    }, [buffer, cursor, isMultiLine, historyIdx, prediction]);
+    // Phase 64: @file autocomplete. When the cursor sits inside an
+    // `@<token>`, scan the active tab's cwd and show a popup. Selection
+    // index is owned here; arrow keys cycle, Tab/Enter accept, Esc
+    // closes.
+    const mention = useMemo(() => activeMention(buffer, cursor), [buffer, cursor]);
+    const fileSuggestions = useMemo(() => {
+        if (!mention)
+            return [];
+        return scanDir(cwd ?? process.cwd(), mention.query);
+    }, [mention, cwd]);
+    const [mentionSel, setMentionSel] = useState(0);
+    // Set to the mention's `start` when the user dismisses the popup
+    // with Esc, so the popup stays hidden until they move away from
+    // that mention. Comparing by `start` index means a fresh `@` later
+    // in the buffer still opens its own popup.
+    const [dismissedStart, setDismissedStart] = useState(null);
+    const popupOpen = fileSuggestions.length > 0 &&
+        (mention?.start ?? -1) !== (dismissedStart ?? -2);
+    // Clamp selection when the candidate set shrinks under us.
+    useEffect(() => {
+        if (mentionSel >= fileSuggestions.length)
+            setMentionSel(0);
+    }, [fileSuggestions.length, mentionSel]);
+    // Phase 113/116: the ghost only shows when no slash palette / @file
+    // popup is claiming the completion. Gating here (rather than on the
+    // raw prefix) means `/team <prior prompt>` and `!cmd` still get a
+    // history ghost once the palette/popup has closed.
+    const ghostSuffix = paletteOpen || popupOpen || search ? "" : ghostMatch;
+    const acceptGhost = () => {
+        if (!ghostSuffix)
+            return false;
+        const next = buffer + ghostSuffix;
+        setBufAndCursor(next, next.length);
+        return true;
+    };
+    const acceptMention = () => {
+        if (!mention || !popupOpen)
+            return false;
+        const choice = fileSuggestions[mentionSel];
+        if (!choice)
+            return false;
+        // Replace the mention's body (everything after `@`) with the
+        // selected path. For directories we leave the trailing `/` so
+        // the user can keep typing into them; for files we add a single
+        // trailing space so the mention is "done".
+        const before = buffer.slice(0, mention.start + 1); // include `@`
+        const after = buffer.slice(mention.end);
+        const inserted = choice.display + (choice.isDir ? "" : " ");
+        const next = before + inserted + after;
+        const nextCursor = before.length + inserted.length;
+        setBufAndCursor(next, nextCursor);
+        setMentionSel(0);
+        return true;
+    };
+    const setBufAndCursor = editor.setBuffer;
+    const setCursor = editor.setCursor;
+    // Phase 205: `insertAt` keeps the history-draft tie-in (any keystroke
+    // while scrolled into history snaps back to a fresh draft). The
+    // editor returns the new buffer so we don't have to wait a render
+    // for the state to settle.
+    const insertAt = (text) => {
+        const next = editor.insert(text);
+        if (historyIdx !== -1) {
+            setHistoryIdx(-1);
+            draftRef.current = next;
+        }
+    };
+    const deleteRange = editor.deleteRange;
+    const pushHistory = (entry) => {
+        const hist = historyRef.current;
+        if (hist.length > 0 && hist[hist.length - 1] === entry)
+            return;
+        hist.push(entry);
+        if (hist.length > 500)
+            hist.shift();
+        // Phase 114: persist so the entry survives into the next session.
+        // Skipped under the test runner so suites don't write to the real
+        // ~/.omg history file.
+        if (!process.env.VITEST)
+            appendInputHistory(entry);
+    };
+    const handleSlash = (trimmed) => {
+        if (!trimmed.startsWith("/"))
+            return false;
+        const [head, ...rest] = trimmed.slice(1).split(" ");
+        const name = head ?? "";
+        const args = rest.join(" ");
+        if (name === "quit" || name === "q") {
+            sendQuit();
+            exit();
+            return true;
+        }
+        if (name === "help" || name === "?") {
+            onLocalLine?.(renderHelp());
+            return true;
+        }
+        if (name === "clear") {
+            onClearEvents?.();
+            sendSlashCommand(name, args);
+            return true;
+        }
+        if (name === "reset") {
+            onClearEvents?.();
+            sendSlashCommand(name, args);
+            return true;
+        }
+        if (name === "theme") {
+            // Phase 81: UI-only toggle. cli.ts never sees this slash.
+            const arg = args.trim().toLowerCase();
+            const next = arg === "light"
+                ? "light"
+                : arg === "dark"
+                    ? "dark"
+                    : // No arg = toggle. Default state is dark; pressing once
+                        // flips to light.
+                        "light";
+            onSetTheme?.(next);
+            onLocalLine?.(`[theme] ${next}`);
+            return true;
+        }
+        if (name === "think") {
+            const arg = args.trim().toLowerCase();
+            const force = arg === "on" || arg === "true" || arg === "1"
+                ? true
+                : arg === "off" || arg === "false" || arg === "0"
+                    ? false
+                    : undefined;
+            onToggleThink?.(force);
+            return true;
+        }
+        if (name === "verbose") {
+            // Phase 101: UI-only — full tool-card output, no collapse.
+            const arg = args.trim().toLowerCase();
+            const force = arg === "on" || arg === "true" || arg === "1"
+                ? true
+                : arg === "off" || arg === "false" || arg === "0"
+                    ? false
+                    : undefined;
+            onToggleVerbose?.(force);
+            return true;
+        }
+        if (name === "reasoning") {
+            // Phase 308: UI-only — expand reasoning/thinking inline (live
+            // progress), independent of /verbose.
+            const arg = args.trim().toLowerCase();
+            const force = arg === "on" || arg === "true" || arg === "1"
+                ? true
+                : arg === "off" || arg === "false" || arg === "0"
+                    ? false
+                    : undefined;
+            onToggleReasoning?.(force);
+            return true;
+        }
+        sendSlashCommand(name, args);
+        return true;
+    };
+    const submit = () => {
+        const trimmed = buffer.trim();
+        // Phase 135: capture the paste-expanded form before the store is
+        // cleared by editor.reset().
+        const trimmedExpanded = editor.expandPastes(trimmed);
+        editor.reset();
+        setHistoryIdx(-1);
+        draftRef.current = "";
+        if (!trimmed)
+            return;
+        pushHistory(trimmed);
+        // Phase 83: claude-code-style shell prefix. A leading `!` routes
+        // the rest of the line to /sh — the cli runs it against the
+        // active tab's cwd, streams output as a tool card, and the
+        // model never sees the input.
+        if (trimmed.startsWith("!")) {
+            // Phase 233: paste chips are expanded before the shell command
+            // is dispatched. Pre-233 a paste in `!cmd` would have stayed as
+            // `[paste#1: N lines]` literally and the shell would have run
+            // the chip text instead of the pasted content.
+            const cmd = editor.expandPastes(trimmed.slice(1)).trim();
+            if (cmd)
+                sendSlashCommand("sh", cmd);
+            return;
+        }
+        // Phase 233: slash commands also need paste expansion. /team and
+        // similar commands take a free-form prompt as their argument; a
+        // pasted block must reach the slash dispatcher as full text, not
+        // the `[paste#N: M lines]` collapsed chip. Pre-233 the chip
+        // stayed literal in slash args, so `/team <pasted prompt>`
+        // forwarded only the chip token to the team adapter and the
+        // model saw nothing useful.
+        if (handleSlash(trimmedExpanded))
+            return;
+        // Phase 115: echo the user's own message into the log first, so
+        // the scrollback reads as a conversation. Uses the paste-expanded
+        // text but keeps @file mentions as raw tokens — the user typed the
+        // paste content themselves and expects to see it in scrollback,
+        // but a `@README.md` should not dump the file body into the log
+        // (Phase 196 refinement of the Phase 115 echo).
+        onUserMessage?.(trimmedExpanded);
+        // Phase 340: pull image attachments BEFORE @file/text handling.
+        //   1) `[image#N]` chips from a clipboard paste → editor.expandImages
+        //      strips the chip tokens and returns their paths.
+        //   2) `@photo.png` mentions → extractImageMentions removes the tokens
+        //      and resolves them to absolute paths (so expandFileMentions below
+        //      never tries to binary-load an image as text).
+        const { text: afterChips, images: chipImages } = editor.expandImages(trimmedExpanded);
+        const { text: afterImageMentions, images: atImages, missing: missingImages, } = extractImageMentions(afterChips, { cwd });
+        const attachments = [...chipImages, ...atImages];
+        if (missingImages.length > 0) {
+            onLocalLine?.(`[image] not found: ${missingImages.join(", ")}`);
+        }
+        if (attachments.length > 0) {
+            onLocalLine?.(`[image] attached ${attachments.length} image${attachments.length === 1 ? "" : "s"}`);
+        }
+        // Phase 55: resolve @path mentions against the active tab's
+        // cwd, not the omg process cwd. With per-tab cwd (Phase 54)
+        // typing `@README.md` should pull the README from whichever
+        // project this tab is rooted in. Paste chips were already spliced
+        // back into `trimmedExpanded` (Phase 135).
+        const { expanded, loaded, failed } = expandFileMentions(afterImageMentions, {
+            cwd,
+        });
+        if (loaded.length > 0) {
+            onLocalLine?.(`[@] loaded ${loaded.length} file${loaded.length === 1 ? "" : "s"}: ${loaded.join(", ")}`);
+        }
+        if (failed.length > 0) {
+            onLocalLine?.(`[@] failed: ${failed.join("; ")}`);
+        }
+        // Phase 340: never send an empty prompt with an image — codex's exec
+        // would fall back to reading (empty) stdin. Give a neutral instruction.
+        const outText = expanded.trim().length === 0 && attachments.length > 0
+            ? "Look at the attached image(s)."
+            : expanded;
+        sendInput(outText, attachments);
+    };
+    useInput((input, key) => {
+        const rawInput = rawInputRef.current;
+        if (isMouseSequence(rawInput) || isMouseSequence(input)) {
+            return;
+        }
+        // Phase 61: opt-in key dump. Set OMG_DEBUG_KEYS=1 and a file at
+        // ~/.omg/keylog.txt records every keystroke with its raw bytes
+        // + ink's parsed flags. Used to diagnose terminal-specific
+        // mismatches (e.g. Warp delivering Opt-N without key.meta).
+        if (process.env.OMG_DEBUG_KEYS) {
+            try {
+                const hex = [...Buffer.from(input, "utf-8")]
+                    .map((b) => b.toString(16).padStart(2, "0"))
+                    .join(" ");
+                const flags = Object.entries(key)
+                    .filter(([, v]) => v)
+                    .map(([k]) => k)
+                    .join(",");
+                process.stderr.write(`[omg-keys] input=${JSON.stringify(input)} hex=[${hex}] flags=[${flags}]\n`);
+            }
+            catch {
+                /* logging must never throw */
+            }
+        }
+        // Phase 289: fold a Korean (2-set) jamo back to its Latin key while
+        // Ctrl is held so the shortcut comparisons below match under a
+        // Hangul input source (Ctrl+P arrives as "ㅔ", not "p").
+        const ck = normalizeCtrlInput(input, key.ctrl);
+        if (key.ctrl && ck === "c") {
+            sendQuit();
+            exit();
+            return;
+        }
+        // ---------------- Ctrl-R reverse history search (Phase 125) ------
+        // Ctrl-R opens the search (or, when already open, steps to the next
+        // older match). While open, typing edits the query, Enter accepts
+        // the current match into the buffer, Esc cancels; any other control
+        // key closes the search and falls through to its normal action.
+        if (key.ctrl && ck === "r") {
+            setSearch((s) => {
+                if (!s)
+                    return { query: "", idx: 0 };
+                const matches = reverseMatches(s.query);
+                const nextIdx = matches.length === 0 ? 0 : Math.min(s.idx + 1, matches.length - 1);
+                return { query: s.query, idx: nextIdx };
+            });
+            return;
+        }
+        if (search) {
+            if (key.return) {
+                const m = reverseMatches(search.query)[search.idx];
+                setSearch(null);
+                if (m)
+                    setBufAndCursor(m, m.length);
+                return;
+            }
+            if (key.escape) {
+                setSearch(null);
+                return;
+            }
+            if (key.backspace || key.delete || input === "\x7f" || input === "\b") {
+                setSearch((s) => (s ? { query: s.query.slice(0, -1), idx: 0 } : s));
+                return;
+            }
+            if (input && !key.ctrl && !key.meta) {
+                setSearch((s) => (s ? { query: s.query + input, idx: 0 } : s));
+                return;
+            }
+            // Unhandled control key — leave search and let it act normally.
+            setSearch(null);
+        }
+        // ---------------- Undo / redo (Phase 126) ----------------------
+        // Ctrl-_ (0x1f) or Ctrl-Z undo; Ctrl-Y redo. (Ctrl-Z may be eaten
+        // by the shell as SIGTSTP in some terminals, so Ctrl-_ is the
+        // reliable binding.)
+        if (input === "\x1f" || (key.ctrl && ck === "z")) {
+            editor.undo();
+            return;
+        }
+        if (key.ctrl && ck === "y") {
+            editor.redo();
+            return;
+        }
+        if (key.escape && input.length <= 1) {
+            // Phase 64: when the @file popup is up, Esc closes it instead
+            // of cancelling the in-flight stream.
+            if (popupOpen && mention) {
+                setDismissedStart(mention.start);
+                return;
+            }
+            // A plain ESC keypress means cancel. Multi-byte ESC sequences
+            // (arrow keys, Opt-letter) still set key.escape, but their
+            // input is longer — those fall through to the matchers below.
+            sendCancel();
+            return;
+        }
+        // ---------------- Tab shortcuts (Phase 49 / 68) ---------------
+        // Ctrl-N → /new (default-named tab on the same provider).
+        // (Ctrl-T would be more "browsery" but macOS PTYs interpret it
+        //  as SIGINFO before ink can see the byte.)
+        if (key.ctrl && ck === "n") {
+            sendSlashCommand("new", "");
+            return;
+        }
+        // Phase 68: cycle keys for users whose terminal eats Opt-N.
+        //   Ctrl-P → previous tab
+        //   Ctrl-O → next tab
+        // The cli's /switch supports the "+1" / "-1" syntax for relative
+        // movement.
+        if (key.ctrl && ck === "p") {
+            sendSlashCommand("switch", "-1");
+            return;
+        }
+        if (key.ctrl && ck === "o") {
+            sendSlashCommand("switch", "+1");
+            return;
+        }
+        // Opt-1 .. Opt-9 → /switch <N>. Terminals send Esc + digit.
+        // Ink surfaces them as key.meta + input=digit on a typical
+        // setup; Warp sometimes delivers the raw two-byte ESC+digit
+        // sequence without setting key.meta. Match both shapes.
+        if (key.meta && /^[1-9]$/.test(input)) {
+            sendSlashCommand("switch", input);
+            return;
+        }
+        if (/^\x1b[1-9]$/.test(input)) {
+            sendSlashCommand("switch", input[1]);
+            return;
+        }
+        // ---------------- Cursor motion -----------------------------
+        // Home / End — terminals often deliver macOS Cmd+← / Cmd+→ as
+        // Home / End while in the alternate screen buffer.
+        if (key.home) {
+            setCursor(startOfLine(buffer, cursor));
+            return;
+        }
+        if (key.end) {
+            setCursor(endOfLine(buffer, cursor));
+            return;
+        }
+        // Kitty keyboard protocol can report Cmd as `super`. Other
+        // terminals encode Cmd+Arrow as CSI 1;9D / CSI 1;9C. Ink's
+        // high-level key object collapses those together with Opt+Arrow,
+        // so use the raw sequence captured above to keep macOS text-field
+        // semantics: Cmd = line boundary, Opt/Ctrl = word boundary.
+        if (key.leftArrow && (key.super || isLineArrowSequence(rawInput, "left"))) {
+            setCursor(startOfLine(buffer, cursor));
+            return;
+        }
+        if (key.rightArrow &&
+            (key.super || isLineArrowSequence(rawInput, "right"))) {
+            setCursor(endOfLine(buffer, cursor));
+            return;
+        }
+        if (key.leftArrow &&
+            (key.ctrl ||
+                isWordArrowSequence(rawInput, "left") ||
+                (key.meta && !key.super))) {
+            setCursor(prevWordIdx(buffer, cursor));
+            return;
+        }
+        if (key.rightArrow &&
+            (key.ctrl ||
+                isWordArrowSequence(rawInput, "right") ||
+                (key.meta && !key.super))) {
+            setCursor(nextWordIdx(buffer, cursor));
+            return;
+        }
+        if (key.leftArrow) {
+            setCursor(Math.max(0, cursor - 1));
+            return;
+        }
+        if (key.rightArrow) {
+            // Phase 113: → at end-of-line accepts the ghost suggestion
+            // (fish-style). Mid-line it just moves the cursor.
+            if (cursor === buffer.length && acceptGhost())
+                return;
+            setCursor(Math.min(buffer.length, cursor + 1));
+            return;
+        }
+        // Option/Alt + ← / →  — terminals send ESC b / ESC f for word
+        // motion. ink usually surfaces them as key.meta + input='b'/'f',
+        // but Warp sometimes delivers the raw two-byte ESC sequence
+        // without setting key.meta. Match both shapes.
+        if ((key.meta && input === "b") || input === "\x1bb") {
+            setCursor(prevWordIdx(buffer, cursor));
+            return;
+        }
+        if ((key.meta && input === "f") || input === "\x1bf") {
+            setCursor(nextWordIdx(buffer, cursor));
+            return;
+        }
+        if (key.ctrl && input === "a") {
+            setCursor(startOfLine(buffer, cursor));
+            return;
+        }
+        if (key.ctrl && input === "e") {
+            setCursor(endOfLine(buffer, cursor));
+            return;
+        }
+        // ---------------- Deletions ---------------------------------
+        if (key.ctrl && input === "w") {
+            deleteRange(prevWordIdx(buffer, cursor), cursor);
+            return;
+        }
+        if (key.ctrl && input === "u") {
+            deleteRange(startOfLine(buffer, cursor), cursor);
+            return;
+        }
+        if (key.ctrl && input === "k") {
+            deleteRange(cursor, endOfLine(buffer, cursor));
+            return;
+        }
+        // Backspace — terminals send a confusing mix:
+        //   0x7F (DEL)             - the traditional unix Backspace byte
+        //   0x08 (BS)              - older terminals + Ctrl-H
+        //   ESC[3~  →  key.delete  - macOS "Delete" key (the smaller one)
+        // Apple keyboards label the larger key "Delete" but it functions
+        // as Backspace, and Warp / a handful of other terminals report
+        // *that* key as key.delete with empty input. The user-visible
+        // intent is unambiguous: delete the char before the cursor. So
+        // we route key.delete to Backspace too. True forward-delete is
+        // surfaced through Ctrl-D below, the standard emacs binding.
+        if (key.backspace ||
+            key.delete ||
+            input === "\x7f" ||
+            input === "\x08" ||
+            (key.ctrl && input === "h")) {
+            if (cursor > 0)
+                deleteRange(cursor - 1, cursor);
+            return;
+        }
+        // Forward-delete — Ctrl-D. Rarely needed in a single-line input
+        // but standard emacs / readline behaviour; cheap to keep.
+        if (key.ctrl && input === "d") {
+            if (cursor < buffer.length)
+                deleteRange(cursor, cursor + 1);
+            return;
+        }
+        // ---------------- @file popup navigation (Phase 64) ----------
+        // When the popup is up, ↑/↓ cycle candidates and Tab/Enter
+        // accepts. This must run before the multi-line ↑/↓ / history
+        // handlers below.
+        if (popupOpen) {
+            if (key.upArrow) {
+                setMentionSel((mentionSel - 1 + fileSuggestions.length) % fileSuggestions.length);
+                return;
+            }
+            if (key.downArrow) {
+                setMentionSel((mentionSel + 1) % fileSuggestions.length);
+                return;
+            }
+            if (key.tab) {
+                if (acceptMention())
+                    return;
+            }
+            // Enter intentionally falls through: if the user typed a full
+            // path the popup may still match it; we don't want to swallow
+            // their submit. The popup closes naturally once submit fires.
+        }
+        // ---------------- Slash palette navigation (Phase 65) ---------
+        // While typing `/<prefix>` the palette shows candidates with
+        // descriptions. ↑/↓ select, Tab/Enter accept. Like the @file
+        // popup we don't hijack Enter — submit still wins if the buffer
+        // already names a valid slash on its own.
+        if (paletteOpen) {
+            if (key.upArrow) {
+                setPaletteSel((paletteSel - 1 + palette.length) % palette.length);
+                return;
+            }
+            if (key.downArrow) {
+                setPaletteSel((paletteSel + 1) % palette.length);
+                return;
+            }
+            if (key.tab) {
+                if (acceptPalette())
+                    return;
+            }
+        }
+        // Phase 186: Tab accepts the predicted-next-message ghost when
+        // the prompt is empty. History cycling was removed alongside the
+        // fish-style autosuggestion.
+        if (key.tab && !popupOpen && !paletteOpen) {
+            if (acceptGhost())
+                return;
+        }
+        // ---------------- Vertical motion / history ----------------
+        // Phase 63: ↑/↓ behave like a real editor inside a multi-line
+        // buffer — move the cursor between lines, preserving column. At
+        // the top/bottom edge, fall through to history navigation so the
+        // single-line UX still works.
+        if (key.upArrow) {
+            if (isMultiLine) {
+                const next = lineUpIdx(buffer, cursor);
+                if (next >= 0) {
+                    setCursor(next);
+                    return;
+                }
+                // Top line — fall through to history.
+            }
+            const hist = historyRef.current;
+            if (hist.length === 0)
+                return;
+            const next = historyIdx === -1 ? hist.length - 1 : Math.max(0, historyIdx - 1);
+            if (historyIdx === -1)
+                draftRef.current = buffer;
+            setHistoryIdx(next);
+            setBufAndCursor(hist[next], hist[next].length);
+            return;
+        }
+        if (key.downArrow) {
+            if (isMultiLine) {
+                const next = lineDownIdx(buffer, cursor);
+                if (next >= 0) {
+                    setCursor(next);
+                    return;
+                }
+                // Bottom line — fall through to history.
+            }
+            if (historyIdx === -1)
+                return;
+            const hist = historyRef.current;
+            const next = historyIdx + 1;
+            if (next >= hist.length) {
+                setHistoryIdx(-1);
+                setBufAndCursor(draftRef.current, draftRef.current.length);
+            }
+            else {
+                setHistoryIdx(next);
+                setBufAndCursor(hist[next], hist[next].length);
+            }
+            return;
+        }
+        // ---------------- Enter -------------------------------------
+        if (key.return) {
+            // Trailing backslash continues the line as a newline.
+            if (buffer.slice(0, cursor).endsWith("\\")) {
+                const next = buffer.slice(0, cursor - 1) + "\n" + buffer.slice(cursor);
+                setBufAndCursor(next, cursor);
+                return;
+            }
+            // Shift/Alt+Enter — explicit newline.
+            if (key.meta || key.shift) {
+                insertAt("\n");
+                return;
+            }
+            submit();
+            return;
+        }
+        // ---------------- Printable input ---------------------------
+        if (input && !key.ctrl && !key.meta) {
+            // Strip bracketed-paste markers if a terminal sent them.
+            // Also strip ESC-prefixed control sequences that fell through
+            // the matchers above (otherwise an unhandled meta-key would
+            // insert its raw ESC byte as literal text).
+            const cleaned = input
+                .replace(/\x1b\[200~/g, "")
+                .replace(/\x1b\[201~/g, "")
+                // Phase 146: terminals separate pasted lines with CR (\r), not
+                // LF. Left in, the \r survives the control-strip below and makes
+                // the cursor jump to column 0 at render, overwriting earlier
+                // lines so only the last shows. Normalize CR / CRLF → LF first
+                // so multi-line pastes become a real multi-line buffer (and the
+                // line count below triggers the paste chip correctly).
+                .replace(/\r\n?/g, "\n")
+                .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "");
+            if (cleaned) {
+                // Phase 135: a big multi-line paste collapses to a chip; the
+                // text is stashed and restored at submit. Small input (typing,
+                // short pastes) inserts as-is.
+                const lineCount = cleaned.split("\n").length;
+                if (lineCount >= PASTE_MIN_LINES || cleaned.length > PASTE_MIN_CHARS) {
+                    insertAt(editor.storePaste(cleaned, lineCount));
+                }
+                else {
+                    insertAt(cleaned);
+                }
+            }
+            else if (/\x1b\[20[01]~/.test(input) || /\x1b\[20[01]~/.test(rawInput ?? "")) {
+                // Phase 340: an EMPTY bracketed paste = a non-text paste (most
+                // often an image on the clipboard — terminals don't deliver image
+                // bytes via the TTY). Probe the OS clipboard; if an image is there,
+                // save it and splice an [image#N] chip. Best-effort + terminal-
+                // dependent (some terminals send nothing at all on image paste);
+                // the @path flow is the guaranteed alternative.
+                const img = captureClipboardImage();
+                if (img) {
+                    insertAt(editor.storeImage(img));
+                    onLocalLine?.("[image] captured from clipboard");
+                }
+            }
+        }
+    });
+    // Render — split the buffer at the cursor boundary. The real
+    // terminal cursor is positioned by Ink's `useCursor`; we no longer
+    // render an inline ▌ glyph here because it overlaps the hardware
+    // cursor during IME composition.
+    const before = buffer.slice(0, cursor);
+    const after = buffer.slice(cursor);
+    const beforeLines = before.split("\n");
+    const afterLines = after.split("\n");
+    // Phase 268/269: Ink 6.7+ exposes a cursor API that handles
+    // trailing-`\n` math and cursor visibility, but its position must be
+    // relative to the Ink output origin and available before Ink's
+    // render commit. `getComputedTop()` is only parent-relative, so
+    // summing the wrapper's ancestor Yoga offsets is what prevents IME
+    // compose from appearing at row 0 when CommandInput itself is nested
+    // below EventLog/Dock/HRule. Column uses `stringWidth` so CJK wide
+    // chars (한글, 漢字) count 2 cols each like the terminal renders them.
+    const wrapperRef = useRef(null);
+    const { setCursorPosition } = useCursor();
+    const [cursorOrigin, setCursorOrigin] = useState(null);
+    // Visible column of the cursor on its line: prompt + display
+    // width of all chars to the left of the cursor on that line.
+    const cursorCol = inputCursorColumn(beforeLines[beforeLines.length - 1]);
+    const showHardwareCursor = shouldShowInputHardwareCursor(buffer, suppressCursorWhenEmpty, suppressHardwareCursor);
+    useLayoutEffect(() => {
+        const node = wrapperRef.current;
+        if (!node) {
+            setCursorOrigin((prev) => (prev === null ? prev : null));
+            return;
+        }
+        const next = absoluteElementOrigin(node);
+        setCursorOrigin((prev) => prev && prev.x === next.x && prev.y === next.y ? prev : next);
+    });
+    // The "cursor line" merges the last line of `before` with the
+    // first line of `after`; surrounding lines render as-is.
+    const renderLines = [];
+    // Lines before the cursor line.
+    for (let i = 0; i < beforeLines.length - 1; i++) {
+        renderLines.push({ kind: "plain", text: beforeLines[i] });
+    }
+    // Cursor line.
+    renderLines.push({
+        kind: "cursor",
+        left: beforeLines[beforeLines.length - 1],
+        right: afterLines[0],
+    });
+    // Lines after the cursor line.
+    for (let i = 1; i < afterLines.length; i++) {
+        renderLines.push({ kind: "plain", text: afterLines[i] });
+    }
+    const cursorLineInBuffer = beforeLines.length - 1;
+    const inputWindowStart = inputViewportStart(renderLines.length, cursorLineInBuffer);
+    const visibleRenderLines = renderLines.slice(inputWindowStart, inputWindowStart + MAX_INPUT_VISIBLE_LINES);
+    const hiddenTop = inputWindowStart > 0;
+    const hiddenBottom = inputWindowStart + visibleRenderLines.length < renderLines.length;
+    const hiddenBottomCount = renderLines.length - inputWindowStart - visibleRenderLines.length;
+    // Lines within the visible input viewport above the cursor's line.
+    const cursorLineWithinInput = (hiddenTop ? 1 : 0) + cursorLineInBuffer - inputWindowStart;
+    setCursorPosition(showHardwareCursor && cursorOrigin
+        ? inputHardwareCursorPosition(cursorOrigin, cursorCol, cursorLineWithinInput, fullscreenCursorMode)
+        : undefined);
+    // Phase 83 / 85: surface shell-prefix mode by recoloring the
+    // prompt arrow magenta (pink) while the buffer leads with `!`.
+    // Red read like an error; magenta reads as "different mode".
+    const shellMode = buffer.startsWith("!");
+    const promptColor = shellMode
+        ? theme.prompt.shellColor
+        : theme.prompt.arrowColor;
+    const promptGlyph = theme.prompt.arrow;
+    return (_jsxs(Box, { flexDirection: "column", children: [popupOpen && (_jsx(FileSuggest, { items: fileSuggestions, selectedIdx: mentionSel })), paletteOpen && _jsx(SlashPalette, { items: palette, selectedIdx: paletteSel }), search && (_jsxs(Box, { children: [_jsxs(Text, { color: theme.hint.color, children: ["(reverse-i-search)`", search.query, "`: "] }), _jsx(Text, { children: reverseMatches(search.query)[search.idx] ?? "" })] })), _jsxs(Box, { flexDirection: "column", ref: wrapperRef, children: [hiddenTop && (_jsx(Box, { children: _jsxs(Text, { color: theme.hint.color, dimColor: true, children: ["  ⋮ ", inputWindowStart, " line", inputWindowStart === 1 ? "" : "s", " above"] }) })), visibleRenderLines.map((row, i) => {
+                        const absoluteLine = inputWindowStart + i;
+                        return (_jsxs(Box, { children: [_jsx(Text, { color: promptColor, children: absoluteLine === 0 ? promptGlyph : "  " }), row.kind === "plain" ? (_jsx(Text, { children: row.text })) : (_jsxs(_Fragment, { children: [_jsx(Text, { children: row.left }), _jsx(Text, { children: row.right }), ghostSuffix && (_jsx(Text, { color: theme.status.labelColor, dimColor: true, children: ghostSuffix }))] }))] }, absoluteLine));
+                    }), hiddenBottom && (_jsx(Box, { children: _jsxs(Text, { color: theme.hint.color, dimColor: true, children: ["  ⋮ ", hiddenBottomCount, " line", hiddenBottomCount === 1 ? "" : "s", " ", "below"] }) }))] }), isMultiLine && (_jsx(Box, { children: _jsxs(Text, { color: theme.hint.color, children: ["  ", "(multi-line \u2014 Enter submits; Shift/Alt+Enter or trailing \\\\ for newline)"] }) })), shellMode && !isMultiLine && (_jsx(Box, { children: _jsxs(Text, { color: theme.prompt.shellColor, children: ["  ", "shell mode \u2014 Enter runs the command in the active tab's cwd, model not invoked"] }) }))] }));
+}
+//# sourceMappingURL=CommandInput.js.map