@miphamai/cli 0.16.1 → 0.16.3

package/bin/mipham.ts

@@ -331,6 +331,32 @@ async function main() {
     process.exit(0)
   }
 
+  // ── Help flag ─────────────────────────────────────────────────────────────
+  if (
+    process.argv.includes('--help') ||
+    process.argv.includes('-h') ||
+    process.argv.slice(2).some((a) => a === 'help')
+  ) {
+    console.log(`Mipham Code — AI-powered coding terminal
+
+Usage:
+  mipham                     Launch interactive CLI
+  mipham update              Update to the latest version
+  mipham upgrade             Same as 'mipham update'
+  mipham plugin <cmd>        Plugin management (install, list, remove, etc.)
+  mipham workflow <cmd>      Workflow orchestration (run, list, resume, etc.)
+  mipham --version           Print version and exit
+  mipham --help              Show this help
+
+Flags:
+  --safe-mode                Skip custom agents, skills, hooks, plugins
+  --version, -v, -V          Print version
+
+Docs: https://mipham.ai/code
+npm:  https://www.npmjs.com/package/@miphamai/cli`)
+    process.exit(0)
+  }
+
   // ── Update / upgrade ──────────────────────────────────────────────────────
   const handledUpdate = await runUpdate()
   if (handledUpdate) return
@@ -343,6 +369,41 @@ async function main() {
   const handled = await runWorkflowCLI()
   if (handled) return
 
+  // ── Unknown command detection ──────────────────────────────────────────────
+  // After all known subcommands are checked, any remaining positional argument
+  // is probably a typo. Show error + suggestions instead of silently launching CLI.
+  const KNOWN_COMMANDS = ['update', 'upgrade', 'plugin', 'workflow', 'help']
+  const firstArg = process.argv.slice(2).find((a) => !a.startsWith('-'))
+  if (firstArg) {
+    // Levenshtein distance to find closest match
+    const distance = (a: string, b: string): number => {
+      const m = a.length
+      const n = b.length
+      const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0))
+      for (let i = 0; i <= m; i++) dp[i]![0] = i
+      for (let j = 0; j <= n; j++) dp[0]![j] = j
+      for (let i = 1; i <= m; i++)
+        for (let j = 1; j <= n; j++)
+          dp[i]![j] =
+            a[i - 1] === b[j - 1]
+              ? dp[i - 1]![j - 1]!
+              : 1 + Math.min(dp[i - 1]![j]!, dp[i]![j - 1]!, dp[i - 1]![j - 1]!)
+      return dp[m]![n]!
+    }
+
+    const best = KNOWN_COMMANDS.map((cmd) => ({ cmd, dist: distance(firstArg, cmd) }))
+      .filter((c) => c.dist <= 3)
+      .sort((a, b) => a.dist - b.dist)
+    const suggestions = best.map((c) => `'mipham ${c.cmd}'`).join(', ')
+
+    console.error(`Unknown command: mipham ${firstArg}`)
+    if (suggestions) {
+      console.error(`Did you mean: ${suggestions}?`)
+    }
+    console.error(`Run 'mipham --help' for usage.`)
+    process.exit(1)
+  }
+
   // Parse --safe-mode flag: skip custom agents, skills, hooks, plugins
   const safeModeFlag = process.argv.includes('--safe-mode')
   if (safeModeFlag) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.16.1",
+  "version": "0.16.3",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",
@@ -42,6 +42,7 @@
     "test": "vitest run"
   },
   "dependencies": {
+    "commander": "^13.1.0",
     "ink": "^5.2.1",
     "ink-text-input": "^6.0.0",
     "react": "^18.3.1",

package/src/ui/app.tsx

@@ -68,12 +68,12 @@ const PERMISSION_MODES: PermissionMode[] = [
   'bypassPermissions',
 ]
 const PERMISSION_LABELS: Record<PermissionMode, string> = {
-  default: 'default · reads free',
-  acceptEdits: 'accept edits · reads + edits free',
+  default: 'reads free',
+  acceptEdits: 'accept edits on',
   plan: 'plan mode · read-only',
-  auto: 'auto mode · hooks gate',
-  dontAsk: "don't ask · pre-approved only",
-  bypassPermissions: 'bypass · skip all checks',
+  auto: 'auto mode',
+  dontAsk: "don't ask",
+  bypassPermissions: 'bypass',
 }
 const PERMISSION_COLORS: Record<PermissionMode, string> = {
   default: 'white',
@@ -500,7 +500,8 @@ export function App({
   )
 
   useInput((_input, key) => {
-    // Global hotkeys
+    // Escape: close picker → abort loading (does NOT exit app)
+    // Vim mode toggle is handled by InputBar
     if (key.escape) {
       if (pickerOpen) {
         setPickerOpen(false)
@@ -510,57 +511,12 @@ export function App({
         abortRef.current.abort()
         return
       }
-      process.exit(0)
-    }
-    // Ctrl+P → open model picker
-    if (_input === '\x10') {
-      setPickerOpen((prev) => !prev)
-      return
-    }
-    // Ctrl+F → toggle focus mode
-    if (_input === '\x06') {
-      setFocusMode((prev) => !prev)
-      return
-    }
-    // Ctrl+O → toggle last tool call expand/collapse
-    if (_input === '\x0f') {
-      setMessages((prev) => {
-        const msgs = [...prev]
-        for (let i = msgs.length - 1; i >= 0; i--) {
-          if (msgs[i]?.toolMeta) {
-            const meta = msgs[i]!.toolMeta!
-            if (meta.collapsed) {
-              msgs[i] = {
-                ...msgs[i]!,
-                content: `🔧 ${meta.name}: ${meta.input}\n📋 Result: ${meta.output || '(pending)'}`,
-                toolMeta: { ...meta, collapsed: false },
-              }
-            } else {
-              const short = meta.input.length > 50 ? meta.input.slice(0, 50) + '...' : meta.input
-              msgs[i] = {
-                ...msgs[i]!,
-                content: `⏺ ${meta.name} · ${short} (Ctrl+O to expand)`,
-                toolMeta: { ...meta, collapsed: true },
-              }
-            }
-            break
-          }
-        }
-        return msgs
-      })
-      return
-    }
-    // Shift+Tab → cycle through all 6 permission modes
-    if (key.shift && key.tab) {
-      setPermissionMode((prev) => {
-        const idx = PERMISSION_MODES.indexOf(prev)
-        const next = PERMISSION_MODES[(idx + 1) % PERMISSION_MODES.length]!
-        // Sync to engine — use setMode for proper mode semantics
-        engine.getPermission().setMode(next)
-        return next
-      })
+      // When input is empty and not loading, let InputBar handle Escape
+      // (it toggles vim mode or clears pending sequences)
       return
     }
+    // All other global hotkeys (Shift+Tab, Ctrl+P, Ctrl+F, Ctrl+O)
+    // are handled in InputBar to avoid ink-text-input conflicts
   })
 
   return (
@@ -599,7 +555,52 @@ export function App({
         /* Input bar (hidden when picker is open) */
         <Box flexDirection="column">
           <Text dimColor>──────────────────────────────</Text>
-          <InputBar onSubmit={handleSubmit} isLoading={isLoading} />
+          <InputBar
+            onSubmit={handleSubmit}
+            isLoading={isLoading}
+            onTogglePicker={() => setPickerOpen((prev) => !prev)}
+            onToggleFocus={() => setFocusMode((prev) => !prev)}
+            onToggleExpand={() => {
+              setMessages((prev) => {
+                const msgs = [...prev]
+                for (let i = msgs.length - 1; i >= 0; i--) {
+                  if (msgs[i]?.toolMeta) {
+                    const meta = msgs[i]!.toolMeta!
+                    if (meta.collapsed) {
+                      msgs[i] = {
+                        ...msgs[i]!,
+                        content: `🔧 ${meta.name}: ${meta.input}\n📋 Result: ${meta.output || '(pending)'}`,
+                        toolMeta: { ...meta, collapsed: false },
+                      }
+                    } else {
+                      const short =
+                        meta.input.length > 50 ? meta.input.slice(0, 50) + '...' : meta.input
+                      msgs[i] = {
+                        ...msgs[i]!,
+                        content: `⏺ ${meta.name} · ${short} (Ctrl+O to expand)`,
+                        toolMeta: { ...meta, collapsed: true },
+                      }
+                    }
+                    break
+                  }
+                }
+                return msgs
+              })
+            }}
+            onCyclePermission={() => {
+              setPermissionMode((prev) => {
+                const idx = PERMISSION_MODES.indexOf(prev)
+                const next = PERMISSION_MODES[(idx + 1) % PERMISSION_MODES.length]!
+                engine.getPermission().setMode(next)
+                return next
+              })
+            }}
+            onCancel={() => {
+              if (abortRef.current) {
+                abortRef.current.abort()
+              }
+            }}
+          />
           <Text dimColor>──────────────────────────────</Text>
         </Box>
       )}
@@ -607,7 +608,7 @@ export function App({
       {/* Agent status footer — shows running background agents */}
       <AgentFooter agents={Object.values(runningAgents)} gitBranch={gitBranch} tick={agentTick} />
 
-      {/* Status line */}
+      {/* Status line — Claude Code style: compact, action-oriented */}
       <Box marginTop={1} flexDirection="column">
         {goalText && (
           <Box>
@@ -616,11 +617,10 @@ export function App({
         )}
         <Box flexDirection="row">
           <Text color={PERMISSION_COLORS[permissionMode]}>
-            ● {PERMISSION_LABELS[permissionMode]}
+            ⏵⏵ {PERMISSION_LABELS[permissionMode]} (shift+tab to cycle)
           </Text>
-          <Text dimColor> · Shift+Tab mode</Text>
-          <Text dimColor> · Ctrl+P model · Ctrl+F focus · Ctrl+O expand</Text>
-          <Text dimColor> · Esc cancel · /help · ← agents</Text>
+          <Text dimColor> · Esc to interrupt</Text>
+          <Text dimColor> · ← agents</Text>
         </Box>
       </Box>
     </Box>

package/src/ui/input.tsx

@@ -8,6 +8,16 @@ import { CommandPicker } from './command-picker.js'
 interface InputBarProps {
   onSubmit: (input: string) => void
   isLoading: boolean
+  /** Ctrl+P → open model picker */
+  onTogglePicker?: () => void
+  /** Ctrl+F → toggle focus mode */
+  onToggleFocus?: () => void
+  /** Ctrl+O → expand last tool call */
+  onToggleExpand?: () => void
+  /** Shift+Tab → cycle permission mode */
+  onCyclePermission?: () => void
+  /** Escape → cancel loading (when input is empty) */
+  onCancel?: () => void
 }
 
 // ── Status verbs — English (Claude Code-aligned) + Chinese (Mipham originals) ──
@@ -107,7 +117,15 @@ function pick<T>(arr: T[]): T {
   return arr[Math.floor(Math.random() * arr.length)]!
 }
 
-export function InputBar({ onSubmit, isLoading }: InputBarProps) {
+export function InputBar({
+  onSubmit,
+  isLoading,
+  onTogglePicker,
+  onToggleFocus,
+  onToggleExpand,
+  onCyclePermission,
+  onCancel,
+}: InputBarProps) {
   const [value, setValue] = useState('')
   const [verb, setVerb] = useState(() => pick(STATUS_GERUNDS))
   const [completionVerb, setCompletionVerb] = useState<string | null>(null)
@@ -158,10 +176,19 @@ export function InputBar({ onSubmit, isLoading }: InputBarProps) {
   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).
+  const valueBeforeShortcut = useRef(value)
+  // Keep the ref in sync with state on every change that isn't a Ctrl shortcut revert.
+  useEffect(() => {
+    valueBeforeShortcut.current = value
+  }, [value])
+
   // ── Vim motions: intercept keys in normal mode ──
 
   useInput((input, key) => {
-    // Escape toggles between insert and normal mode
+    // ── Escape: cancel loading → toggle vim mode ──
     if (key.escape) {
       // Cancel search mode if active
       if (searchMode) {
@@ -169,6 +196,11 @@ export function InputBar({ onSubmit, isLoading }: InputBarProps) {
         setSearchQuery('')
         return
       }
+      // Escape while loading → abort (priority over vim toggle)
+      if (isLoading) {
+        onCancel?.()
+        return
+      }
       // Clear any pending multi-key sequence
       if (vimPending.current) {
         vimPending.current = null
@@ -178,6 +210,33 @@ export function InputBar({ onSubmit, isLoading }: InputBarProps) {
       return
     }
 
+    // ── Global hotkeys (work in both insert and normal modes) ──
+    // Shift+Tab → cycle permission mode
+    if (key.shift && key.tab) {
+      onCyclePermission?.()
+      return
+    }
+    // Ctrl+P → toggle model picker
+    // NOTE: Ink passes input=keypress.name (just 'p') when ctrl is true, not raw \x10.
+    // ink-text-input inserts 'p' as literal text — revert it.
+    if (key.ctrl && input === 'p') {
+      setValue(valueBeforeShortcut.current)
+      onTogglePicker?.()
+      return
+    }
+    // Ctrl+F → toggle focus mode
+    if (key.ctrl && input === 'f') {
+      setValue(valueBeforeShortcut.current)
+      onToggleFocus?.()
+      return
+    }
+    // Ctrl+O → expand/collapse last tool call
+    if (key.ctrl && input === 'o') {
+      setValue(valueBeforeShortcut.current)
+      onToggleExpand?.()
+      return
+    }
+
     if (vimEngine.current.mode !== 'normal') return
 
     // Handle search mode — collect query characters