@miphamai/cli 0.85.4 → 0.85.5

package/src/ui/picker.tsx

@@ -1,8 +1,15 @@
 import React, { useState, useCallback } from 'react'
 import { Box, Text, useInput } from 'ink'
 import { useI18n } from '../i18n-context'
+import { useKeyState } from './use-key-state'
 import type { MiphamConfig, ProviderConfig } from '../shared/index.ts'
 
+/** 环绕取模 —— 列表两端互为首尾。 */
+const wrap = (i: number, len: number) => ((i % len) + len) % len
+
+/** 只列启用中的模型（与 `providerList` 的 `upcoming` 过滤同一条口径）。 */
+const activeModels = (p: ProviderConfig) => p.models.filter((m) => m.status === 'active')
+
 interface PickerProps {
   config: MiphamConfig
   currentProvider: string
@@ -25,54 +32,58 @@ export function ModelPicker({
   const { t } = useI18n()
   // Get active providers only
   const providers = config.providers.filter((p) => p.status !== 'upcoming')
-  const activeModels = (p: ProviderConfig) => p.models.filter((m) => m.status === 'active')
 
   // State
   const [activePanel, setActivePanel] = useState<Panel>('provider')
-  const [providerIdx, setProviderIdx] = useState(() => {
+  // 光标走 `useKeyState`：一组按键可能在同一拍里到达（↓ 之后紧跟 Enter），判据必须
+  // 读得到本次按键刚写下的那个索引，而不是上一张闭包里的。
+  const providerIdx = useKeyState(() => {
     const idx = providers.findIndex((p) => p.id === currentProvider)
     return idx >= 0 ? idx : 0
   })
-  const [modelIdx, setModelIdx] = useState(0)
+  const modelIdx = useKeyState(0)
 
-  const selectedProvider = providers[providerIdx]
+  const selectedProvider = providers[providerIdx.value]
   const models = selectedProvider ? activeModels(selectedProvider) : []
 
   // Reset model index when provider changes
   const goToProvider = useCallback(
     (idx: number) => {
-      const wrapped = ((idx % providers.length) + providers.length) % providers.length
-      setProviderIdx(wrapped)
-      setModelIdx(0)
+      providerIdx.set(wrap(idx, providers.length))
+      modelIdx.set(0)
       setActivePanel('model') // auto-switch to model panel
     },
-    [providers.length],
+    [providers.length, providerIdx, modelIdx],
   )
 
-  const selectModel = useCallback(
-    (idx: number) => {
+  /** 相对移动 —— 按 `read()` 叠加，同一拍里的两次 ↓ 就是两步。 */
+  const stepModel = useCallback(
+    (delta: number) => {
       if (!selectedProvider) return
-      const wrapped = ((idx % models.length) + models.length) % models.length
-      setModelIdx(wrapped)
+      const len = models.length
+      if (len === 0) return
+      modelIdx.set((prev) => wrap(prev + delta, len))
     },
-    [selectedProvider, models.length],
+    [selectedProvider, models.length, modelIdx],
   )
 
   const confirmSelection = useCallback(() => {
-    if (!selectedProvider) return
-    const model = models[modelIdx]
+    // 按 `read()` 取当前光标，而不是渲染时那份闭包 —— 否则「↓ Enter」确认的是上一行。
+    const provider = providers[providerIdx.read()]
+    if (!provider) return
+    const model = activeModels(provider)[modelIdx.read()]
     if (model) {
       // Check API key before confirming switch
-      const apiKey = selectedProvider.apiKey
+      const apiKey = provider.apiKey
       if (!apiKey || apiKey.trim() === '' || /^\$\{[A-Z_]+\}$/.test(apiKey.trim())) {
-        if (selectedProvider.id !== 'ollama' && onNeedsApiKey) {
-          onNeedsApiKey(selectedProvider.id, model.id, selectedProvider.name)
+        if (provider.id !== 'ollama' && onNeedsApiKey) {
+          onNeedsApiKey(provider.id, model.id, provider.name)
           return
         }
       }
-      onSelect(selectedProvider.id, model.id)
+      onSelect(provider.id, model.id)
     }
-  }, [selectedProvider, models, modelIdx, onSelect, onNeedsApiKey])
+  }, [providers, providerIdx, modelIdx, onSelect, onNeedsApiKey])
 
   useInput((input, key) => {
     // Global keys
@@ -83,7 +94,7 @@ export function ModelPicker({
 
     if (key.return) {
       if (activePanel === 'provider') {
-        goToProvider(providerIdx) // switches to model panel
+        goToProvider(providerIdx.read()) // switches to model panel
       } else {
         confirmSelection()
       }
@@ -105,18 +116,18 @@ export function ModelPicker({
     // Up/Down navigation
     if (key.upArrow) {
       if (activePanel === 'provider') {
-        setProviderIdx((providerIdx - 1 + providers.length) % providers.length)
+        providerIdx.set((prev) => wrap(prev - 1, providers.length))
       } else {
-        selectModel(modelIdx - 1)
+        stepModel(-1)
       }
       return
     }
 
     if (key.downArrow) {
       if (activePanel === 'provider') {
-        setProviderIdx((providerIdx + 1) % providers.length)
+        providerIdx.set((prev) => wrap(prev + 1, providers.length))
       } else {
-        selectModel(modelIdx + 1)
+        stepModel(1)
       }
       return
     }
@@ -150,7 +161,7 @@ export function ModelPicker({
           </Text>
           {providers.map((p, i) => {
             const isCurrent = p.id === currentProvider
-            const isSelected = i === providerIdx
+            const isSelected = i === providerIdx.value
             const isUpcoming = p.status === 'upcoming'
             return (
               <Box key={p.id}>
@@ -185,7 +196,7 @@ export function ModelPicker({
           {models.length === 0 && <Text dimColor> {t('ui.picker.no_active_models')}</Text>}
           {models.map((m, i) => {
             const isCurrentModel = selectedProvider?.id === currentProvider && m.id === currentModel
-            const isSelected = i === modelIdx
+            const isSelected = i === modelIdx.value
             return (
               <Box key={m.id} flexDirection="column">
                 <Text

package/src/ui/use-key-state.ts

@@ -0,0 +1,55 @@
+import { useCallback, useRef, useState } from 'react'
+
+/**
+ * 一个状态 + 一个「在同一次按键回调里也读得到最新值」的镜像。
+ *
+ * 为什么需要它：一组按键会在同一个 chunk 里到达（远端/远程控制，或键盘把
+ * 「↓ 然后 Enter」一起写进来），Ink 的输入解析器会把这种转义序列打头的 chunk
+ * 切开**逐个派发** —— 而 React 还没提交第一个回调里的 setState，第二个回调拿到的
+ * 就还是上一张闭包。于是「↓ Enter」按在**按下 ↓ 之前**那一行上：按键有反应，
+ * 世界却是上一拍的。
+ *
+ * 与 `useCtrlCConfirm` 的两条路同源（那里的 `isArmed()` / `armed`）：
+ * - `value` 只给渲染用；
+ * - `read()` 给判据用 —— 同步读数，同一次按键回调里 `set()` 之后立刻为新值；
+ * - `set()` 接受函数式写法，并按 `read()` 的当前值求值，于是同一个 burst 里的多次
+ *   修改能**叠加**（两次 ↓ 是两步，而不是把两次都算在同一个起点上）。
+ *
+ * 注意 `set()` 之外不要再写这个 state —— 绕过它写会让镜像与真值分叉。
+ */
+export interface KeyState<T> {
+  /** 渲染用。 */
+  value: T
+  /**
+   * 写入。函数式写法按 `read()` 求值后落盘：同一个 burst 里调用多次会依次叠加。
+   *
+   * `T` 是函数时函数式写法不可用（按值处理）—— 本仓库的调用点都是索引/枚举。
+   */
+  set: (next: T | ((prev: T) => T)) => void
+  /** 判据用：同步读数，`set()` 之后立刻为新值。 */
+  read: () => T
+}
+
+export function useKeyState<T>(initial: T | (() => T)): KeyState<T> {
+  const [value, setValue] = useState(initial)
+  const ref = useRef(value)
+
+  const set = useCallback((next: T | ((prev: T) => T)) => {
+    const resolved = typeof next === 'function' ? (next as (prev: T) => T)(ref.current) : next
+    ref.current = resolved
+    setValue(resolved)
+  }, [])
+
+  const read = useCallback(() => ref.current, [])
+
+  // 返回的对象**身份稳定**（每次渲染只刷新 `.value`）：调用点会把它整个放进依赖
+  // 数组，每次渲染换一个身份会让依赖它的 effect 每次都重跑。
+  const apiRef = useRef<KeyState<T> | null>(null)
+  let api = apiRef.current
+  if (!api) {
+    api = { value, set, read }
+    apiRef.current = api
+  }
+  api.value = value
+  return api
+}

package/src/daemon/message-bus.ts

@@ -1,84 +0,0 @@
-// apps/cli/src/daemon/message-bus.ts — Phase 3: Inter-Agent Message Bus
-//
-// MessageBus provides asynchronous message passing between agents:
-//   - send()    — enqueue a message from one agent to another
-//   - poll()    — retrieve and clear pending messages (discards TTL-expired)
-//   - broadcastToSession() — send a message to all agents in a session
-//
-// Messages older than 5 minutes are automatically discarded on poll.
-// Session-to-agent mapping is maintained externally via registerAgent/unregisterAgent.
-
-interface BusMessage {
-  sender: string
-  content: string
-  timestamp: number
-}
-
-export class MessageBus {
-  private queues = new Map<string, BusMessage[]>()
-  private sessionAgents = new Map<string, Set<string>>()
-  private readonly ttlMs = 5 * 60 * 1000 // 5 minutes
-
-  /**
-   * Register an agent to a session so that broadcastToSession can reach it.
-   */
-  registerAgent(sessionId: string, agentId: string): void {
-    if (!this.sessionAgents.has(sessionId)) {
-      this.sessionAgents.set(sessionId, new Set())
-    }
-    this.sessionAgents.get(sessionId)!.add(agentId)
-  }
-
-  /**
-   * Remove an agent from all session registrations and clear its message queue.
-   */
-  unregisterAgent(agentId: string): void {
-    for (const [, agents] of this.sessionAgents) {
-      agents.delete(agentId)
-    }
-    this.queues.delete(agentId)
-  }
-
-  /**
-   * Enqueue a message from senderAgentId to receiverAgentId.
-   */
-  send(senderAgentId: string, receiverAgentId: string, content: string): void {
-    if (!this.queues.has(receiverAgentId)) {
-      this.queues.set(receiverAgentId, [])
-    }
-    this.queues.get(receiverAgentId)!.push({
-      sender: senderAgentId,
-      content,
-      timestamp: Date.now(),
-    })
-  }
-
-  /**
-   * Retrieve and clear all pending messages for an agent.
-   * Messages older than the TTL (5 min) are discarded.
-   */
-  poll(agentId: string): BusMessage[] {
-    const queue = this.queues.get(agentId)
-    if (!queue || queue.length === 0) return []
-
-    const now = Date.now()
-    const valid = queue.filter((msg) => now - msg.timestamp < this.ttlMs)
-
-    this.queues.delete(agentId)
-    return valid
-  }
-
-  /**
-   * Send a message to every agent in a session except the one specified.
-   * The sender is recorded as 'system'.
-   */
-  broadcastToSession(sessionId: string, content: string, excludeAgentId?: string): void {
-    const agents = this.sessionAgents.get(sessionId)
-    if (!agents) return
-    for (const agentId of agents) {
-      if (agentId !== excludeAgentId) {
-        this.send('system', agentId, content)
-      }
-    }
-  }
-}