@miphamai/cli 0.56.0 → 0.58.0

package/src/ui/input.tsx

@@ -1,7 +1,6 @@
 import React, { useState, useEffect, useRef, useMemo } from 'react'
 import { Box, Text, useInput } from 'ink'
 import TextInput from 'ink-text-input'
-import { VimMotionEngine, handleSearchBackspace, type VimMode } from './vim-motions.js'
 import { getCommandList } from './commands.js'
 import { CommandPicker } from './command-picker.js'
 import { useI18n } from '../i18n-context'
@@ -20,7 +19,7 @@ interface InputBarProps {
   onToggleAgentView?: () => void
   /** Shift+Tab → cycle permission mode */
   onCyclePermission?: () => void
-  /** Escape → cancel loading (when input is empty) */
+  /** Escape → cancel loading / clear draft */
   onCancel?: () => void
 }
 
@@ -68,6 +67,14 @@ function pick<T>(arr: T[]): T {
   return arr[Math.floor(Math.random() * arr.length)]!
 }
 
+/**
+ * 判断一次输入是否为「批量」（长度跳变 >1：粘贴 / IME 替换）。
+ * 批量输入需节流防渲染风暴；普通单字符输入应立即显示，无节流延迟。
+ */
+export function isBulkInput(prev: string, next: string): boolean {
+  return Math.abs(next.length - prev.length) > 1
+}
+
 export function InputBar({
   onSubmit,
   isLoading,
@@ -145,15 +152,6 @@ export function InputBar({
     prevLoading.current = isLoading
   }, [isLoading])
 
-  const [vimMode, setVimMode] = useState<VimMode>('insert')
-  // NOTE: Dual mode state — React state (vimMode) drives UI re-renders (prompt color,
-  // placeholder); engine mode (vimEngine.current.mode) drives logic inside useInput so
-  // the handler always reads the authoritative mode without stale-closure risk.
-  const vimEngine = useRef(new VimMotionEngine())
-  const vimPending = useRef<string | null>(null)
-  const [searchMode, setSearchMode] = useState(false)
-  const [searchQuery, setSearchQuery] = useState('')
-
   // Track pre-shortcut value so we can revert ink-text-input's Ctrl-key insertions.
   // ink-text-input inserts 'p'/'f'/'o' for Ctrl+P/F/O (Ink normalizes control chars
   // to their letter names before passing to useInput).
@@ -163,32 +161,21 @@ export function InputBar({
     valueBeforeShortcut.current = value
   }, [value])
 
-  // ── Vim motions: intercept keys in normal mode ──
-
   useInput((input, key) => {
-    // ── Escape: cancel loading → toggle vim mode ──
+    // ── Escape: cancel loading → clear draft ──
     if (key.escape) {
-      // Cancel search mode if active
-      if (searchMode) {
-        setSearchMode(false)
-        setSearchQuery('')
-        return
-      }
-      // Escape while loading → abort (priority over vim toggle)
+      // Escape while loading → abort
       if (isLoading) {
         onCancel?.()
         return
       }
-      // Clear any pending multi-key sequence
-      if (vimPending.current) {
-        vimPending.current = null
-      }
-      setVimMode((prev) => (prev === 'insert' ? 'normal' : 'insert'))
-      vimEngine.current.mode = vimEngine.current.mode === 'insert' ? 'normal' : 'insert'
+      // Idle → clear the draft (the intuitive "cancel")
+      setValue('')
+      valueRef.current = ''
       return
     }
 
-    // ── Global hotkeys (work in both insert and normal modes) ──
+    // ── Global hotkeys ──
     // Shift+Tab → cycle permission mode
     if (key.shift && key.tab) {
       onCyclePermission?.()
@@ -221,121 +208,43 @@ export function InputBar({
       return
     }
 
-    // ── Arrow-key history navigation (insert mode only, Claude Code parity) ──
-    if (vimEngine.current.mode === 'insert' && !searchMode) {
-      if (key.upArrow || key.downArrow) {
-        // Ignore if picker is active (command picker handles its own arrows)
-        if (value.startsWith('/')) return
-
-        if (key.upArrow) {
-          if (submittedHistory.length === 0) return
-          // Save current draft the first time we enter history browsing
-          if (historyIndexRef.current === -1) {
-            // Flush any pending throttle so its deferred setValue doesn't overwrite
-            // history navigation (paste → immediate ↑ race). Save the latest value
-            // from the ref — state `value` is stale inside the throttle window.
-            if (onChangeTimerRef.current) {
-              clearTimeout(onChangeTimerRef.current)
-              onChangeTimerRef.current = null
-            }
-            savedDraftRef.current = valueRef.current
+    // ── Arrow-key history navigation (Claude Code parity) ──
+    if (key.upArrow || key.downArrow) {
+      // Ignore if picker is active (command picker handles its own arrows)
+      if (value.startsWith('/')) return
+
+      if (key.upArrow) {
+        if (submittedHistory.length === 0) return
+        // Save current draft the first time we enter history browsing
+        if (historyIndexRef.current === -1) {
+          // Flush any pending throttle so its deferred setValue doesn't overwrite
+          // history navigation (paste → immediate ↑ race). Save the latest value
+          // from the ref — state `value` is stale inside the throttle window.
+          if (onChangeTimerRef.current) {
+            clearTimeout(onChangeTimerRef.current)
+            onChangeTimerRef.current = null
           }
-          const newIndex = Math.min(historyIndexRef.current + 1, submittedHistory.length - 1)
-          historyIndexRef.current = newIndex
-          setValue(submittedHistory[submittedHistory.length - 1 - newIndex]!)
-          return
+          savedDraftRef.current = valueRef.current
         }
-        if (key.downArrow) {
-          if (historyIndexRef.current === -1) return
-          const newIndex = historyIndexRef.current - 1
-          historyIndexRef.current = newIndex
-          if (newIndex === -1) {
-            // Back to the original draft
-            setValue(savedDraftRef.current)
-            savedDraftRef.current = ''
-          } else {
-            setValue(submittedHistory[submittedHistory.length - 1 - newIndex]!)
-          }
-          return
-        }
-      }
-    }
-
-    if (vimEngine.current.mode !== 'normal') return
-
-    // Handle search mode — collect query characters
-    if (searchMode) {
-      if (key.return) {
-        const action = vimEngine.current.handleSearch(value, searchQuery)
-        if (action.text !== undefined) setValue(action.text)
-        // NOTE: action.cursor is not settable on ink-text-input — user repositions manually
-        setSearchMode(false)
-        setSearchQuery('')
+        const newIndex = Math.min(historyIndexRef.current + 1, submittedHistory.length - 1)
+        historyIndexRef.current = newIndex
+        setValue(submittedHistory[submittedHistory.length - 1 - newIndex]!)
         return
       }
-      if (key.backspace || key.delete) {
-        const next = handleSearchBackspace(searchQuery)
-        setSearchQuery(next.query)
-        if (next.exit) setSearchMode(false)
+      if (key.downArrow) {
+        if (historyIndexRef.current === -1) return
+        const newIndex = historyIndexRef.current - 1
+        historyIndexRef.current = newIndex
+        if (newIndex === -1) {
+          // Back to the original draft
+          setValue(savedDraftRef.current)
+          savedDraftRef.current = ''
+        } else {
+          setValue(submittedHistory[submittedHistory.length - 1 - newIndex]!)
+        }
         return
       }
-      // Accumulate printable characters
-      if (input && input.length === 1 && !key.escape && !key.return) {
-        setSearchQuery((q) => q + input)
-      }
-      return
-    }
-
-    // Handle pending two-key sequences (dd, yy)
-    if (vimPending.current !== null) {
-      if (vimPending.current === 'd' && input === 'd') {
-        const action = vimEngine.current.handleDD(value)
-        setValue(action.text ?? value)
-      } else if (vimPending.current === 'y' && input === 'y') {
-        vimEngine.current.handleYY(value)
-      }
-      // Always clear pending — even when second key doesn't match
-      vimPending.current = null
-      return
-    }
-
-    // Handle p (paste) — pastes clipboard at cursor position
-    if (input === 'p') {
-      const action = vimEngine.current.handlePaste(value, value.length)
-      if (action.text !== undefined) setValue(action.text)
-      return
-    }
-
-    // Handle u (undo)
-    if (input === 'u') {
-      const action = vimEngine.current.handleUndo(value)
-      if (action.text !== undefined) setValue(action.text)
-      return
-    }
-
-    // Handle / (enter search mode)
-    if (input === '/') {
-      setSearchMode(true)
-      setSearchQuery('')
-      return
     }
-
-    // Handle single-key motions (h, j, k, l, w, b, 0, $, d, y)
-    const action = vimEngine.current.handleNormal(input, value, value.length)
-    if (!action) return
-
-    if (action.pending) {
-      vimPending.current = action.pending
-      return
-    }
-
-    if (action.text !== undefined) {
-      setValue(action.text)
-    }
-
-    // NOTE: action.cursor is returned by motions (h/j/k/l/w/b/0/$) but
-    // ink-text-input does not expose a programmatic cursor-position API.
-    // The cursor hint is informational only; the user repositions manually.
   })
 
   // ── Command picker state ──
@@ -344,7 +253,7 @@ export function InputBar({
 
   // Auto-activate picker when user types "/"
   useEffect(() => {
-    if (value.startsWith('/') && !prevValueRef.current.startsWith('/') && vimMode === 'insert') {
+    if (value.startsWith('/') && !prevValueRef.current.startsWith('/')) {
       setPickerActive(true)
     }
     // Dismiss picker when user clears the / prefix
@@ -352,7 +261,7 @@ export function InputBar({
       setPickerActive(false)
     }
     prevValueRef.current = value
-  }, [value, vimMode])
+  }, [value])
 
   // Keep valueRef in sync with state (so useInput handlers read latest value)
   useEffect(() => {
@@ -365,9 +274,15 @@ export function InputBar({
       clearTimeout(onChangeTimerRef.current)
       onChangeTimerRef.current = null
     }
-    // Use latest value from ref (may be ahead of state during throttle)
-    const finalValue = val || valueRef.current
-    if (!finalValue.trim() || isLoading) return
+    // Use the latest value from the ref — state lags behind during throttle, and
+    // the onSubmit `val` is the stale controlled prop in that window.
+    const finalValue = valueRef.current || val
+    if (!finalValue.trim()) return
+    // Submitting while a response streams interrupts it (Claude Code parity)
+    // instead of silently dropping the input.
+    if (isLoading) {
+      onCancel?.()
+    }
     // Save to message history for arrow-key navigation
     setSubmittedHistory((prev) => [...prev, finalValue])
     historyIndexRef.current = -1
@@ -379,7 +294,7 @@ export function InputBar({
   }
 
   // ── Picker mode: CommandPicker overlay ──
-  if (pickerActive && vimMode === 'insert') {
+  if (pickerActive) {
     return (
       <Box flexDirection="column" marginTop={1}>
         <CommandPicker
@@ -403,15 +318,11 @@ export function InputBar({
     <Box flexDirection="column" marginTop={1}>
       <Box>
         <Box marginRight={1}>
-          <Text color={vimMode === 'normal' ? 'magenta' : isLoading ? 'yellow' : 'cyan'}>
-            {vimMode === 'normal' ? ':' : '>'}
-          </Text>
+          <Text color={isLoading ? 'yellow' : 'cyan'}>{'>'}</Text>
         </Box>
         <TextInput
           value={value}
           onChange={(val) => {
-            // Block text changes during search mode — keys go to search query
-            if (searchMode) return
             // Reset history browsing when user starts typing
             if (historyIndexRef.current !== -1) {
               historyIndexRef.current = -1
@@ -420,11 +331,18 @@ export function InputBar({
             // Normalize newlines → spaces. ink-text-input is single-line; multi-line
             // paste would trap arrow-key navigation on the first line.
             const normalized = val.replace(/\n/g, ' ')
-            // Throttle: first keystroke renders immediately, then batch at ~30fps.
-            // During paste, the terminal may send hundreds of characters in rapid
-            // succession — without throttling, each triggers a React render+Ink write
-            // cycle that starves the event loop and freezes the UI.
+            // 批量输入（paste/IME 替换）节流防渲染风暴；普通单字符输入立即显示，
+            // 避免 33ms trailing 的「慢半拍」尾巴。
+            const bulk = isBulkInput(valueRef.current, normalized)
             valueRef.current = normalized
+            if (!bulk) {
+              if (onChangeTimerRef.current) {
+                clearTimeout(onChangeTimerRef.current)
+                onChangeTimerRef.current = null
+              }
+              setValue(normalized)
+              return
+            }
             if (onChangeTimerRef.current) return // timer pending, latest value in ref
             setValue(normalized)
             onChangeTimerRef.current = setTimeout(() => {
@@ -434,20 +352,12 @@ export function InputBar({
           }}
           onSubmit={handleSubmit}
           placeholder={
-            searchMode
-              ? `/${searchQuery}`
-              : vimMode === 'normal'
-                ? t('ui.input.vim_help')
-                : isLoading
-                  ? `${verb}...`
-                  : completionVerb
-                    ? completionVerb
-                    : t('ui.input.placeholder')
+            isLoading ? `${verb}...` : completionVerb ? completionVerb : t('ui.input.placeholder')
           }
         />
       </Box>
-      {/* Slash command hints — shown when typing / in INSERT mode (only when picker is NOT active) */}
-      {slashHints.length > 0 && vimMode === 'insert' && !pickerActive && (
+      {/* Slash command hints — shown when typing / (only when picker is NOT active) */}
+      {slashHints.length > 0 && !pickerActive && (
         <Box marginTop={1} flexDirection="column" gap={1}>
           <Text dimColor>{t('ui.slash_hints.label')} </Text>
           {slashHints.map((cmd, _i) => (
@@ -468,7 +378,7 @@ export function InputBar({
         </Box>
       )}
       {/* @mention hints — active sessions (cross-session messaging) */}
-      {mentionHints.length > 0 && vimMode === 'insert' && !pickerActive && (
+      {mentionHints.length > 0 && !pickerActive && (
         <Box marginTop={1} flexDirection="column" gap={1}>
           <Text dimColor>{t('ui.mention_hints.label')} </Text>
           {mentionHints.map((name) => (

package/src/ui/vim-motions.ts

@@ -1,113 +0,0 @@
-export type VimMode = 'insert' | 'normal'
-
-export class VimMotionEngine {
-  mode: VimMode = 'insert'
-  private clipboard = ''
-  private undoStack: string[] = []
-
-  /** Handle a keypress in normal mode. Returns new cursor position delta and any text mutation. */
-  handleNormal(key: string, text: string, cursor: number): VimAction | null {
-    switch (key) {
-      case 'h':
-        return { cursor: cursor - 1 }
-      case 'j':
-        return { cursor: text.length } // end of line (like $)
-      case 'k':
-        return { cursor: 0 } // start of line (like 0)
-      case 'l':
-        return { cursor: cursor + 1 }
-      case '0':
-        return { cursor: 0 }
-      case '$':
-        return { cursor: text.length }
-      case 'w':
-        return { cursor: this.nextWord(text, cursor) }
-      case 'b':
-        return { cursor: this.prevWord(text, cursor) }
-      case 'd':
-        return { pending: 'd' }
-      case 'y':
-        return { pending: 'y' }
-      default:
-        return null
-    }
-  }
-
-  /** Handle dd — delete entire line */
-  handleDD(text: string): VimAction {
-    this.clipboard = text
-    this.pushUndo(text)
-    return { text: '', cursor: 0 }
-  }
-
-  /** Handle yy — yank entire line */
-  handleYY(text: string): VimAction {
-    this.clipboard = text
-    return { cursor: 0 } // no change
-  }
-
-  /** Handle p — paste after cursor */
-  handlePaste(text: string, cursor: number): VimAction {
-    const newText = text.slice(0, cursor) + this.clipboard + text.slice(cursor)
-    this.pushUndo(text)
-    return { text: newText, cursor: cursor + this.clipboard.length }
-  }
-
-  /** Handle u — undo */
-  handleUndo(text: string): VimAction {
-    const prev = this.undoStack.pop()
-    if (prev !== undefined) {
-      return { text: prev, cursor: prev.length }
-    }
-    return { cursor: text.length }
-  }
-
-  /** Handle /search */
-  handleSearch(text: string, query: string): VimAction {
-    const idx = text.indexOf(query)
-    return idx >= 0 ? { cursor: idx } : { cursor: 0 }
-  }
-
-  private nextWord(text: string, cursor: number): number {
-    // Skip word characters, then skip whitespace
-    let i = cursor
-    while (i < text.length && text[i] !== ' ') i++
-    while (i < text.length && text[i] === ' ') i++
-    return i
-  }
-
-  private prevWord(text: string, cursor: number): number {
-    let i = cursor - 1
-    while (i > 0 && text[i] === ' ') i--
-    while (i > 0 && text[i] !== ' ') i--
-    return i > 0 ? i + 1 : 0
-  }
-
-  private pushUndo(text: string): void {
-    this.undoStack.push(text)
-    if (this.undoStack.length > 50) this.undoStack.shift()
-  }
-}
-
-export interface VimAction {
-  text?: string
-  cursor?: number
-  pending?: string
-}
-
-export interface SearchBackspaceResult {
-  query: string
-  /** true → the `/` prefix should be removed by exiting search mode */
-  exit: boolean
-}
-
-/**
- * Backspace while in `/` search mode.
- * Trims the query; when the query is already empty, signals that search mode
- * should exit so the `/` placeholder disappears (the user can "delete" the
- * slash instead of being trapped).
- */
-export function handleSearchBackspace(query: string): SearchBackspaceResult {
-  if (query.length === 0) return { query: '', exit: true }
-  return { query: query.slice(0, -1), exit: false }
-}