@miphamai/cli 0.45.0 → 0.46.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.45.0",
+  "version": "0.46.0",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",

package/src/shared/package-info.ts

@@ -9,7 +9,7 @@
 export const PACKAGE_NAME = '@miphamai/cli' as const
 
 /** 当前发布版本 */
-export const PACKAGE_VERSION = '0.45.0' as const
+export const PACKAGE_VERSION = '0.46.0' as const
 
 /** npm install 全局安装命令 */
 export const NPM_INSTALL_COMMAND = `npm install -g ${PACKAGE_NAME}` as const

package/src/tools/exec/task.ts

@@ -1,6 +1,6 @@
 import type { ToolDefinition } from '../../shared/index.ts'
 
-interface Task {
+export interface Task {
   id: string
   subject: string
   description: string
@@ -20,6 +20,11 @@ interface Task {
 const tasks = new Map<string, Task>()
 let taskCounter = 0
 
+/** Read accessor for the session task store — returns all non-deleted tasks. */
+export function getTasks(): Task[] {
+  return Array.from(tasks.values()).filter((t) => t.status !== 'deleted')
+}
+
 function formatTask(t: Task): string {
   const meta = t.metadata ? ` ${JSON.stringify(t.metadata)}` : ''
   const blocks = t.blocks.length ? ` blocks:[${t.blocks.join(',')}]` : ''

package/src/tools/file/grep.ts

@@ -1,7 +1,28 @@
-import { $ } from 'bun'
 import type { ToolDefinition } from '../../shared/index.ts'
 import { resolveSafe } from '../../security/path'
 
+/** Grep stall guard: a search over a huge tree (or a pathological regex) must
+ *  not hang the session for minutes. Matches the Bash tool's 120s ceiling. */
+const GREP_TIMEOUT_MS = 120_000
+
+/** Run a search command with a kill-timer; report whether the timeout fired. */
+export async function runSearch(
+  cmd: string[],
+  cwd: string,
+  timeoutMs: number,
+): Promise<{ stdout: string; timedOut: boolean; exitCode: number | null }> {
+  const proc = Bun.spawn(cmd, { cwd, stdout: 'pipe', stderr: 'pipe' })
+  let timedOut = false
+  const timer = setTimeout(() => {
+    timedOut = true
+    proc.kill()
+  }, timeoutMs)
+  const stdout = await new Response(proc.stdout).text()
+  await proc.exited
+  clearTimeout(timer)
+  return { stdout, timedOut, exitCode: proc.exitCode }
+}
+
 export const grepTool: ToolDefinition = {
   name: 'Grep',
   description:
@@ -29,32 +50,52 @@ export const grepTool: ToolDefinition = {
     const searchPath = resolveSafe(ctx.cwd, (params.path as string) || '.')
     const include = params.include as string | undefined
 
+    // 1. ripgrep (fast path)
+    const rgArgs = ['rg', '-n', '--heading', '--color=never', '-M', '500', pattern]
+    if (include) rgArgs.push('--glob', include)
+    rgArgs.push(searchPath)
     try {
-      const args = ['-n', '--heading', '--color=never', '-M', '500', pattern]
-      if (include) args.push('--glob', include)
-      args.push(searchPath)
-
-      const result = await $`rg ${args}`.cwd(ctx.cwd).quiet().text()
-      return { success: true, content: result || '(no matches)' }
-    } catch (err: unknown) {
-      const exitErr = err as { exitCode?: number }
-      if (exitErr.exitCode === 1) {
-        return { success: true, content: '(no matches)' }
-      }
-      // Fallback to grep
-      try {
-        const content = await $`grep -rn ${pattern} ${searchPath}`.cwd(ctx.cwd).quiet().text()
+      const { stdout, timedOut, exitCode } = await runSearch(rgArgs, ctx.cwd, GREP_TIMEOUT_MS)
+      if (timedOut) {
         return {
-          success: true,
-          content: content.slice(0, 50000) || '(no matches)',
+          success: false,
+          content: '',
+          error: `Grep timed out after ${GREP_TIMEOUT_MS / 1000}s — narrow scope with "path" and "include".`,
         }
-      } catch {
+      }
+      if (exitCode === 1) return { success: true, content: '(no matches)' }
+      if (exitCode === 0) return { success: true, content: stdout || '(no matches)' }
+      // rg exit 2 (error) or null (killed) → fall through to grep
+    } catch {
+      // rg not installed → fall through to grep
+    }
+
+    // 2. fallback to plain grep
+    const grepArgs = ['grep', '-rn', pattern, searchPath]
+    try {
+      const { stdout, timedOut, exitCode } = await runSearch(grepArgs, ctx.cwd, GREP_TIMEOUT_MS)
+      if (timedOut) {
         return {
           success: false,
           content: '',
-          error: 'grep failed. Install ripgrep: brew install ripgrep',
+          error: `Grep timed out after ${GREP_TIMEOUT_MS / 1000}s — narrow scope with "path" and "include".`,
         }
       }
+      if (exitCode === 1) return { success: true, content: '(no matches)' }
+      if (exitCode === 0) {
+        return { success: true, content: stdout.slice(0, 50000) || '(no matches)' }
+      }
+      return {
+        success: false,
+        content: '',
+        error: 'grep failed. Install ripgrep: brew install ripgrep',
+      }
+    } catch {
+      return {
+        success: false,
+        content: '',
+        error: 'grep failed. Install ripgrep: brew install ripgrep',
+      }
     }
   },
 }

package/src/ui/app.tsx

@@ -20,6 +20,7 @@ import { AgentFooter, type AgentEntry } from './agent-footer'
 import { AgentViewDashboard } from '../agent-view/dashboard'
 import type { AgentViewManager } from '../agent-view/agent-view-manager'
 import { WorkflowProgress } from './workflow-progress.js'
+import { GoalProgress } from './goal-progress.js'
 import {
   getCommand,
   looksLikeSlashCommand,
@@ -828,6 +829,17 @@ export function App({
         {/* Workflow progress — auto-detects active workflows, renders nothing when idle */}
         <WorkflowProgress />
 
+        {/* Goal progress — live goal + subtasks + done/total · elapsed · tokens (auto-hides when no goal) */}
+        <GoalProgress
+          goal={goalText}
+          getTokens={() => {
+            const tracker = engine.getUsageTracker()
+            if (!tracker) return 0
+            if ('totalApiTokens' in tracker) return tracker.totalApiTokens
+            return Object.values(tracker.getStats()).reduce((a, b) => a + b, 0)
+          }}
+        />
+
         {/* Agent View Dashboard — Ctrl+G overlay (replaces chat + input) */}
         {agentViewOpen && agentViewManager ? (
           <AgentViewDashboard
@@ -935,11 +947,6 @@ export function App({
 
             {/* Status line — Claude Code style */}
             <Box marginTop={1} flexDirection="column">
-              {goalText && (
-                <Box>
-                  <Text color="green">🎯 Goal: {goalText}</Text>
-                </Box>
-              )}
               <Box flexDirection="row">
                 <Text color={PERMISSION_COLORS[permissionMode]}>
                   ⏵⏵ {PERMISSION_LABELS[permissionMode]}

package/src/ui/chat.tsx

@@ -83,6 +83,10 @@ const MessageRow = React.memo(
               <Text bold color="green">
                 ▸ {displayCwd()}:
               </Text>
+            ) : msg.role === 'assistant' ? (
+              <Text bold color="magenta">
+                ◆ {t('ui.assistant.role_label')}:
+              </Text>
             ) : msg.role === 'system' ? (
               <Text bold color="yellow">
                 ⚠ {t('ui.system.role_label')}:

package/src/ui/goal-progress.tsx

@@ -0,0 +1,137 @@
+import { useState, useEffect, useRef } from 'react'
+import { Box, Text } from 'ink'
+import { getTasks } from '../tools/exec/task.js'
+import type { Task } from '../tools/exec/task.js'
+
+export interface GoalProgressProps {
+  goal: string
+  /** Read current session token total; defaults to 0. */
+  getTokens?: () => number
+  /** Read current tasks; defaults to the real task store. */
+  listTasks?: () => Task[]
+}
+
+export interface TaskSummary {
+  total: number
+  done: number
+  inProgress: number
+  pending: number
+  failed: number
+}
+
+/** Count tasks by status, ignoring deleted. */
+export function summarizeTasks(tasks: Task[]): TaskSummary {
+  const summary: TaskSummary = { total: 0, done: 0, inProgress: 0, pending: 0, failed: 0 }
+  for (const t of tasks) {
+    if (t.status === 'deleted') continue
+    summary.total++
+    if (t.status === 'completed') summary.done++
+    else if (t.status === 'in_progress') summary.inProgress++
+    else if (t.status === 'pending') summary.pending++
+    else if (t.status === 'failed') summary.failed++
+  }
+  return summary
+}
+
+/** Format a token count: raw under 1000, `1.2K` style above. */
+export function formatTokens(n: number): string {
+  if (n >= 1000) return `${(n / 1000).toFixed(1)}K`
+  return String(n)
+}
+
+function formatElapsed(ms: number): string {
+  const s = Math.floor(ms / 1000)
+  if (s < 60) return `${s}s`
+  const m = Math.floor(s / 60)
+  return `${m}m ${s % 60}s`
+}
+
+function taskIcon(status: Task['status']): { icon: string; color?: string; dim?: boolean } {
+  switch (status) {
+    case 'completed':
+      return { icon: '✓', color: 'green' }
+    case 'in_progress':
+      return { icon: '⏳', color: 'yellow' }
+    case 'failed':
+      return { icon: '✗', color: 'red' }
+    default:
+      return { icon: '📋', dim: true }
+  }
+}
+
+/** Live goal progress panel — mirrors ZCode's goal view: title + subtasks + done/total · elapsed · tokens. */
+export function GoalProgress({ goal, getTokens, listTasks }: GoalProgressProps) {
+  const [tasks, setTasks] = useState<Task[]>([])
+  const [tokens, setTokens] = useState(0)
+  const [elapsedMs, setElapsedMs] = useState(0)
+
+  // Hold latest callbacks in refs so the interval doesn't churn on re-render.
+  const listTasksRef = useRef(listTasks ?? getTasks)
+  const getTokensRef = useRef(getTokens ?? (() => 0))
+  listTasksRef.current = listTasks ?? getTasks
+  getTokensRef.current = getTokens ?? (() => 0)
+
+  useEffect(() => {
+    if (!goal) {
+      setTasks([])
+      setTokens(0)
+      setElapsedMs(0)
+      return
+    }
+    const start = Date.now()
+    const tick = () => {
+      setTasks(listTasksRef.current())
+      setTokens(getTokensRef.current())
+      setElapsedMs(Date.now() - start)
+    }
+    tick()
+    const timer = setInterval(tick, 1000)
+    return () => clearInterval(timer)
+  }, [goal])
+
+  if (!goal) return null
+
+  const summary = summarizeTasks(tasks)
+  const visibleTasks = tasks.filter((t) => t.status !== 'deleted')
+
+  return (
+    <Box
+      flexDirection="column"
+      borderStyle="round"
+      borderColor="cyan"
+      paddingX={1}
+      marginBottom={1}
+    >
+      <Text bold color="green">
+        🎯 Goal: {goal}
+      </Text>
+
+      {visibleTasks.length === 0 ? (
+        <Text dimColor> (no subtasks yet)</Text>
+      ) : (
+        visibleTasks.map((t) => {
+          const meta = taskIcon(t.status)
+          return (
+            <Box key={t.id} marginLeft={1}>
+              <Text color={meta.color} dimColor={meta.dim}>
+                {meta.icon} {t.subject}
+              </Text>
+            </Box>
+          )
+        })
+      )}
+
+      <Box marginTop={1}>
+        <Text dimColor>
+          ═══ {summary.done}/{summary.total} done
+          {summary.inProgress > 0 && ` · ${summary.inProgress} in progress`}
+          {summary.failed > 0 && ` · ${summary.failed} failed`}
+          {' · '}
+          {formatElapsed(elapsedMs)}
+          {tokens > 0 && ` · ${formatTokens(tokens)} tokens`}
+          {' ═══'}
+        </Text>
+      </Box>
+    </Box>
+  )
+}