@miphamai/cli 0.31.1 → 0.32.1

package/src/index.tsx

@@ -47,6 +47,13 @@ import enUS from './i18n-core/locales/en-US.json' with { type: 'json' }
 import zhCN from './i18n-core/locales/zh-CN.json' with { type: 'json' }
 import type { TranslationMap } from './i18n-core/types'
 
+// Locale bundles — defined at module level so the remote-attach branch can
+// reference them before the full bootstrap path runs.
+const localeBundles: Record<string, TranslationMap> = {
+  'en-US': enUS as TranslationMap,
+  'zh-CN': zhCN as TranslationMap,
+}
+
 interface RunOptions {
   model?: string
   provider?: string
@@ -54,6 +61,8 @@ interface RunOptions {
   permission?: string
   resume?: string
   version?: string
+  /** When set, launch TUI in remote mode connected to a daemon session. */
+  remoteSession?: { sessionId: string; port: number; token: string }
 }
 
 /**
@@ -183,6 +192,41 @@ export async function runApp(options: RunOptions): Promise<void> {
   // ── Workspace Trust Check ──
   await checkWorkspaceTrust()
 
+  // ── Remote attach mode ──────────────────────────────────────────────────
+  // When the TUI is launched via `mipham attach`, skip the entire local
+  // engine bootstrap and connect to the daemon via WebSocket instead.
+  if (options.remoteSession) {
+    const { RemoteEngine } = await import('./daemon/remote-engine')
+    const engine = new RemoteEngine(options.remoteSession)
+
+    // Detect locale and create translation function (same as local path)
+    const locale = detectLocale({ lang: options.lang })
+    const t = createT(localeBundles[locale] || enUS, enUS)
+
+    // Set terminal window title
+    process.stdout.write('\x1b]0;Mipham Code\x07')
+
+    const { waitUntilExit } = render(
+      React.createElement(I18nProvider, {
+        locale,
+        t,
+        children: React.createElement(App, {
+          engine,
+          config: {} as MiphamConfig,
+          initialProvider: 'remote',
+          initialModel: 'remote',
+          version: options.version,
+          sessionId: options.remoteSession.sessionId,
+        }),
+      }),
+    )
+    await waitUntilExit()
+
+    // Close the WebSocket connection on the way out
+    engine.close()
+    return
+  }
+
   // Handle `mipham agents` subcommand — launch standalone dashboard
   const args = process.argv.slice(2)
   if (args[0] === 'agents') {
@@ -208,10 +252,6 @@ export async function runApp(options: RunOptions): Promise<void> {
 
   // Detect locale and create translation function
   const locale = detectLocale({ lang: options.lang })
-  const localeBundles: Record<string, TranslationMap> = {
-    'en-US': enUS as TranslationMap,
-    'zh-CN': zhCN as TranslationMap,
-  }
   const t = createT(localeBundles[locale] || enUS, enUS)
 
   // Bootstrap providers

package/src/ui/app.tsx

@@ -3,6 +3,7 @@ import { Box, Text, useInput } from 'ink'
 import TextInput from 'ink-text-input'
 import { readFileSync } from 'node:fs'
 import type { QueryEngine } from '../core/engine'
+import type { RemoteEngine } from '../daemon/remote-engine'
 import type { MiphamConfig } from '../shared/index.ts'
 import type { SkillsLoader } from '../skills/loader'
 import type { PluginManager } from '../plugin/plugin-manager'
@@ -29,7 +30,7 @@ import type { PermissionMode } from '../shared/index.ts'
 import { sanitizeForDisplay } from '../shared/sanitize.ts'
 
 interface AppProps {
-  engine: QueryEngine
+  engine: QueryEngine | RemoteEngine
   config: MiphamConfig
   initialProvider?: string
   initialModel?: string
@@ -265,7 +266,10 @@ export function App({
 
   const mkCtx = useCallback(
     (): CommandContext => ({
-      engine,
+      // In remote attach mode, RemoteEngine provides stub methods for all the
+      // QueryEngine APIs that slash commands need. The cast is safe because
+      // stubs cover every method that CommandContext consumers call.
+      engine: engine as QueryEngine,
       config,
       providerId,
       modelId,

package/src/ui/chat.tsx

@@ -157,52 +157,58 @@ export function ChatPanel({ messages, focusMode }: ChatPanelProps) {
 }
 
 /**
- * Group consecutive tool calls into compact one-liners for the normal view.
- * Single tools show normally; 2+ consecutive tools get folded:
- *   ⏺ Read · Glob · Bash (3 tools)
+ * Pair each tool_use message with its following tool_result message(s),
+ * showing every tool individually with its name, detail, and output.
+ *
+ * Claude Code parity: each tool renders as:
+ *   ⏺ ToolName (detail)        ← colored per tool type
+ *     ⎿  output summary          ← dimmed below
+ *
+ * Only true duplicates (same tool name + same detail) are collapsed
+ * into a single entry with a count.
  */
 function compactToolGroups(messages: ChatMessage[]): ChatMessage[] {
   const result: ChatMessage[] = []
-  let toolGroup: ChatMessage[] = []
+  let current: ChatMessage | null = null
 
-  const flush = () => {
-    if (toolGroup.length === 0) return
-    if (toolGroup.length === 1) {
-      result.push(toolGroup[0]!)
-    } else {
-      const names = toolGroup
-        .filter((t) => t.toolMeta?.name && !t.toolMeta.name.startsWith('tools ('))
-        .map((t) => t.toolMeta!.name)
-      const uniqueNames = [...new Set(names)]
-      result.push({
-        role: 'system',
-        content: `⏺ ${uniqueNames.join(' · ')} (${names.length} tools)`,
-        toolMeta: {
-          name: `tools (${names.length})`,
-          input: uniqueNames.join(', '),
-          collapsed: true,
-        },
-      })
+  for (const msg of messages) {
+    // Tool call with a name → flush previous, start a new one
+    if (msg.toolMeta?.name && !msg.toolMeta.name.startsWith('tools (')) {
+      if (current) result.push(current)
+      current = { ...msg }
+      continue
     }
-    toolGroup = []
-  }
 
-  for (const msg of messages) {
-    // Tool results (no name, has output) get folded into the preceding tool group
+    // Tool result (no name, has output) → merge output into current tool
     if (msg.toolMeta && !msg.toolMeta.name && msg.toolMeta.output) {
-      toolGroup.push(msg)
+      if (current) {
+        current = {
+          ...current,
+          content: msg.content,
+          toolMeta: {
+            ...current.toolMeta!,
+            output: msg.toolMeta.output,
+          },
+        }
+      }
+      // Orphan tool result (no preceding tool_use) → skip
       continue
     }
-    // Tool calls with a name
-    if (msg.toolMeta?.name && !msg.toolMeta.name.startsWith('tools (')) {
-      toolGroup.push(msg)
+
+    // Already-grouped message (from a previous compact cycle) or non-tool
+    if (current) {
+      result.push(current)
+      current = null
+    }
+    // Skip orphan tool-result messages without a preceding tool_use
+    if (msg.toolMeta && !msg.toolMeta.name && msg.toolMeta.output) {
       continue
     }
-    // Already-grouped or non-tool message
-    flush()
     result.push(msg)
   }
-  flush()
+
+  // Flush any remaining tool
+  if (current) result.push(current)
   return result
 }