@miphamai/cli 0.9.0 → 0.11.0

package/src/tools/exec/task.ts

@@ -4,13 +4,17 @@ interface Task {
   id: string
   subject: string
   description: string
-  status: 'pending' | 'in_progress' | 'completed' | 'deleted'
+  status: 'pending' | 'in_progress' | 'completed' | 'deleted' | 'failed'
   activeForm?: string
   metadata?: Record<string, unknown>
   blocks: string[]
   blockedBy: string[]
   owner?: string
   createdAt: string
+  /** Background task output content (set when a background agent completes). */
+  output?: string
+  /** Background task error message (set when a background agent fails). */
+  outputError?: string
 }
 
 const tasks = new Map<string, Task>()
@@ -20,14 +24,33 @@ function formatTask(t: Task): string {
   const meta = t.metadata ? ` ${JSON.stringify(t.metadata)}` : ''
   const blocks = t.blocks.length ? ` blocks:[${t.blocks.join(',')}]` : ''
   const blocked = t.blockedBy.length ? ` waits:[${t.blockedBy.join(',')}]` : ''
-  return `[${t.status}] #${t.id}: ${t.subject}${blocks}${blocked}${meta}`
+  const owner = t.owner ? ` @${t.owner}` : ''
+  return `[${t.status}] #${t.id}: ${t.subject}${owner}${blocks}${blocked}${meta}`
+}
+
+/** Check if a task is blocked — has unresolved dependencies. */
+function isBlocked(task: Task): boolean {
+  if (task.blockedBy.length === 0) return false
+  return task.blockedBy.some((depId) => {
+    const dep = tasks.get(depId)
+    return dep && dep.status !== 'completed' && dep.status !== 'deleted'
+  })
+}
+
+/** Get the list of blocking task IDs (unresolved dependencies). */
+function getBlockingIds(task: Task): string[] {
+  return task.blockedBy.filter((depId) => {
+    const dep = tasks.get(depId)
+    return dep && dep.status !== 'completed' && dep.status !== 'deleted'
+  })
 }
 
 export const taskTool: ToolDefinition = {
   name: 'Task',
   description:
     'Create and manage structured task lists for tracking progress. ' +
-    'Supports CRUD, dependencies (blocks/blockedBy), metadata, owner assignment, and status workflow: pending → in_progress → completed. ' +
+    'Supports CRUD, dependencies (blocks/blockedBy), metadata, owner assignment, ' +
+    'background task output/stop, and status workflow: pending → in_progress → completed. ' +
     'Use for complex multi-step tasks, session tracking, and organizing work.',
   category: 'exec',
   permission: 'auto',
@@ -36,9 +59,9 @@ export const taskTool: ToolDefinition = {
     properties: {
       action: {
         type: 'string',
-        enum: ['create', 'list', 'update', 'get', 'delete'],
+        enum: ['create', 'list', 'update', 'get', 'delete', 'output', 'stop'],
         description:
-          'Action: create a task, list all, update status/fields, get one by ID, or delete.',
+          'Action: create a task, list all, update status/fields, get one by ID, delete, view output of background task, or stop a running task.',
       },
       subject: { type: 'string', description: 'A brief, actionable title (for create/update).' },
       description: { type: 'string', description: 'What needs to be done (for create/update).' },
@@ -46,21 +69,24 @@ export const taskTool: ToolDefinition = {
         type: 'string',
         description: 'Present continuous form shown during work (for create/update).',
       },
-      taskId: { type: 'string', description: 'Task ID (for update/get/delete).' },
+      taskId: { type: 'string', description: 'Task ID (for update/get/delete/output/stop).' },
       status: {
         type: 'string',
-        enum: ['pending', 'in_progress', 'completed', 'deleted'],
-        description: 'New status. "deleted" permanently removes the task.',
+        enum: ['pending', 'in_progress', 'completed', 'deleted', 'failed'],
+        description:
+          'New status. "deleted" permanently removes the task, "failed" marks as failed.',
       },
       addBlocks: {
         type: 'array',
         items: { type: 'string' },
-        description: 'Task IDs that this task blocks (they depend on this one).',
+        description:
+          'Task IDs that this task blocks (they depend on this one). Use for create or update.',
       },
       addBlockedBy: {
         type: 'array',
         items: { type: 'string' },
-        description: 'Task IDs that block this task (this one depends on them).',
+        description:
+          'Task IDs that block this task (this one depends on them). Use for create or update.',
       },
       owner: { type: 'string', description: 'Agent or user name assigned to this task.' },
       metadata: {
@@ -90,8 +116,24 @@ export const taskTool: ToolDefinition = {
         owner: (params.owner as string) || undefined,
         createdAt: new Date().toISOString(),
       }
+
+      // Accept initial dependencies at creation time
+      if (Array.isArray(params.addBlocks)) {
+        for (const bid of params.addBlocks as string[]) {
+          if (!task.blocks.includes(bid)) task.blocks.push(bid)
+        }
+      }
+      if (Array.isArray(params.addBlockedBy)) {
+        for (const bid of params.addBlockedBy as string[]) {
+          if (!task.blockedBy.includes(bid)) task.blockedBy.push(bid)
+        }
+      }
+
       tasks.set(id, task)
-      return { success: true, content: `Task #${id} created: ${subject}` }
+      const blockedNote = isBlocked(task)
+        ? ` (blocked — waiting on: ${getBlockingIds(task).join(', ')})`
+        : ''
+      return { success: true, content: `Task #${id} created: ${subject}${blockedNote}` }
     }
 
     // ── LIST ──
@@ -99,18 +141,63 @@ export const taskTool: ToolDefinition = {
       const all = Array.from(tasks.values()).filter((t) => t.status !== 'deleted')
       if (all.length === 0) return { success: true, content: '(no tasks)' }
 
-      // Group by status
-      const groups: Record<string, Task[]> = { pending: [], in_progress: [], completed: [] }
-      for (const t of all) groups[t.status]?.push(t)
+      // Sort by availability: in_progress → pending(available) → pending(blocked) → completed
+      const sortOrder: Record<string, number> = {
+        in_progress: 0,
+        pending: 1,
+        completed: 2,
+        failed: 3,
+      }
+
+      const sorted = [...all].sort((a, b) => {
+        const orderA = sortOrder[a.status] ?? 3
+        const orderB = sortOrder[b.status] ?? 3
+        if (orderA !== orderB) return orderA - orderB
+        // Within same status: available before blocked
+        if (a.status === 'pending' && b.status === 'pending') {
+          const aBlocked = isBlocked(a)
+          const bBlocked = isBlocked(b)
+          if (aBlocked !== bBlocked) return aBlocked ? 1 : -1
+        }
+        return 0
+      })
 
       const lines: string[] = []
-      for (const status of ['in_progress', 'pending', 'completed'] as const) {
-        const group = groups[status]!
-        if (group.length === 0) continue
-        const emoji = status === 'in_progress' ? '🔄' : status === 'pending' ? '📋' : '✅'
-        lines.push(`${emoji} ${status.replace('_', ' ')} (${group.length}):`)
-        for (const t of group) lines.push(`  ${formatTask(t)}`)
+      const statusLabels: Record<string, { emoji: string; label: string }> = {
+        in_progress: { emoji: '🔄', label: 'In Progress' },
+        pending: { emoji: '📋', label: 'Pending' },
+        completed: { emoji: '✅', label: 'Completed' },
+        failed: { emoji: '❌', label: 'Failed' },
+      }
+
+      let currentStatus = ''
+      for (const t of sorted) {
+        const statusInfo = statusLabels[t.status]
+        if (!statusInfo) continue
+
+        if (statusInfo.label !== currentStatus) {
+          currentStatus = statusInfo.label
+          // Count tasks in this status group
+          const count = sorted.filter((s) => statusLabels[s.status]?.label === currentStatus).length
+          lines.push(`${statusInfo.emoji} ${currentStatus} (${count}):`)
+        }
+
+        const blocked = isBlocked(t)
+        const prefix = blocked && t.status === 'pending' ? '🚫 ' : '  '
+        const blockingNote = blocked ? ` 🚫 阻塞中 (等待: ${getBlockingIds(t).join(', ')})` : ''
+        lines.push(`${prefix}${formatTask(t)}${blockingNote}`)
       }
+
+      // Summary footer
+      const available = all.filter((t) => t.status === 'pending' && !isBlocked(t)).length
+      const blockedCount = all.filter((t) => t.status === 'pending' && isBlocked(t)).length
+      if (blockedCount > 0) {
+        lines.push('')
+        lines.push(
+          `📊 ${available} available · ${blockedCount} blocked · ${all.filter((t) => t.status === 'completed').length} done`,
+        )
+      }
+
       return { success: true, content: lines.join('\n') }
     }
 
@@ -129,8 +216,27 @@ export const taskTool: ToolDefinition = {
       if (task.activeForm) lines.push(`Active form: ${task.activeForm}`)
       if (task.owner) lines.push(`Owner: ${task.owner}`)
       if (task.blocks.length) lines.push(`Blocks: ${task.blocks.join(', ')}`)
-      if (task.blockedBy.length) lines.push(`Blocked by: ${task.blockedBy.join(', ')}`)
+      if (task.blockedBy.length) {
+        const blocking = getBlockingIds(task)
+        if (blocking.length > 0) {
+          lines.push(
+            `Blocked by: ${task.blockedBy.join(', ')} (active blockers: ${blocking.join(', ')})`,
+          )
+        } else {
+          lines.push(`Blocked by: ${task.blockedBy.join(', ')} (all resolved ✓)`)
+        }
+      }
       if (task.metadata) lines.push(`Metadata: ${JSON.stringify(task.metadata)}`)
+      if (task.output) {
+        lines.push('')
+        lines.push('── Output ──')
+        lines.push(task.output.slice(0, 2000))
+      }
+      if (task.outputError) {
+        lines.push('')
+        lines.push(`── Error ──`)
+        lines.push(task.outputError)
+      }
 
       return { success: true, content: lines.join('\n') }
     }
@@ -167,7 +273,14 @@ export const taskTool: ToolDefinition = {
         }
       }
 
-      return { success: true, content: `Task #${taskId} updated.\n${formatTask(task)}` }
+      const blockedNote = isBlocked(task)
+        ? ` (blocked — waiting on: ${getBlockingIds(task).join(', ')})`
+        : ''
+
+      return {
+        success: true,
+        content: `Task #${taskId} updated.\n${formatTask(task)}${blockedNote}`,
+      }
     }
 
     // ── DELETE ──
@@ -179,6 +292,86 @@ export const taskTool: ToolDefinition = {
       return { success: true, content: `Task #${taskId} deleted.` }
     }
 
+    // ── OUTPUT ──
+    if (action === 'output') {
+      const taskId = params.taskId as string
+      const task = tasks.get(taskId)
+      if (!task) return { success: false, content: '', error: `Task #${taskId} not found` }
+
+      if (task.status === 'pending') {
+        return {
+          success: true,
+          content: `Task #${taskId} is still pending — no output yet.\nStatus: ${task.status}\nSubject: ${task.subject}`,
+        }
+      }
+
+      if (task.status === 'in_progress') {
+        return {
+          success: true,
+          content: `Task #${taskId} is still running — output not yet available.\nStatus: in_progress\nSubject: ${task.subject}\n\nUse Task output again once the task completes.`,
+        }
+      }
+
+      if (task.status === 'completed' && task.output) {
+        return {
+          success: true,
+          content: `── Task #${taskId} Output ──\nStatus: completed\nSubject: ${task.subject}\n\n${task.output.slice(0, 5000)}`,
+        }
+      }
+
+      if (task.status === 'failed' && task.outputError) {
+        return {
+          success: false,
+          content: '',
+          error: `Task #${taskId} failed: ${task.outputError}`,
+        }
+      }
+
+      return {
+        success: true,
+        content: `Task #${taskId} — Status: ${task.status}\nSubject: ${task.subject}\n\n(no output recorded)`,
+      }
+    }
+
+    // ── STOP ──
+    if (action === 'stop') {
+      const taskId = params.taskId as string
+      const task = tasks.get(taskId)
+      if (!task) return { success: false, content: '', error: `Task #${taskId} not found` }
+
+      if (task.status === 'completed' || task.status === 'deleted') {
+        return {
+          success: true,
+          content: `Task #${taskId} is already ${task.status}. Nothing to stop.`,
+        }
+      }
+
+      if (task.status === 'pending') {
+        // Cancel a pending task
+        task.status = 'deleted'
+        return { success: true, content: `Task #${taskId} cancelled (was pending).` }
+      }
+
+      // For in_progress tasks: mark as failed — actual process termination is handled
+      // by BackgroundAgentRegistry.stop() when wired via the engine context
+      task.status = 'failed'
+      task.outputError = 'Task stopped by user.'
+
+      // If BackgroundAgentRegistry is available in context, try to abort
+      if (_ctx.registry) {
+        // Signal to any background registry that this task should stop
+        // The background registry will be injected via the engine context
+        const bgRegistry = (_ctx as unknown as Record<string, unknown>).backgroundAgentRegistry as
+          | { stop(id: string): boolean }
+          | undefined
+        if (bgRegistry) {
+          bgRegistry.stop(taskId)
+        }
+      }
+
+      return { success: true, content: `Task #${taskId} stopped.` }
+    }
+
     return { success: false, content: '', error: `Unknown action: ${action}` }
   },
 }

package/src/tools/index.ts

@@ -7,16 +7,23 @@ import { grepTool } from './file/grep'
 import { bashTool } from './exec/bash'
 import { gitTool } from './exec/git'
 import { taskTool } from './exec/task'
+import { enterWorktreeTool } from './exec/enter-worktree'
+import { exitWorktreeTool } from './exec/exit-worktree'
 import { agentTool } from './agent/agent'
 import { skillTool } from './agent/skill'
 import { planTool } from './agent/plan'
+import { enterPlanModeTool } from './agent/enter-plan'
+import { exitPlanModeTool } from './agent/exit-plan'
 import { memoryTool } from './agent/memory'
 import { workflowTool } from './agent/workflow'
 import { webFetchTool } from './network/web-fetch'
 import { webSearchTool } from './network/web-search'
 import { configTool } from './system/config'
 import { mcpTool } from './system/mcp'
+import { toolSearchTool } from './system/tool-search'
 import { artifactTool } from './artifact/artifact'
+import { reportFindingsTool } from './agent/report-findings'
+import { sendMessageTool } from './agent/send-message'
 import { computerUseTool } from './computer/computer-use'
 import { scheduleWakeupTool } from './scheduling/schedule-wakeup.js'
 import { cronCreateTool, cronDeleteTool, cronListTool } from './scheduling/cron.js'
@@ -110,18 +117,25 @@ export function createToolRegistry(): Map<string, ToolDefinition> {
     withValidation(bashTool),
     withValidation(gitTool),
     withValidation(taskTool),
+    withValidation(enterWorktreeTool),
+    withValidation(exitWorktreeTool),
     // Agent tools
     withValidation(agentTool),
     withValidation(skillTool),
     withValidation(planTool),
+    withValidation(enterPlanModeTool),
+    withValidation(exitPlanModeTool),
     withValidation(memoryTool),
     withValidation(workflowTool),
+    withValidation(reportFindingsTool),
+    withValidation(sendMessageTool),
     // Network tools
     withValidation(webFetchTool),
     withValidation(webSearchTool),
     // System tools
     withValidation(configTool),
     withValidation(mcpTool),
+    withValidation(toolSearchTool),
     // Artifact tools
     withValidation(artifactTool),
     // Computer Use tools

package/src/tools/system/tool-search.ts

@@ -0,0 +1,143 @@
+/**
+ * ToolSearch — search MCP server tools by name or description.
+ *
+ * Instead of loading all MCP tool definitions into the context upfront,
+ * the AI can call ToolSearch to discover relevant tools on demand.
+ * This saves ~85% of context tokens for large MCP servers (50-100 tools).
+ */
+
+import type { ToolDefinition } from '../../shared/index.ts'
+import { McpClient } from '../../mcp/client'
+
+export const toolSearchTool: ToolDefinition = {
+  name: 'ToolSearch',
+  description:
+    'Search available MCP server tools by name or description. ' +
+    'Use this to discover tools on demand instead of loading all tool definitions into context. ' +
+    'Returns matching tool names with their server and description.',
+  category: 'system',
+  permission: 'auto',
+  parameters: {
+    type: 'object',
+    properties: {
+      query: {
+        type: 'string',
+        description:
+          'Search query — matches against tool names and descriptions. Leave empty to list all available MCP tools.',
+      },
+      server: {
+        type: 'string',
+        description: 'Optional: limit search to a specific MCP server name.',
+      },
+      limit: {
+        type: 'integer',
+        description: 'Max results to return (default: 20).',
+      },
+    },
+    required: [],
+  },
+  async execute(params, _ctx) {
+    const query = ((params.query as string) || '').toLowerCase()
+    const serverFilter = (params.server as string) || ''
+    const limit = (params.limit as number) || 20
+
+    const client = McpClient.getInstance()
+    const connectedServers = client.getConnectedServers()
+
+    if (connectedServers.length === 0) {
+      return {
+        success: true,
+        content:
+          '── MCP Tool Search ──\n\n' +
+          'No MCP servers connected.\n\n' +
+          'Connect MCP servers in .mcp.json or via /mcp add <name> <url>.',
+      }
+    }
+
+    // Filter by server if specified
+    const servers = serverFilter
+      ? connectedServers.filter((s) => s.toLowerCase().includes(serverFilter))
+      : connectedServers
+
+    if (serverFilter && servers.length === 0) {
+      return {
+        success: true,
+        content:
+          `── MCP Tool Search ──\n\n` +
+          `No connected server matching "${serverFilter}".\n\n` +
+          `Connected servers: ${connectedServers.join(', ')}`,
+      }
+    }
+
+    // Collect matching tools
+    interface Match {
+      server: string
+      tool: string
+      description: string
+    }
+
+    const matches: Match[] = []
+
+    for (const serverName of servers) {
+      try {
+        const tools = client.getTools(serverName)
+        for (const tool of tools) {
+          const nameMatch = !query || tool.name.toLowerCase().includes(query)
+          const descMatch = !query || (tool.description || '').toLowerCase().includes(query)
+          if (nameMatch || descMatch) {
+            matches.push({
+              server: serverName,
+              tool: tool.name,
+              description: (tool.description || '').slice(0, 120),
+            })
+          }
+        }
+      } catch {
+        // Server disconnected mid-search — skip
+      }
+    }
+
+    if (matches.length === 0) {
+      return {
+        success: true,
+        content:
+          `── MCP Tool Search ──\n\n` +
+          `No tools matching "${query}" across ${servers.length} server(s).\n\n` +
+          `Try a different query, or omit the query to list all tools.`,
+      }
+    }
+
+    // Truncate to limit
+    const limited = matches.slice(0, limit)
+
+    const lines: string[] = [
+      `── MCP Tool Search ──`,
+      '',
+      `${limited.length} of ${matches.length} matching tool(s) across ${servers.length} server(s):`,
+      '',
+    ]
+
+    // Group by server
+    const byServer = new Map<string, Match[]>()
+    for (const m of limited) {
+      const list = byServer.get(m.server) || []
+      list.push(m)
+      byServer.set(m.server, list)
+    }
+
+    for (const [server, tools] of byServer) {
+      lines.push(`  ${server} (${tools.length}):`)
+      for (const t of tools) {
+        const desc = t.description ? ` — ${t.description}` : ''
+        lines.push(`    mcp__${server.replace(/[^a-z0-9-]/g, '_')}__${t.tool}${desc}`)
+      }
+      lines.push('')
+    }
+
+    if (matches.length > limit) {
+      lines.push(`... and ${matches.length - limit} more. Use "query" to narrow results.`)
+    }
+
+    return { success: true, content: lines.join('\n') }
+  },
+}

package/src/ui/app.tsx

@@ -15,6 +15,7 @@ import {
   handleSwitch,
   type CommandContext,
 } from './commands'
+import type { PermissionMode } from '../shared/index.ts'
 
 interface AppProps {
   engine: QueryEngine
@@ -49,13 +50,29 @@ interface AgentProgress {
 // Version is read fresh from package.json at startup via runApp prop
 // (bypasses Bun module caching after npm update)
 
-type PermissionMode = 'auto' | 'ask' | 'bypass'
-
-const PERMISSION_MODES: PermissionMode[] = ['auto', 'ask', 'bypass']
+const PERMISSION_MODES: PermissionMode[] = [
+  'default',
+  'acceptEdits',
+  'plan',
+  'auto',
+  'dontAsk',
+  'bypassPermissions',
+]
 const PERMISSION_LABELS: Record<PermissionMode, string> = {
-  auto: 'auto mode on',
-  ask: 'ask mode (confirm each action)',
-  bypass: 'bypass mode (skip all checks)',
+  default: 'default · reads free',
+  acceptEdits: 'accept edits · reads + edits free',
+  plan: 'plan mode · read-only',
+  auto: 'auto mode · hooks gate',
+  dontAsk: "don't ask · pre-approved only",
+  bypassPermissions: 'bypass · skip all checks',
+}
+const PERMISSION_COLORS: Record<PermissionMode, string> = {
+  default: 'white',
+  acceptEdits: 'blue',
+  plan: 'yellow',
+  auto: 'green',
+  dontAsk: 'cyan',
+  bypassPermissions: 'red',
 }
 
 export function App({
@@ -78,7 +95,7 @@ export function App({
   const [effort, setEffort] = useState('high')
   const [focusMode, setFocusMode] = useState(false)
   const [goalText, setGoalText] = useState('')
-  const [permissionMode, setPermissionMode] = useState<PermissionMode>('auto')
+  const [permissionMode, setPermissionMode] = useState<PermissionMode>('default')
   const abortRef = useRef<AbortController | null>(null)
   const [agentProgress, setAgentProgress] = useState<AgentProgress | null>(null)
   const [agentElapsed, setAgentElapsed] = useState(0)
@@ -304,6 +321,24 @@ export function App({
               { role: 'system', content: `❌ Error: ${chunk.error}` },
             ])
           }
+
+          if (chunk.type === 'task_notification' && chunk.taskNotification) {
+            const tn = chunk.taskNotification
+            const emoji = tn.status === 'completed' ? '✅' : '❌'
+            const label = tn.status === 'completed' ? 'completed' : 'failed'
+            const preview = tn.content
+              ? tn.content.slice(0, 120) + (tn.content.length > 120 ? '...' : '')
+              : tn.error
+                ? `Error: ${tn.error.slice(0, 120)}`
+                : '(no output)'
+            setMessages((prev) => [
+              ...prev,
+              {
+                role: 'system',
+                content: `${emoji} Background Agent ${label}: ${tn.description}\n   ID: ${tn.taskId}\n   ${preview}`,
+              },
+            ])
+          }
         }
       } catch (err) {
         setMessages((prev) => [...prev, { role: 'system', content: `Error: ${String(err)}` }])
@@ -365,13 +400,13 @@ export function App({
       })
       return
     }
-    // Shift+Tab → cycle permission mode (auto → ask → bypass → auto)
+    // 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
-        engine.getPermission().setDefaultLevel(next)
+        // Sync to engine — use setMode for proper mode semantics
+        engine.getPermission().setMode(next)
         return next
       })
       return
@@ -441,17 +476,12 @@ export function App({
           </Box>
         )}
         <Box flexDirection="row">
-          <Text
-            color={
-              permissionMode === 'auto' ? 'green' : permissionMode === 'ask' ? 'yellow' : 'red'
-            }
-          >
+          <Text color={PERMISSION_COLORS[permissionMode]}>
             ● {PERMISSION_LABELS[permissionMode]}
           </Text>
-          <Text dimColor> · ⏵⏵ accept edits on</Text>
-          <Text dimColor> (Shift+Tab to cycle)</Text>
-          <Text dimColor> · Ctrl+P pick · /help /commands · Esc cancel</Text>
-          <Text dimColor> · ← agents</Text>
+          <Text dimColor> · Shift+Tab mode</Text>
+          <Text dimColor> · Ctrl+P model · Ctrl+O expand</Text>
+          <Text dimColor> · Esc cancel · /help · ← agents</Text>
         </Box>
       </Box>
     </Box>