min-agent 0.2.1 → 0.4.0

package/dist/tui/InputBar.js

@@ -1,83 +1,543 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState, useEffect } from "react";
-import { Box, Text, useInput, useStdin } from "ink";
+import { useState, useEffect, useMemo, useRef, useCallback } from "react";
+import { Box, Text, useInput, useStdin, useStdout } from "ink";
+import { setCaretPosition } from "./caret.js";
+import { displayWidth } from "./text-width.js";
+import { visualRows, moveCaretHorizontal, moveCaretVertical, insertAt, backspaceAt, deleteAt, caretIndexFromClick, scanDeleteKeys, scanHomeEndKeys, moveToLineStart, moveToLineEnd, deleteToLineStart, deleteToLineEnd, deleteWordBefore, } from "./caret-pos.js";
+import { searchHistory, loadInputHistory, saveInputHistory, createHistory, pushInput, browseHistory, resetHistory, isCtrlC, clearInputOnCtrlC, EXIT_CTRL_C_WINDOW_MS, } from "./input-history.js";
+import { filterSlashCommands, getSlashArgOptions, applySlashArgCompletion, isKnownSlashCommandInput, } from "./slash-commands.js";
+import { MOUSE_ENABLE, MOUSE_DISABLE } from "./mouse.js";
+import { scanSgrMouse } from "./mouse.js";
+import { TEXT_START_COLUMN, inputTextWidth } from "./layout.js";
+import { theme } from "./theme.js";
+const GUTTER = "❯ ";
+const SHIFT_ENTER_SEQ = "\x1b[13;2u";
+/**
+ * True when `input` looks like the Kitty Shift+Enter sequence
+ * ("[13;2u" — the leading ESC is stripped by Ink) or a fragment of it.
+ * Fragments may arrive split across stdin chunks; they must never be
+ * appended to the input value — the raw stdin listener reassembles them.
+ */
+export function isKittySequenceFragment(input) {
+    return (/^\[\d{1,2}(;\d{0,2})?u?$/.test(input) || // prefix or complete "[13;2u"
+        /^\d{1,2};\d{1,2}u$/.test(input) // suffix after a split ("3;2u")
+    );
+}
+/**
+ * Accumulate raw stdin bytes and detect the complete Kitty Shift+Enter
+ * sequence, which may span multiple chunks. Non-sequence bytes are dropped;
+ * the trailing partial prefix (from the last ESC) is kept for the next chunk.
+ */
+export function accumulateKittyInput(buffer, chunk) {
+    let buf = buffer + chunk;
+    let shiftEnter = false;
+    let idx;
+    while ((idx = buf.indexOf(SHIFT_ENTER_SEQ)) !== -1) {
+        buf = buf.slice(idx + SHIFT_ENTER_SEQ.length);
+        shiftEnter = true;
+    }
+    const escIdx = buf.lastIndexOf("\x1b");
+    return { buffer: escIdx === -1 ? "" : buf.slice(escIdx), shiftEnter };
+}
 /**
  * Multi-line input bar.
  * - Enter: submit
  * - Shift+Enter (Kitty protocol terminals): new line
  * - Ctrl+J: new line (universal fallback)
  * - Backslash at end + Enter: continue on next line
+ *
+ * Wrapping is done here rather than by Ink so the caret's row/column is known
+ * exactly; the hardware cursor is parked on that cell so IME composition
+ * (Chinese, Japanese, Korean) shows up in the right place.
  */
-export function InputBar({ onSubmit, disabled, placeholder }) {
-    const [value, setValue] = useState("");
-    const [shiftEnterDetected, setShiftEnterDetected] = useState(false);
+export function InputBar({ onSubmit, disabled, placeholder, columns, terminalRows, onSelectionMode, onExit, }) {
+    const [editing, setEditing] = useState({ value: "", caretIndex: 0 });
+    const { value, caretIndex } = editing;
+    const [menuIndex, setMenuIndex] = useState(0);
+    const [menuDismissed, setMenuDismissed] = useState(false);
     const { stdin } = useStdin();
-    // Listen for Kitty protocol Shift+Enter: ESC[13;2u
-    useEffect(() => {
-        if (!stdin || disabled)
+    const { stdout } = useStdout();
+    const kittyBuffer = useRef("");
+    const mouseBuffer = useRef("");
+    const deleteBuffer = useRef("");
+    const homeEndBuffer = useRef("");
+    const width = columns || 80;
+    const [historyState, setHistoryState] = useState(() => createHistory(loadInputHistory()));
+    const historyRef = useRef(historyState);
+    const [exitHint, setExitHint] = useState(false);
+    const exitArmedAtRef = useRef(null);
+    const exitHintTimer = useRef(null);
+    const clearExitHint = useCallback(() => {
+        if (exitArmedAtRef.current === null && exitHintTimer.current === null)
             return;
-        const handleData = (data) => {
-            const str = data.toString("utf-8");
-            // Kitty keyboard protocol: \x1b[13;2u = Shift+Enter
-            if (str.includes("\x1b[13;2u")) {
-                setShiftEnterDetected(true);
-                setValue((v) => v + "\n");
-            }
-        };
-        stdin.on("data", handleData);
-        return () => { stdin.off("data", handleData); };
-    }, [stdin, disabled]);
+        if (exitHintTimer.current !== null) {
+            clearTimeout(exitHintTimer.current);
+            exitHintTimer.current = null;
+        }
+        exitArmedAtRef.current = null;
+        setExitHint(false);
+    }, []);
+    const showExitHint = useCallback((armedAt) => {
+        exitArmedAtRef.current = armedAt;
+        setExitHint(true);
+        if (exitHintTimer.current !== null)
+            clearTimeout(exitHintTimer.current);
+        exitHintTimer.current = setTimeout(() => {
+            exitHintTimer.current = null;
+            exitArmedAtRef.current = null;
+            setExitHint(false);
+        }, EXIT_CTRL_C_WINDOW_MS);
+    }, []);
+    useEffect(() => () => clearExitHint(), [clearExitHint]);
+    // The ref mirrors `editing` synchronously, so edits from separate stdin
+    // listeners (Ink's useInput for text, the raw listener for delete keys)
+    // always apply to the newest state, in arrival order, even when React has
+    // not re-rendered yet (fast key repeats, text + delete in one chunk).
+    const editingRef = useRef(editing);
+    const applyEdit = useCallback((edit) => {
+        clearExitHint();
+        const after = edit(editingRef.current.value, editingRef.current.caretIndex);
+        editingRef.current = after;
+        setEditing(after);
+        const nextHistory = resetHistory(historyRef.current, after.value);
+        if (nextHistory !== historyRef.current) {
+            historyRef.current = nextHistory;
+            setHistoryState(nextHistory);
+        }
+    }, [clearExitHint]);
+    const submit = (text) => {
+        historyRef.current = pushInput(historyRef.current, text);
+        setHistoryState(historyRef.current);
+        saveInputHistory(historyRef.current.entries);
+        onSubmit(text);
+    };
+    const browseTo = (direction) => {
+        const { text, state } = browseHistory(historyRef.current, direction, isKnownSlashCommandInput);
+        historyRef.current = state;
+        setHistoryState(state);
+        if (text !== editingRef.current.value) {
+            const after = { value: text, caretIndex: Array.from(text).length };
+            editingRef.current = after;
+            setEditing(after);
+        }
+    };
+    // Release the caret when the input bar goes away (e.g. confirm prompt).
+    useEffect(() => () => {
+        setCaretPosition(null);
+    }, []);
+    // Slash command menu — closes once a space follows the command name so the
+    // argument menu can take over immediately.
+    const matches = useMemo(() => filterSlashCommands(value), [value]);
+    const menuOpen = value.startsWith("/") && !/\s/.test(value.slice(1)) && !menuDismissed && matches.length > 0;
+    const shownIndex = menuOpen ? Math.min(menuIndex, matches.length - 1) : 0;
+    const selected = menuOpen ? matches[shownIndex] : undefined;
+    // Argument completion (e.g. `/skills disable <name>`), fed by app-registered providers
+    const argOptions = useMemo(() => (menuOpen ? [] : getSlashArgOptions(value)), [value, menuOpen]);
+    const argMenuOpen = !menuOpen && !menuDismissed && argOptions.length > 0;
+    const argIndex = argMenuOpen ? Math.min(menuIndex, argOptions.length - 1) : 0;
+    const argSelected = argMenuOpen ? argOptions[argIndex] : undefined;
+    useEffect(() => {
+        setMenuIndex(0);
+    }, []);
+    const acceptCommand = (cmd) => {
+        if (cmd.argHint) {
+            applyEdit(() => ({ value: `/${cmd.name} `, caretIndex: cmd.name.length + 2 }));
+        }
+        else {
+            submit(`/${cmd.name}`);
+            applyEdit(() => ({ value: "", caretIndex: 0 }));
+        }
+    };
+    const acceptArg = (option) => {
+        applyEdit((v) => {
+            const next = applySlashArgCompletion(v, option.value);
+            return { value: next, caretIndex: Array.from(next).length };
+        });
+    };
+    const acceptCommandRef = useRef(acceptCommand);
+    acceptCommandRef.current = acceptCommand;
+    const acceptArgRef = useRef(acceptArg);
+    acceptArgRef.current = acceptArg;
+    const matchesRef = useRef(matches);
+    matchesRef.current = matches;
+    const argOptionsRef = useRef(argOptions);
+    argOptionsRef.current = argOptions;
+    const menuOpenRef = useRef(menuOpen);
+    menuOpenRef.current = menuOpen;
+    const argMenuOpenRef = useRef(argMenuOpen);
+    argMenuOpenRef.current = argMenuOpen;
     useInput((input, key) => {
         if (disabled)
             return;
-        // If we just handled a Shift+Enter via raw stdin, skip this cycle
-        if (shiftEnterDetected) {
-            setShiftEnterDetected(false);
+        if (isCtrlC(input, key)) {
+            const current = editingRef.current.value;
+            const result = clearInputOnCtrlC(historyRef.current, current, exitArmedAtRef.current, Date.now());
+            if (result.exit) {
+                clearExitHint();
+                onExit();
+                return;
+            }
+            if (result.state.entries !== historyRef.current.entries) {
+                saveInputHistory(result.state.entries);
+            }
+            historyRef.current = result.state;
+            setHistoryState(result.state);
+            if (result.armedAt !== null) {
+                showExitHint(result.armedAt);
+                return;
+            }
+            clearExitHint();
+            applyEdit(() => ({ value: "", caretIndex: 0 }));
+            return;
+        }
+        clearExitHint();
+        if (key.ctrl && input === "b") {
+            onSelectionMode?.();
+            return;
+        }
+        // Fast typing or paste can deliver "text\r" as a single chunk — treat a
+        // trailing Enter as Enter and strip it from the value.
+        const cleanInput = input.replace(/[\r\n]+$/, "");
+        const pressedEnter = key.return || /[\r\n]+$/.test(input);
+        // Esc closes the slash menu; while browsing history it returns to the draft
+        if (key.escape) {
+            if (menuOpen || argMenuOpen)
+                setMenuDismissed(true);
+            else if (historyRef.current.index !== -1) {
+                const next = resetHistory(historyRef.current, historyRef.current.draft);
+                historyRef.current = next;
+                setHistoryState(next);
+                if (next.draft !== editingRef.current.value) {
+                    const after = { value: next.draft, caretIndex: Array.from(next.draft).length };
+                    editingRef.current = after;
+                    setEditing(after);
+                }
+            }
+            return;
+        }
+        // Any other key re-opens the menu
+        setMenuDismissed(false);
+        // Slash menu: Tab/Shift+Tab pick, Enter runs. ↑↓ always recall sent input.
+        if (menuOpen) {
+            if (key.tab) {
+                if (matches.length === 1 && selected) {
+                    acceptCommand(selected);
+                    return;
+                }
+                setMenuIndex((i) => (key.shift ? (i - 1 + matches.length) % matches.length : (i + 1) % matches.length));
+                return;
+            }
+            if (pressedEnter) {
+                if (selected)
+                    acceptCommand(selected);
+                return;
+            }
+            if (key.leftArrow || key.rightArrow)
+                return;
+        }
+        // Argument menu: Tab completes the highlight. Enter still submits the line
+        // so a fully typed command is never swallowed by the suggestion list.
+        if (argMenuOpen) {
+            if (key.tab) {
+                if (argSelected)
+                    acceptArg(argSelected);
+                return;
+            }
+        }
+        const inkKey = key;
+        if (inkKey.home) {
+            applyEdit((v, c) => ({ value: v, caretIndex: moveToLineStart(v, c) }));
+            return;
+        }
+        if (inkKey.end) {
+            applyEdit((v, c) => ({ value: v, caretIndex: moveToLineEnd(v, c) }));
             return;
         }
-        // Ctrl+J: insert newline
-        if (key.ctrl && input === "j") {
-            setValue((v) => v + "\n");
+        // Move one visual row first; only browse history when already at the edge.
+        if (key.upArrow) {
+            const { value: v, caretIndex: c } = editingRef.current;
+            const next = moveCaretVertical(v, c, -1, inputTextWidth(columns));
+            if (next !== c) {
+                applyEdit(() => ({ value: v, caretIndex: next }));
+                return;
+            }
+            browseTo(1);
+            return;
+        }
+        if (key.downArrow) {
+            const { value: v, caretIndex: c } = editingRef.current;
+            const next = moveCaretVertical(v, c, 1, inputTextWidth(columns));
+            if (next !== c) {
+                applyEdit(() => ({ value: v, caretIndex: next }));
+                return;
+            }
+            browseTo(-1);
+            return;
+        }
+        // Ctrl+J: insert newline. The terminal sends LF (0x0A) for Ctrl+J and CR
+        // (0x0D) for Enter; Ink parses both as "enter", but key.return is only
+        // true for the CR case, so a lone "\n" without key.return is Ctrl+J.
+        if (input === "\n" && !key.return) {
+            applyEdit((v, c) => insertAt(v, c, "\n"));
             return;
         }
         // Enter: submit or continue if ends with backslash
-        if (key.return) {
-            if (value.endsWith("\\")) {
-                setValue((v) => v.slice(0, -1) + "\n");
+        if (pressedEnter) {
+            const v = editingRef.current.value;
+            if (v.endsWith("\\")) {
+                applyEdit((cv, cc) => insertAt(cv.slice(0, -1), cc, "\n"));
                 return;
             }
-            const text = value.trim();
-            if (text) {
-                onSubmit(text);
-                setValue("");
+            const text = v.trim();
+            if (text)
+                submit(text);
+            applyEdit(() => ({ value: "", caretIndex: 0 }));
+            return;
+        }
+        // Left / right move the caret through the text
+        if (key.leftArrow) {
+            applyEdit((v, c) => ({ value: v, caretIndex: moveCaretHorizontal(v, c, -1) }));
+            return;
+        }
+        if (key.rightArrow) {
+            applyEdit((v, c) => ({ value: v, caretIndex: moveCaretHorizontal(v, c, 1) }));
+            return;
+        }
+        // Backspace (\b, Ctrl+H) — remove the code point before the caret. Most
+        // terminals send DEL (0x7F) for the Backspace key and CSI 3 ~ for Delete;
+        // Ink reports both of those as key.delete (not key.backspace), so they
+        // never reach this branch and are handled by the raw stdin listener,
+        // which can tell them apart.
+        if (key.backspace) {
+            applyEdit((v, c) => backspaceAt(v, c));
+            return;
+        }
+        if (key.escape || key.pageUp || key.pageDown)
+            return;
+        // Ctrl+R: history search by current input
+        if (key.ctrl && input === "r") {
+            const hit = searchHistory(historyRef.current, editingRef.current.value);
+            if (hit) {
+                const after = { value: hit, caretIndex: Array.from(hit).length };
+                editingRef.current = after;
+                setEditing(after);
             }
             return;
         }
-        // Backspace / Delete
-        if (key.backspace || key.delete) {
-            setValue((v) => v.slice(0, -1));
+        // Readline keys
+        if (key.ctrl && input === "a") {
+            applyEdit((v, c) => ({ value: v, caretIndex: moveToLineStart(v, c) }));
             return;
         }
-        // Escape, arrows, etc. — ignore (handled elsewhere)
-        if (key.escape || key.upArrow || key.downArrow || key.leftArrow || key.rightArrow)
+        if (key.ctrl && input === "e") {
+            applyEdit((v, c) => ({ value: v, caretIndex: moveToLineEnd(v, c) }));
             return;
-        if (key.pageUp || key.pageDown)
+        }
+        if (key.ctrl && input === "k") {
+            applyEdit((v, c) => deleteToLineEnd(v, c));
+            return;
+        }
+        if (key.ctrl && input === "u") {
+            applyEdit((v, c) => deleteToLineStart(v, c));
             return;
+        }
+        if (key.ctrl && input === "w") {
+            applyEdit((v, c) => deleteWordBefore(v, c));
+            return;
+        }
+        if (key.meta && input === "b") {
+            applyEdit((v, c) => ({ value: v, caretIndex: Math.max(0, c - 1) }));
+            return;
+        }
+        if (key.meta && input === "f") {
+            applyEdit((v, c) => ({ value: v, caretIndex: Math.min(Array.from(v).length, c + 1) }));
+            return;
+        }
         if (key.ctrl || key.meta)
             return;
+        // Kitty Shift+Enter sequence (or a fragment of it) — handled by the raw
+        // stdin listener, never as text
+        if (isKittySequenceFragment(input))
+            return;
+        if (/^\[<.*[Mm]$/.test(input) || input.startsWith("[<") || /^[\d;,]+[Mm]$/.test(input))
+            return;
+        // Bracketed paste: ESC[200~ ... ESC[200~ — Ink may deliver without ESC, treat as bulk insert
+        if (input.includes("\x1b[200~") || input.includes("[200~")) {
+            const cleaned = input.replace(/\x1b?\[200~|\x1b?\[201~/g, "");
+            if (cleaned)
+                applyEdit((v, c) => insertAt(v, c, cleaned));
+            return;
+        }
         // Tab → 2 spaces
         if (key.tab) {
-            setValue((v) => v + "  ");
+            applyEdit((v, c) => insertAt(v, c, "  "));
             return;
         }
         // Normal character input (including CJK)
         if (input) {
-            setValue((v) => v + input);
+            applyEdit((v, c) => insertAt(v, c, cleanInput));
         }
     }, { isActive: !disabled });
     const isEmpty = value === "";
-    const lines = value.split("\n");
-    const isMultiline = lines.length > 1;
-    const borderColor = disabled ? "gray" : "cyan";
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: borderColor, paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: disabled ? "gray" : "cyan", children: "\u276F " }), isEmpty && placeholder ? (_jsx(Text, { color: "gray", dimColor: true, children: placeholder })) : (_jsxs(Text, { wrap: "wrap", children: [value, "\u2588"] }))] }), isMultiline && (_jsx(Box, { justifyContent: "flex-end", children: _jsxs(Text, { color: "gray", dimColor: true, children: [lines.length, " \u884C | Shift+Enter/Ctrl+J \u6362\u884C | Enter \u53D1\u9001"] }) }))] }));
+    const shownPlaceholder = exitHint ? "再按一次 Ctrl+C 退出" : placeholder;
+    const logicalLines = value.split("\n");
+    const isMultiline = logicalLines.length > 1;
+    const borderColor = disabled ? theme.inputBorderDisabled : theme.inputBorder;
+    const textWidth = inputTextWidth(width);
+    // Visual rows of the value, plus the caret position inside them.
+    const rows = visualRows(value, textWidth);
+    const clampedCaret = Math.min(caretIndex, Array.from(value).length);
+    // Locate the caret's visual row and its character offset inside that row.
+    let caretRowIndex = rows.length - 1;
+    let caretCharOffset = Array.from(rows[caretRowIndex].text).length;
+    for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        const end = row.startIndex + Array.from(row.text).length;
+        if (clampedCaret >= row.startIndex && clampedCaret <= end) {
+            caretRowIndex = i;
+            caretCharOffset = clampedCaret - row.startIndex;
+            break;
+        }
+    }
+    // A caret at the end of a full row has no cell left — move it to the start
+    // of the next visual row (pushing an empty one when it is the last row).
+    let caretColumnOffset = displayWidth(Array.from(rows[caretRowIndex].text).slice(0, caretCharOffset).join(""));
+    if (caretColumnOffset >= textWidth) {
+        if (caretRowIndex === rows.length - 1) {
+            rows.push({
+                text: "",
+                startIndex: rows[caretRowIndex].startIndex + Array.from(rows[caretRowIndex].text).length,
+            });
+        }
+        caretRowIndex++;
+        caretCharOffset = 0;
+        caretColumnOffset = 0;
+    }
+    // The caret may sit on any content row; the only thing below it is the
+    // (single-row) multi-line hint — plus the slash menu when it floats below
+    // the input bar.
+    const hintRows = isMultiline ? 1 : 0;
+    const argShown = argMenuOpen ? Math.min(8, argOptions.length) : 0;
+    const menuRows = menuOpen ? matches.length + 5 : argMenuOpen ? argShown + 4 : 0;
+    // Input bar sits at the bottom of App's footer: its content area starts
+    // `terminalRows` rows up minus the bar's own height (menu + bottom border +
+    // hint above it in screen order, from the bottom of the terminal up).
+    const inputTopRow = terminalRows - rows.length - hintRows - menuRows;
+    // Latest geometry for the raw stdin listener, which subscribes only once
+    // (independent of re-renders) and needs these when a click arrives.
+    const rowsRef = useRef(rows);
+    rowsRef.current = rows;
+    const inputTopRowRef = useRef(inputTopRow);
+    inputTopRowRef.current = inputTopRow;
+    const hintRowsRef = useRef(hintRows);
+    hintRowsRef.current = hintRows;
+    // Listen for Kitty protocol Shift+Enter: ESC[13;2u, which may arrive split
+    // across stdin chunks — accumulate and reassemble here. Ink's useInput gets
+    // each raw chunk and would append fragments to the value, so isKittySequenceFragment
+    // below filters them out. Backspace (DEL 0x7F) and Delete (CSI 3 ~ and
+    // variants) are also picked out of the same raw stream, since Ink collapses
+    // them into one key.delete. SGR mouse click events arrive on the same raw
+    // stream; parse them and move the caret to the clicked cell. The listener
+    // subscribes once; every edit goes through applyEdit, which reads the
+    // synchronous editingRef, so fast key repeats never operate on stale text.
+    useEffect(() => {
+        if (!stdin || disabled)
+            return;
+        const handleData = (data) => {
+            const chunk = data.toString("utf-8");
+            // Kitty Shift+Enter accumulation
+            const { buffer: kittyBuf, shiftEnter } = accumulateKittyInput(kittyBuffer.current, chunk);
+            kittyBuffer.current = kittyBuf;
+            if (shiftEnter)
+                applyEdit((v, c) => insertAt(v, c, "\n"));
+            // Backspace (DEL 0x7F) and Delete (CSI 3 ~ / variants): Ink reports
+            // them all as key.delete, so they are distinguished and applied here.
+            // The buffer handles a sequence split across chunks.
+            const { buffer: delBuf, actions } = scanDeleteKeys(deleteBuffer.current, chunk);
+            deleteBuffer.current = delBuf;
+            if (actions.length > 0) {
+                for (const action of actions) {
+                    applyEdit((v, c) => (action.kind === "backspace" ? backspaceAt(v, c) : deleteAt(v, c)));
+                }
+            }
+            const { buffer: homeBuf, actions: homeActions } = scanHomeEndKeys(homeEndBuffer.current, chunk);
+            homeEndBuffer.current = homeBuf;
+            if (homeActions.length > 0) {
+                for (const action of homeActions) {
+                    applyEdit((v, c) => ({
+                        value: v,
+                        caretIndex: action.kind === "home" ? moveToLineStart(v, c) : moveToLineEnd(v, c),
+                    }));
+                }
+            }
+            mouseBuffer.current += chunk;
+            let sgr;
+            while ((sgr = scanSgrMouse(mouseBuffer.current))) {
+                mouseBuffer.current = sgr.rest;
+                if (sgr.event.button === 0 && sgr.event.press) {
+                    const contentRow = sgr.event.row - inputTopRowRef.current;
+                    if (contentRow >= 0 && contentRow < rowsRef.current.length) {
+                        const evCol = sgr.event.col;
+                        applyEdit((v) => ({
+                            value: v,
+                            caretIndex: caretIndexFromClick(rowsRef.current, contentRow, evCol, TEXT_START_COLUMN),
+                        }));
+                    }
+                    else {
+                        const chrome = 3;
+                        const header = menuOpenRef.current ? 1 : 0;
+                        const optionIndex = sgr.event.row - (inputTopRowRef.current + rowsRef.current.length + hintRowsRef.current + chrome + header);
+                        if (menuOpenRef.current) {
+                            const cmd = matchesRef.current[optionIndex];
+                            if (cmd)
+                                acceptCommandRef.current(cmd);
+                        }
+                        else if (argMenuOpenRef.current) {
+                            const shown = argOptionsRef.current.slice(0, 8);
+                            const opt = shown[optionIndex];
+                            if (opt)
+                                acceptArgRef.current(opt);
+                        }
+                    }
+                }
+            }
+            if (mouseBuffer.current.length > 64) {
+                const esc = mouseBuffer.current.lastIndexOf("\x1b");
+                mouseBuffer.current = esc === -1 ? "" : mouseBuffer.current.slice(esc);
+            }
+        };
+        stdin.on("data", handleData);
+        return () => {
+            stdin.off("data", handleData);
+        };
+    }, [stdin, disabled, applyEdit]);
+    // Enable the SGR mouse protocol so clicks on the input bar can position the
+    // caret. Events arrive on raw stdin; parseSgrMouse picks them out of the
+    // same chunk stream as the Kitty sequence. Terminals without mouse support
+    // simply never send events — keyboard navigation still works.
+    useEffect(() => {
+        stdout.write(MOUSE_ENABLE);
+        return () => {
+            stdout.write(MOUSE_DISABLE);
+        };
+    }, [stdout]);
+    // Must publish during render (not in effect) — Ink writes the frame in
+    // resetAfterCommit before effects run. If delayed to useEffect, the
+    // hardware cursor (IME preedit anchor) lags by one frame and appears
+    // displaced while composing CJK.
+    {
+        const rowsBelowCaret = rows.length - 1 - caretRowIndex;
+        setCaretPosition({
+            rowsAbove: rowsBelowCaret + 1 /* bottom border */ + hintRows + menuRows,
+            column: TEXT_START_COLUMN + caretColumnOffset,
+        });
+    }
+    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, width: "100%", children: [_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: borderColor, paddingX: 1, width: "100%", children: [isEmpty && shownPlaceholder ? (_jsxs(Box, { children: [_jsx(Text, { color: disabled ? theme.inputBorderDisabled : theme.inputBorder, children: GUTTER }), _jsx(Text, { inverse: true, children: " " }), _jsx(Text, { color: theme.muted, dimColor: true, wrap: "truncate-end", children: shownPlaceholder })] })) : (rows.map((row, i) => {
+                        const chars = Array.from(row.text);
+                        const caretHere = i === caretRowIndex;
+                        const offset = caretHere ? caretCharOffset : chars.length;
+                        const before = chars.slice(0, offset).join("");
+                        const after = chars.slice(offset).join("");
+                        return (_jsxs(Box, { children: [_jsx(Text, { color: disabled ? theme.inputBorderDisabled : theme.inputBorder, children: i === 0 ? GUTTER : "  " }), _jsxs(Text, { wrap: "truncate-end", children: [before, caretHere && _jsx(Text, { inverse: true, children: " " }), after] })] }, i));
+                    })), isMultiline && (_jsx(Box, { justifyContent: "flex-end", children: _jsxs(Text, { color: theme.muted, dimColor: true, wrap: "truncate-end", children: [logicalLines.length, " \u884C | Shift+Enter/Ctrl+J \u6362\u884C | Enter \u53D1\u9001"] }) }))] }), menuOpen && selected && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.inputBorder, paddingX: 1, marginTop: 1, width: "100%", children: [_jsx(Box, { children: _jsx(Text, { color: theme.muted, children: value.trim() === "/" ? "命令" : `/${value.slice(1)} 命令` }) }), matches.map((c, i) => (_jsxs(Box, { children: [_jsx(Text, { color: i === shownIndex ? theme.accent : theme.muted, children: i === shownIndex ? "❯ " : "  " }), _jsxs(Text, { bold: i === shownIndex, color: i === shownIndex ? theme.accent : undefined, children: ["/", c.name, c.argHint ? ` ${c.argHint}` : ""] }), _jsxs(Text, { color: theme.muted, dimColor: true, wrap: "truncate-end", children: ["  ", c.description] })] }, c.name))), _jsx(Box, { children: _jsx(Text, { color: theme.muted, dimColor: true, wrap: "truncate-end", children: "Tab \u9009\u62E9 \u00B7 Enter \u6267\u884C \u00B7 Esc \u5173\u95ED" }) })] })), argMenuOpen && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.inputBorder, paddingX: 1, marginTop: 1, width: "100%", children: [argOptions.slice(0, 8).map((o, i) => (_jsxs(Box, { children: [_jsx(Text, { color: i === argIndex ? theme.accent : theme.muted, children: i === argIndex ? "❯ " : "  " }), _jsx(Text, { bold: i === argIndex, color: i === argIndex ? theme.accent : undefined, children: o.value }), o.description && (_jsxs(Text, { color: theme.muted, dimColor: true, wrap: "truncate-end", children: ["  ", o.description] }))] }, o.value))), _jsx(Box, { children: _jsxs(Text, { color: theme.muted, dimColor: true, wrap: "truncate-end", children: [argOptions.length > 8 ? `还有 ${argOptions.length - 8} 项 · ` : "", "Tab \u8865\u5168 \u00B7 Enter \u6267\u884C \u00B7 Esc \u5173\u95ED"] }) })] }))] }));
 }