min-agent 0.2.0 → 0.3.0

package/dist/tools/write.js

@@ -1,29 +1,35 @@
 import { tool, jsonSchema } from "ai";
-import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { mkdir, writeFile } from "fs/promises";
+import { existsSync } from "fs";
 import path from "path";
 import { confirm, isAutoApprove } from "../confirm.js";
+const MAX_WRITE_BYTES = 10 * 1024 * 1024;
 export const writeTool = tool({
-    description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Creates parent directories as needed.",
+    description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does (unless `append` is true). Creates parent directories as needed.",
     inputSchema: jsonSchema({
         type: "object",
         properties: {
             filePath: { type: "string", description: "Path to the file to write (relative to cwd or absolute)" },
             content: { type: "string", description: "The content to write to the file" },
+            append: { type: "boolean", description: "If true, append to the file instead of overwriting" },
         },
         required: ["filePath", "content"],
     }),
-    execute: async ({ filePath, content }) => {
+    execute: async ({ filePath, content, append }) => {
+        if (Buffer.byteLength(content, "utf-8") > MAX_WRITE_BYTES) {
+            return `Error: content exceeds ${MAX_WRITE_BYTES} bytes. Write in smaller chunks or check the content size.`;
+        }
         const resolved = path.resolve(process.cwd(), filePath);
         // Confirm overwriting existing files
-        if (!isAutoApprove() && existsSync(resolved)) {
+        if (!append && !isAutoApprove() && existsSync(resolved)) {
             const approved = await confirm(`Overwrite existing file: ${filePath}`);
             if (!approved)
                 return "Write rejected by user.";
         }
         try {
-            mkdirSync(path.dirname(resolved), { recursive: true });
-            writeFileSync(resolved, content, "utf-8");
-            return `Written ${content.length} bytes to ${filePath}`;
+            await mkdir(path.dirname(resolved), { recursive: true });
+            await writeFile(resolved, content, append ? { flag: "a", encoding: "utf-8" } : "utf-8");
+            return `Written ${Buffer.byteLength(content, "utf-8")} bytes to ${filePath}${append ? " (appended)" : ""}`;
         }
         catch (err) {
             return `Error writing file: ${err.message}`;

package/dist/tui/App.js

@@ -1,15 +1,49 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, useInput } from "ink";
+import { useEffect, useState } from "react";
+import { Box, useInput, useStdout } from "ink";
 import { Spinner } from "./Spinner.js";
 import { InputBar } from "./InputBar.js";
 import { MessageList } from "./MessageList.js";
-import { ConfirmBar } from "./ConfirmBar.js";
+import { ConfirmBar, confirmBarRows } from "./ConfirmBar.js";
+import { QuestionBar, questionBarRows } from "./QuestionBar.js";
 import { StatusBar } from "./StatusBar.js";
-export function App({ initialState, onSubmit, onConfirm, onExit }) {
-    useInput((_input, key) => {
-        if (key.escape && initialState.isRunning) {
+import { ModelPicker, modelPickerRows } from "./ModelPicker.js";
+import { setCaretPosition } from "./caret.js";
+import { computeMessageMaxHeight } from "./layout.js";
+export function App({ initialState, onSubmit, onConfirm, onQuestionAnswer, onModelPick, onModelCancel, onExit, onCopyNotice }) {
+    // Ink recalculates its own layout on resize without re-rendering React, so
+    // track terminal size ourselves to keep heights/widths in sync.
+    const { stdout } = useStdout();
+    const [terminal, setTerminal] = useState({ columns: stdout.columns || 80, rows: stdout.rows || 0 });
+    useEffect(() => {
+        const onResize = () => setTerminal({ columns: stdout.columns || 80, rows: stdout.rows || 0 });
+        stdout.on("resize", onResize);
+        return () => { stdout.off("resize", onResize); };
+    }, [stdout]);
+    useInput((input, key) => {
+        if (key.ctrl && input === "c") {
+            onExit();
+            return;
+        }
+        if (key.escape && initialState.isRunning && !initialState.confirmMessage && !initialState.question && !initialState.modelPicker) {
             onExit();
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(MessageList, { messages: initialState.messages }), initialState.isRunning && (_jsx(Box, { paddingLeft: 1, children: _jsx(Spinner, { label: initialState.spinnerText || "思考中..." }) })), _jsx(StatusBar, { state: initialState }), initialState.confirmMessage ? (_jsx(ConfirmBar, { message: initialState.confirmMessage, onConfirm: onConfirm })) : (_jsx(InputBar, { onSubmit: onSubmit, disabled: initialState.isRunning, placeholder: initialState.isRunning ? "按 Esc 取消运行..." : "输入消息... (Ctrl+J 换行)" }))] }));
+    if (initialState.confirmMessage || initialState.question || initialState.modelPicker)
+        setCaretPosition(null);
+    const columns = terminal.columns;
+    const terminalRows = terminal.rows;
+    const confirmActive = Boolean(initialState.confirmMessage);
+    const questionActive = Boolean(initialState.question);
+    const modelPickerActive = Boolean(initialState.modelPicker);
+    const footerRows = confirmActive
+        ? confirmBarRows(initialState.confirmMessage ?? "", columns)
+        : questionActive
+            ? questionBarRows(initialState.question.prompt, initialState.question.options, columns)
+            : modelPickerActive
+                ? modelPickerRows(terminalRows)
+                : 3; // input bar: 2 borders + 1 content row
+    const spinnerRows = initialState.isRunning && !confirmActive && !questionActive && !modelPickerActive ? 1 : 0;
+    const messageMaxHeight = computeMessageMaxHeight(terminalRows, footerRows, spinnerRows);
+    return (_jsxs(Box, { flexDirection: "column", height: terminalRows || undefined, children: [!modelPickerActive && (_jsx(Box, { flexGrow: 1, minHeight: 0, children: _jsx(MessageList, { messages: initialState.messages, maxHeight: messageMaxHeight, columns: columns, onCopyNotice: onCopyNotice }) })), initialState.isRunning && !confirmActive && !questionActive && !modelPickerActive && (_jsx(Box, { paddingLeft: 1, children: _jsx(Spinner, { label: initialState.spinnerText || "思考中..." }) })), _jsx(StatusBar, { state: initialState, columns: columns }), initialState.confirmMessage ? (_jsx(ConfirmBar, { message: initialState.confirmMessage, onConfirm: onConfirm })) : initialState.question ? (_jsx(QuestionBar, { prompt: initialState.question.prompt, options: initialState.question.options, onAnswer: onQuestionAnswer })) : initialState.modelPicker ? (_jsx(ModelPicker, { currentModel: initialState.model, onSelect: onModelPick, onCancel: onModelCancel })) : (_jsx(InputBar, { onSubmit: onSubmit, disabled: initialState.isRunning, placeholder: initialState.isRunning ? "按 Esc 取消运行..." : "输入消息... (Ctrl+J 换行)", columns: columns, terminalRows: terminalRows }))] }));
 }

package/dist/tui/ConfirmBar.js

@@ -1,13 +1,34 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text, useInput } from "ink";
+import { wrapByWidth } from "./text-width.js";
+import { innerTextWidth } from "./layout.js";
+import { theme } from "./theme.js";
+/**
+ * Terminal rows the confirm bar occupies, mirroring the JSX layout below.
+ * Needed by App to bound the message area so the frame never exceeds the
+ * terminal height while the prompt is up.
+ */
+export function confirmBarRows(message, columns) {
+    const textWidth = innerTextWidth(columns);
+    let rows = 0;
+    for (const line of message.split("\n"))
+        rows += wrapByWidth(line, textWidth).length;
+    return rows + 5; /* borders2 + title1 + marginTop1 + prompt1 */
+}
 export function ConfirmBar({ message, onConfirm }) {
     useInput((input, key) => {
-        if (input.toLowerCase() === "y") {
+        if (key.escape) {
+            onConfirm(false);
+            return;
+        }
+        const hasEnter = key.return || /[\r\n]/.test(input);
+        const stripped = input.replace(/[\r\n]+/g, "").trim().toLowerCase();
+        if (stripped === "y") {
             onConfirm(true);
         }
-        else if (input.toLowerCase() === "n" || key.escape || key.return) {
+        else if (stripped === "n" || (stripped === "" && hasEnter)) {
             onConfirm(false);
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "blue", paddingX: 1, children: [_jsx(Box, { children: _jsx(Text, { color: "gray", children: "\u250C\u2500 \u5373\u5C06\u6267\u884C \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }) }), _jsx(Box, { paddingLeft: 1, children: _jsx(Text, { children: message }) }), _jsx(Box, { children: _jsx(Text, { color: "gray", children: "\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }) }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { bold: true, color: "blue", children: "? \u662F\u5426\u5141\u8BB8\u6267\u884C\uFF1F " }), _jsx(Text, { color: "green", children: "[y]" }), _jsx(Text, { color: "gray", children: " / " }), _jsx(Text, { color: "red", children: "[N]" })] })] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.confirmBorder, paddingX: 1, children: [_jsx(Box, { children: _jsx(Text, { bold: true, color: theme.confirmBorder, children: "\u26A0 \u8BF7\u6C42\u6267\u884C\u6743\u9650" }) }), _jsx(Box, { paddingLeft: 1, children: _jsx(Text, { children: message }) }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { bold: true, color: theme.confirmBorder, children: "? \u662F\u5426\u5141\u8BB8\u6267\u884C\uFF1F " }), _jsx(Text, { color: theme.success, children: "[y]" }), _jsx(Text, { color: theme.muted, children: " / " }), _jsx(Text, { color: theme.error, children: "[N]" })] })] }));
 }

package/dist/tui/InputBar.js

@@ -1,83 +1,428 @@
 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, insertAt, backspaceAt, deleteAt, caretIndexFromClick, scanDeleteKeys, moveToLineStart, moveToLineEnd, deleteToLineStart, deleteToLineEnd, deleteWordBefore } from "./caret-pos.js";
+import { searchHistory } from "./input-history.js";
+import { createHistory, pushInput, browseHistory, resetHistory } from "./input-history.js";
+import { filterSlashCommands, getSlashArgOptions, applySlashArgCompletion } 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 }) {
+    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)
-            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]);
+    const { stdout } = useStdout();
+    const kittyBuffer = useRef("");
+    const mouseBuffer = useRef("");
+    const deleteBuffer = useRef("");
+    const width = columns || 80;
+    const [historyState, setHistoryState] = useState(() => createHistory());
+    const historyRef = useRef(historyState);
+    // 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) => {
+        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);
+        }
+    }, []);
+    const submit = (text) => {
+        historyRef.current = pushInput(historyRef.current, text);
+        setHistoryState(historyRef.current);
+        onSubmit(text);
+    };
+    const browseTo = (direction) => {
+        const { text, state } = browseHistory(historyRef.current, direction);
+        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); }, [value]);
+    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 };
+        });
+    };
     useInput((input, key) => {
         if (disabled)
             return;
-        // If we just handled a Shift+Enter via raw stdin, skip this cycle
-        if (shiftEnterDetected) {
-            setShiftEnterDetected(false);
+        // 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 navigation
+        if (menuOpen) {
+            if (key.downArrow) {
+                setMenuIndex((i) => (i + 1) % matches.length);
+                return;
+            }
+            if (key.upArrow) {
+                setMenuIndex((i) => (i - 1 + matches.length) % matches.length);
+                return;
+            }
+            if (pressedEnter || key.tab) {
+                if (selected)
+                    acceptCommand(selected);
+                return;
+            }
+            // Left/right are ignored while the menu is open
+            if (key.leftArrow || key.rightArrow)
+                return;
+        }
+        // Argument menu: ↑↓ pick, Tab completes. Enter still submits the line so a
+        // fully typed command is never swallowed by the suggestion list.
+        if (argMenuOpen) {
+            if (key.downArrow) {
+                setMenuIndex((i) => (i + 1) % argOptions.length);
+                return;
+            }
+            if (key.upArrow) {
+                setMenuIndex((i) => (i - 1 + argOptions.length) % argOptions.length);
+                return;
+            }
+            if (key.tab) {
+                if (argSelected)
+                    acceptArg(argSelected);
+                return;
+            }
+        }
+        // Input history: ↑ older, ↓ newer (only when the slash menu is closed)
+        if (key.upArrow) {
+            browseTo(1);
+            return;
+        }
+        if (key.downArrow) {
+            browseTo(-1);
             return;
         }
-        // Ctrl+J: insert newline
-        if (key.ctrl && input === "j") {
-            setValue((v) => v + "\n");
+        // 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 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 menuRows = menuOpen ? matches.length + 5 /* margin + borders + header + footer */ : 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;
+    // 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)));
+                }
+            }
+            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),
+                        }));
+                    }
+                }
+            }
+            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", children: [_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: borderColor, paddingX: 1, children: [isEmpty && placeholder ? (_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: placeholder })] })) : (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, 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: "\u2191\u2193 \u9009\u62E9 \u00B7 Enter \u6267\u884C \u00B7 Esc \u5173\u95ED" }) })] })), argMenuOpen && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.inputBorder, paddingX: 1, marginTop: 1, 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} 项 · ` : "", "\u2191\u2193 \u9009\u62E9 \u00B7 Tab \u8865\u5168 \u00B7 Enter \u6267\u884C \u00B7 Esc \u5173\u95ED"] }) })] }))] }));
 }