@miphamai/cli 0.2.3 → 0.3.0

package/src/core/permission.ts

@@ -1,7 +1,8 @@
-import type { ToolDefinition, ToolPermission, PermissionLevel } from '../shared/index.ts'
+import type { ToolDefinition, ToolPermission, PermissionLevel, PermissionRule } from '../shared/index.ts'
 
 export class PermissionSystem {
   private rules = new Map<string, PermissionLevel>()
+  private patternRules: Array<{ pattern: RegExp; level: PermissionLevel }> = []
 
   constructor(private defaultLevel: ToolPermission = 'auto') {}
 
@@ -13,18 +14,43 @@ export class PermissionSystem {
     return this.defaultLevel
   }
 
-  setRule(toolName: string, level: PermissionLevel): void {
-    this.rules.set(toolName, level)
+  setRule(toolNameOrRule: string | PermissionRule, level?: PermissionLevel): void {
+    if (typeof toolNameOrRule === 'string') {
+      if (level) this.rules.set(toolNameOrRule, level)
+    } else {
+      const rule = toolNameOrRule
+      if (rule.pattern) {
+        this.patternRules.push({ pattern: new RegExp(rule.pattern), level: rule.level })
+      } else {
+        this.rules.set(rule.toolName, rule.level)
+      }
+    }
   }
 
   removeRule(toolName: string): void {
     this.rules.delete(toolName)
   }
 
-  check(tool: ToolDefinition, _input: Record<string, unknown>): PermissionLevel {
+  /**
+   * Resolve permission level for a tool call.
+   *
+   * Fallback chain: exact rule → pattern rule → tool permission → system default
+   */
+  check(tool: ToolDefinition, input: Record<string, unknown>): PermissionLevel {
+    // 1. Exact-name rule wins
     const ruleLevel = this.rules.get(tool.name)
     if (ruleLevel) return ruleLevel
-    return tool.permission
+
+    // 2. Pattern-based rules (e.g. "file_*" → bypass)
+    for (const { pattern, level } of this.patternRules) {
+      if (pattern.test(tool.name)) return level
+    }
+
+    // 3. Tool's own permission level
+    if (tool.permission) return tool.permission
+
+    // 4. System default
+    return this.defaultLevel
   }
 
   needsApproval(tool: ToolDefinition, input: Record<string, unknown>): boolean {

package/src/core/session-store.ts

@@ -4,6 +4,7 @@ import {
   readFileSync,
   writeFileSync,
   unlinkSync,
+  renameSync,
   existsSync,
 } from 'node:fs'
 import { join } from 'node:path'
@@ -60,7 +61,10 @@ export class SessionStore {
       messages,
     }
 
-    writeFileSync(path, JSON.stringify(session) + '\n', 'utf-8')
+    // Atomic write: write to temp file, then rename (same-fs rename is atomic)
+    const tmp = path + '.tmp'
+    writeFileSync(tmp, JSON.stringify(session) + '\n', 'utf-8')
+    renameSync(tmp, path)
   }
 
   /**

package/src/index.tsx

@@ -8,6 +8,8 @@ import { QueryEngine } from './core/engine'
 import { SessionStore } from './core/session-store'
 import { SkillsLoader } from './skills/loader'
 import { createToolRegistry } from './tools'
+import { McpClient } from './mcp/client'
+import { HookEngine } from './core/hooks'
 
 interface RunOptions {
   model?: string
@@ -24,6 +26,17 @@ export async function runApp(options: RunOptions): Promise<void> {
   // Load configuration
   const config = loadConfig()
 
+  // Connect MCP servers (fire-and-forget — do not block startup)
+  const mcpServers = config.skills?.mcpServers ?? []
+  if (mcpServers.length > 0) {
+    const mcp = McpClient.getInstance()
+    for (const server of mcpServers) {
+      mcp.connect(server).catch((err) => {
+        process.stderr.write(`[mcp] Failed to connect "${server.name}": ${String(err)}\n`)
+      })
+    }
+  }
+
   // Bootstrap providers
   const defaultProvider = options.provider || config.defaultProvider
   const defaultModel = options.model || config.defaultModel
@@ -60,8 +73,20 @@ export async function runApp(options: RunOptions): Promise<void> {
   // Create tool registry with all 16 tools
   const tools = createToolRegistry()
 
+  // Initialize hook engine — register skill-defined hooks
+  const hookEngine = new HookEngine()
+  for (const skill of skillsLoader.list()) {
+    if (skill.hooks) {
+      for (const hook of skill.hooks) {
+        hookEngine.register(hook)
+      }
+    }
+  }
+
   // Create query engine
   const engine = new QueryEngine(registry, context, tools)
+  engine.setHookEngine(hookEngine)
+  engine.setupContextSummarizer()
 
   // Auto-save session on exit
   let autoSaveName: string | undefined

package/src/providers/anthropic.ts

@@ -6,6 +6,7 @@ import type {
   ContentBlock,
 } from '../shared/index.ts'
 import type { ProviderInstance, ChatRequest } from './registry'
+import { fetchWithRetry } from './fetch-utils'
 
 interface AnthropicContentBlock {
   type: string
@@ -72,7 +73,7 @@ export class AnthropicProvider implements ProviderInstance {
       }))
     }
 
-    const response = await fetch(`${this.baseUrl}/messages`, {
+    const response = await fetchWithRetry(`${this.baseUrl}/messages`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',

package/src/providers/fetch-utils.ts

@@ -0,0 +1,103 @@
+/**
+ * Shared fetch utilities — retry, timeout, backoff.
+ *
+ * Both AnthropicProvider and OpenAICompatProvider use these for
+ * resilient API communication.
+ */
+
+export interface FetchWithRetryOptions {
+  /** Request timeout in ms (applied via AbortController). */
+  timeout?: number
+  /** Maximum retry attempts (default 0 = no retry). */
+  maxRetries?: number
+  /** Base delay for exponential backoff in ms (default 1000). */
+  baseDelay?: number
+}
+
+const RETRYABLE_STATUSES = new Set([429, 500, 502, 503, 504])
+
+function isRetryableError(err: unknown): boolean {
+  if (err instanceof DOMException && err.name === 'AbortError') return false
+  return true
+}
+
+/**
+ * Fetch with optional timeout and retry with exponential backoff.
+ *
+ * Retries on: network errors, 5xx, 429.
+ * Does NOT retry on: timeout (AbortError), 4xx (except 429).
+ */
+export async function fetchWithRetry(
+  url: string,
+  init: RequestInit,
+  options: FetchWithRetryOptions = {},
+): Promise<Response> {
+  const { timeout = 60_000, maxRetries = 2, baseDelay = 1000 } = options
+
+  let lastErr: unknown
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), timeout)
+    const signal = init.signal
+      ? anySignal([init.signal, controller.signal])
+      : controller.signal
+
+    try {
+      const response = await fetch(url, { ...init, signal })
+
+      // 429 / 5xx → retry
+      if (RETRYABLE_STATUSES.has(response.status) && attempt < maxRetries) {
+        const retryAfter = response.headers.get('Retry-After')
+        const delay = retryAfter
+          ? parseInt(retryAfter, 10) * 1000
+          : baseDelay * Math.pow(2, attempt)
+        await sleep(delay)
+        continue
+      }
+
+      return response
+    } catch (err) {
+      lastErr = err
+      if (!isRetryableError(err) || attempt >= maxRetries) throw err
+      await sleep(baseDelay * Math.pow(2, attempt))
+    } finally {
+      clearTimeout(timer)
+      // Clean up combined signal if we created one
+      if (init.signal) {
+        try {
+          controller.abort()
+        } catch {
+          /* best effort */
+        }
+      }
+    }
+  }
+
+  throw lastErr
+}
+
+/** Simple promise-based sleep. */
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+/**
+ * Combine multiple AbortSignals into one — any signal aborting
+ * triggers the combined signal.
+ */
+function anySignal(signals: AbortSignal[]): AbortSignal {
+  const controller = new AbortController()
+  const onAbort = () => {
+    controller.abort()
+    for (const s of signals) s.removeEventListener('abort', onAbort)
+  }
+  for (const s of signals) {
+    if (s.aborted) {
+      controller.abort()
+      return controller.signal
+    }
+    s.addEventListener('abort', onAbort)
+  }
+  return controller.signal
+}

package/src/providers/openai-compat.ts

@@ -6,6 +6,7 @@ import type {
   ContentBlock,
 } from '../shared/index.ts'
 import type { ProviderInstance, ChatRequest } from './registry'
+import { fetchWithRetry } from './fetch-utils'
 
 export class OpenAICompatProvider implements ProviderInstance {
   constructor(public config: ProviderConfig) {}
@@ -23,7 +24,7 @@ export class OpenAICompatProvider implements ProviderInstance {
       tools: req.tools?.map((t) => ({ type: 'function', function: t })),
     }
 
-    const response = await fetch(`${baseUrl}/chat/completions`, {
+    const response = await fetchWithRetry(`${baseUrl}/chat/completions`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -47,6 +48,12 @@ export class OpenAICompatProvider implements ProviderInstance {
     const decoder = new TextDecoder()
     let buffer = ''
 
+    // Track incremental tool calls across streaming deltas
+    const pendingToolCalls = new Map<
+      number,
+      { id: string; name: string; arguments: string }
+    >()
+
     while (true) {
       const { done, value } = await reader.read()
       if (done) break
@@ -60,6 +67,18 @@ export class OpenAICompatProvider implements ProviderInstance {
         if (!trimmed || !trimmed.startsWith('data: ')) continue
         const data = trimmed.slice(6)
         if (data === '[DONE]') {
+          // Emit any pending tool calls before stopping
+          for (const [, tc] of pendingToolCalls) {
+            yield {
+              type: 'tool_use',
+              toolUse: {
+                type: 'tool_use',
+                id: tc.id,
+                name: tc.name,
+                input: this.safeParseJson(tc.arguments),
+              },
+            }
+          }
           yield { type: 'stop' }
           return
         }
@@ -73,21 +92,39 @@ export class OpenAICompatProvider implements ProviderInstance {
 
           if (delta?.tool_calls) {
             for (const tc of delta.tool_calls) {
+              const idx = tc.index ?? 0
+              const pending = pendingToolCalls.get(idx) || {
+                id: '',
+                name: '',
+                arguments: '',
+              }
+
+              if (tc.id) pending.id = tc.id
+              if (tc.function?.name) pending.name = tc.function.name
+              if (tc.function?.arguments) pending.arguments += tc.function.arguments
+
+              pendingToolCalls.set(idx, pending)
+            }
+          }
+
+          if (delta?.content) {
+            yield { type: 'text', content: delta.content }
+          }
+
+          if (choice.finish_reason === 'tool_calls') {
+            // Emit fully accumulated tool calls
+            for (const [, tc] of pendingToolCalls) {
               yield {
                 type: 'tool_use',
                 toolUse: {
                   type: 'tool_use',
                   id: tc.id || `call_${Date.now()}`,
-                  name: tc.function?.name || '',
-                  input: tc.function?.arguments ? JSON.parse(tc.function.arguments) : {},
+                  name: tc.name,
+                  input: this.safeParseJson(tc.arguments),
                 },
               }
             }
-            continue
-          }
-
-          if (delta?.content) {
-            yield { type: 'text', content: delta.content }
+            pendingToolCalls.clear()
           }
 
           if (choice.finish_reason === 'stop') {
@@ -148,6 +185,16 @@ export class OpenAICompatProvider implements ProviderInstance {
     return result
   }
 
+  /** Safely parse JSON, returning an empty object on failure. */
+  private safeParseJson(raw: string): Record<string, unknown> {
+    if (!raw) return {}
+    try {
+      return JSON.parse(raw)
+    } catch {
+      return { _raw: raw }
+    }
+  }
+
   private resolveApiKey(keyTemplate: string): string {
     const match = keyTemplate.match(/^\$\{(.+)\}$/)
     if (match?.[1]) {

package/src/providers/registry.ts

@@ -14,6 +14,7 @@ export interface ChatRequest {
   tools?: Record<string, unknown>[]
   maxTokens?: number
   temperature?: number
+  signal?: AbortSignal
 }
 
 export class ProviderRegistry {

package/src/ui/app.tsx

@@ -1,4 +1,4 @@
-import React, { useState, useCallback } from 'react'
+import React, { useState, useCallback, useRef } from 'react'
 import { Box, Text, useInput } from 'ink'
 import type { QueryEngine } from '../core/engine'
 import type { MiphamConfig } from '../shared/index.ts'
@@ -23,12 +23,26 @@ interface AppProps {
   skillsLoader?: SkillsLoader
 }
 
+export interface ToolMeta {
+  name: string
+  input: string
+  output?: string
+  collapsed: boolean
+}
+
 export interface ChatMessage {
   role: 'user' | 'assistant' | 'system'
   content: string
+  toolMeta?: ToolMeta
 }
 
-const VERSION = '0.2.0'
+interface AgentProgress {
+  name: string
+  description: string
+  startTime: number
+}
+
+const VERSION = '0.3.0'
 
 type PermissionMode = 'auto' | 'ask' | 'bypass'
 
@@ -58,6 +72,18 @@ export function App({
   const [focusMode, setFocusMode] = useState(false)
   const [goalText, setGoalText] = useState('')
   const [permissionMode, setPermissionMode] = useState<PermissionMode>('auto')
+  const abortRef = useRef<AbortController | null>(null)
+  const [agentProgress, setAgentProgress] = useState<AgentProgress | null>(null)
+  const [agentElapsed, setAgentElapsed] = useState(0)
+
+  // Agent elapsed timer
+  React.useEffect(() => {
+    if (!agentProgress) { setAgentElapsed(0); return }
+    const interval = setInterval(() => {
+      setAgentElapsed(Math.floor((Date.now() - agentProgress.startTime) / 1000))
+    }, 1000)
+    return () => clearInterval(interval)
+  }, [agentProgress])
 
   const mkCtx = useCallback(
     (): CommandContext => ({
@@ -161,10 +187,13 @@ export function App({
       setMessages((prev) => [...prev, { role: 'user', content: input }])
       setIsLoading(true)
 
+      const controller = new AbortController()
+      abortRef.current = controller
+
       let assistantContent = ''
 
       try {
-        for await (const chunk of engine.process(input)) {
+        for await (const chunk of engine.process(input, controller.signal)) {
           if (chunk.type === 'text' && chunk.content) {
             assistantContent += chunk.content
             setMessages((prev) => {
@@ -180,24 +209,50 @@ export function App({
           }
 
           if (chunk.type === 'tool_use' && chunk.toolUse) {
+            const toolName = chunk.toolUse.name
+            const inputStr = JSON.stringify(chunk.toolUse.input)
+            const isAgent = toolName === 'Agent' || toolName === 'Task'
+
+            if (isAgent) {
+              setAgentProgress({
+                name: (chunk.toolUse.input.subagent_type as string) || 'General-purpose',
+                description: (chunk.toolUse.input.description as string) ||
+                  (chunk.toolUse.input.prompt as string) || '',
+                startTime: Date.now(),
+              })
+            }
+
+            const collapsed = toolName !== 'Agent' // agents always expanded
             setMessages((prev) => [
               ...prev,
               {
                 role: 'system',
-                content: `🔧 Using tool: ${chunk.toolUse!.name}(${JSON.stringify(chunk.toolUse!.input)})`,
+                content: collapsed
+                  ? `⏺ ${toolName} · ${inputStr.slice(0, 50)}${inputStr.length > 50 ? '...' : ''} (Ctrl+O to expand)`
+                  : `🔧 ${toolName}: ${inputStr.slice(0, 200)}`,
+                toolMeta: { name: toolName, input: inputStr, collapsed },
               },
             ])
           }
 
           if (chunk.type === 'tool_result') {
-            const resultPreview =
-              chunk.content && chunk.content.length > 200
-                ? chunk.content.slice(0, 200) + '...'
-                : chunk.content || '(empty)'
-            setMessages((prev) => [
-              ...prev,
-              { role: 'system', content: `📋 Tool result: ${resultPreview}` },
-            ])
+            setAgentProgress(null)
+            setMessages((prev) => {
+              const updated = [...prev]
+              for (let i = updated.length - 1; i >= 0; i--) {
+                if (updated[i]?.toolMeta && !updated[i]!.toolMeta!.output) {
+                  updated[i] = {
+                    ...updated[i]!,
+                    content: updated[i]!.toolMeta!.collapsed
+                      ? updated[i]!.content
+                      : `📋 ${updated[i]!.toolMeta!.name} result: ${(chunk.content || '(empty)').slice(0, 200)}`,
+                    toolMeta: { ...updated[i]!.toolMeta!, output: chunk.content || '' },
+                  }
+                  break
+                }
+              }
+              return updated
+            })
           }
 
           if (chunk.type === 'error') {
@@ -211,6 +266,7 @@ export function App({
         setMessages((prev) => [...prev, { role: 'system', content: `Error: ${String(err)}` }])
       } finally {
         setIsLoading(false)
+        abortRef.current = null
         // Auto-save checkpoint after each AI response
         if (assistantContent) {
           engine.getContext().saveCheckpoint('post-turn')
@@ -227,6 +283,10 @@ export function App({
         setPickerOpen(false)
         return
       }
+      if (isLoading && abortRef.current) {
+        abortRef.current.abort()
+        return
+      }
       process.exit(0)
     }
     // Ctrl+P → open model picker
@@ -234,6 +294,34 @@ export function App({
       setPickerOpen((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 permission mode (auto → ask → bypass → auto)
     if (key.shift && key.tab) {
       setPermissionMode((prev) => {
@@ -255,7 +343,7 @@ export function App({
           <Text bold color="cyan">
             Mipham Code
           </Text>
-          <Text dimColor> v0.2.0</Text>
+          <Text dimColor> v0.3.0</Text>
           {sessionTitle ? (
             <Text color="yellow"> — {sessionTitle}</Text>
           ) : (
@@ -278,7 +366,7 @@ export function App({
             ● {PERMISSION_LABELS[permissionMode]}
           </Text>
           <Text dimColor> (Shift+Tab to cycle)</Text>
-          <Text dimColor> · Ctrl+P pick · /help · Esc exit</Text>
+          <Text dimColor> · Ctrl+P pick · /help · Esc cancel</Text>
         </Box>
         {goalText && (
           <Box>
@@ -287,6 +375,21 @@ export function App({
         )}
       </Box>
 
+      {/* Agent progress banner */}
+      {agentProgress && (
+        <Box flexDirection="column" marginY={1}>
+          <Text color="cyan" bold>
+            ⏺ {agentProgress.name}{' '}
+            <Text color="yellow">{agentElapsed}s</Text>
+          </Text>
+          <Text dimColor>
+            {agentProgress.description.length > 100
+              ? `"${agentProgress.description.slice(0, 100)}..."`
+              : `"${agentProgress.description}"`}
+          </Text>
+        </Box>
+      )}
+
       {/* Chat panel */}
       <ChatPanel messages={messages} focusMode={focusMode} />
 

package/src/ui/chat.tsx

@@ -37,17 +37,35 @@ export function ChatPanel({ messages, focusMode }: ChatPanelProps) {
               exit
             </Text>
           </Box>
+          <Box marginTop={1}>
+            <Text dimColor>
+              Tip: Use <Text color="yellow">/clear</Text> to start fresh when switching topics
+              and free up context
+            </Text>
+          </Box>
         </Box>
       )}
       {displayMessages.map((msg, i) => (
         <Box key={i} flexDirection="column" marginY={1}>
-          <Text
-            bold
-            color={msg.role === 'user' ? 'green' : msg.role === 'system' ? 'yellow' : 'blue'}
-          >
-            {msg.role === 'user' ? '▸ You' : msg.role === 'assistant' ? 'Mipham Code' : '⚠ System'}:
-          </Text>
-          <Text>{msg.content}</Text>
+          {msg.toolMeta ? (
+            <Box flexDirection="column">
+              <Text color="yellow">
+                {msg.toolMeta.collapsed ? '⏺' : '⏺ ▼'}{' '}
+                {msg.toolMeta.name}
+              </Text>
+              <Text dimColor>{msg.content}</Text>
+            </Box>
+          ) : (
+            <>
+              <Text
+                bold
+                color={msg.role === 'user' ? 'green' : msg.role === 'system' ? 'yellow' : 'blue'}
+              >
+                {msg.role === 'user' ? '▸ You' : msg.role === 'assistant' ? 'Mipham Code' : '⚠ System'}:
+              </Text>
+              <Text>{msg.content}</Text>
+            </>
+          )}
         </Box>
       ))}
     </Box>