@miphamai/cli 0.3.0 → 0.5.0

package/src/agent/agent-registry.ts

@@ -0,0 +1,134 @@
+import { readFileSync, existsSync, readdirSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join, extname } from 'node:path'
+import { parse as parseYaml } from 'yaml'
+import type { AgentDefinition, SubAgentType } from './types'
+
+interface FrontmatterResult {
+  data: Record<string, unknown>
+  content: string
+}
+
+function parseFrontmatter(raw: string): FrontmatterResult {
+  const match = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/)
+  if (!match) {
+    return { data: {}, content: raw }
+  }
+  return {
+    data: parseYaml(match[1] || '') as Record<string, unknown>,
+    content: (match[2] || '').trim(),
+  }
+}
+
+const BUILTIN_SYSTEM_PROMPTS: Record<SubAgentType, string> = {
+  general: 'You are a focused sub-agent. Complete the assigned task thoroughly and return results.',
+  explore:
+    'You are an exploration sub-agent. Search, read, and analyze code. Return structured findings with file paths and line numbers.',
+  plan: 'You are a planning sub-agent. Design implementation approaches. Return a step-by-step plan with files to modify.',
+  'code-review':
+    'You are a code review sub-agent. Find bugs, security issues, and code quality problems. Return findings by severity.',
+}
+
+const BUILTIN_DESCRIPTIONS: Record<SubAgentType, string> = {
+  general: 'General-purpose agent for complex multi-step tasks.',
+  explore: 'Read-only search agent for broad fan-out searches across files.',
+  plan: 'Software architect agent for designing implementation plans.',
+  'code-review': 'Code review agent for finding bugs and quality issues.',
+}
+
+export class AgentRegistry {
+  private agents = new Map<string, AgentDefinition>()
+
+  /** Load agents from a directory. Later loads override earlier ones for same name. */
+  loadDirectory(dir: string, source: 'project' | 'user'): void {
+    if (!existsSync(dir)) return
+
+    let entries: string[] = []
+    try {
+      entries = readdirSync(dir)
+    } catch {
+      // Permission errors, missing dir, etc.
+      return
+    }
+
+    for (const entry of entries) {
+      if (extname(entry) !== '.md') continue
+      const fullPath = join(dir, entry)
+      try {
+        const raw = readFileSync(fullPath, 'utf-8')
+        const { data, content } = parseFrontmatter(raw)
+
+        const name = (data.name as string) || entry.replace(/\.md$/, '')
+        const def: AgentDefinition = {
+          name,
+          description: (data.description as string) || '',
+          systemPrompt: content,
+          tools: data.tools as string | undefined,
+          disallowedTools: data.disallowedTools as string | undefined,
+          model: (data.model as string) || 'inherit',
+          permissionMode: (data.permissionMode as string) || 'inherit',
+          maxTurns: data.maxTurns as number | undefined,
+          skills: data.skills
+            ? String(data.skills)
+                .split(',')
+                .map((s) => s.trim())
+            : undefined,
+          background: (data.background as boolean) || false,
+          source,
+          filePath: fullPath,
+        }
+
+        this.agents.set(name, def)
+      } catch {
+        // Skip unparseable files
+      }
+    }
+  }
+
+  /** Load project-level agents from .mipham/agents/ */
+  loadProjectAgents(cwd: string): void {
+    this.loadDirectory(join(cwd, '.mipham', 'agents'), 'project')
+  }
+
+  /** Load user-level agents from ~/.mipham/agents/ */
+  loadUserAgents(): void {
+    const home = homedir()
+    this.loadDirectory(join(home, '.mipham', 'agents'), 'user')
+  }
+
+  /** Get a custom agent by name. Returns undefined for builtins. */
+  get(name: string): AgentDefinition | undefined {
+    return this.agents.get(name)
+  }
+
+  /** List all custom agents. */
+  list(): AgentDefinition[] {
+    return Array.from(this.agents.values())
+  }
+
+  /**
+   * Resolve an agent name to its definition.
+   * Priority: custom (project) > custom (user) > builtin.
+   * Builtins are always available and never return undefined.
+   */
+  resolve(name: string): AgentDefinition | undefined {
+    const custom = this.agents.get(name)
+    if (custom) return custom
+
+    // Check if it's a builtin type
+    const builtinType = name as SubAgentType
+    if (BUILTIN_SYSTEM_PROMPTS[builtinType]) {
+      return {
+        name: builtinType,
+        description: BUILTIN_DESCRIPTIONS[builtinType],
+        systemPrompt: BUILTIN_SYSTEM_PROMPTS[builtinType],
+        model: 'inherit',
+        permissionMode: 'inherit',
+        background: false,
+        source: 'builtin',
+      }
+    }
+
+    return undefined
+  }
+}

package/src/agent/sub-agent.ts

@@ -1,14 +1,7 @@
-import { ContextManager } from '../core/context'
-import type { ProviderRegistry } from '../providers/registry'
-import type { Message } from '../shared/types'
-
-export type SubAgentType = 'general' | 'explore' | 'plan' | 'code-review'
-
-interface SubAgentOptions {
-  type?: SubAgentType
-  systemPrompt?: string
-  maxContextMessages?: number
-}
+import type { ProviderRegistry, ProviderInstance } from '../providers/registry'
+import type { ToolDefinition } from '../shared/index.ts'
+import type { SubAgentType, SubAgentOptions, AgentDefinition } from './types'
+import { createAgentContext } from './agent-context'
 
 const TYPE_SYSTEM_PROMPTS: Record<SubAgentType, string> = {
   general: 'You are a focused sub-agent. Complete the assigned task thoroughly and return results.',
@@ -21,102 +14,93 @@ const TYPE_SYSTEM_PROMPTS: Record<SubAgentType, string> = {
 
 /**
  * Sub-agent engine — creates an isolated conversation context and processes
- * a single prompt independently. Returns the consolidated result.
- *
- * Phase 7: Pipeline-ready. Without a real AI provider, returns a structured
- * analysis of the prompt. Full AI integration in M3.
+ * a single prompt independently via the active AI provider. Returns the
+ * consolidated result text.
  */
 export class SubAgent {
-  constructor(private registry: ProviderRegistry) {}
+  constructor(
+    private registry: ProviderRegistry,
+    private toolRegistry: Map<string, ToolDefinition>,
+  ) {}
 
   async execute(
     prompt: string,
     description: string,
     options: SubAgentOptions = {},
   ): Promise<string> {
+    const provider = this.registry.getActive()
+    if (!provider) {
+      throw new Error('No active provider available for sub-agent execution')
+    }
+
+    const model = this.registry.getActiveModel()
     const type = options.type || 'general'
-    const systemPrompt = options.systemPrompt || TYPE_SYSTEM_PROMPTS[type]
+    const agentDef = options.agentDef
+
+    // Resolve system prompt: agentDef > options.systemPrompt > builtin type
+    const systemPrompt = agentDef?.systemPrompt || options.systemPrompt || TYPE_SYSTEM_PROMPTS[type]
+
+    // Create isolated context with tool scoping
+    const resolvedDef: AgentDefinition = agentDef || {
+      name: type,
+      description: '',
+      systemPrompt,
+      model: options.modelOverride || 'inherit',
+      permissionMode: 'inherit',
+      background: false,
+      source: 'builtin',
+    }
+    const { context, allowedTools } = createAgentContext(
+      resolvedDef,
+      this.toolRegistry,
+      options.maxContextMessages,
+    )
 
-    // Create isolated context for this sub-agent
-    const context = new ContextManager({
-      maxTokens: 100_000,
-      compactionThreshold: 0.9,
-    })
     context.setSystemPrompt(systemPrompt)
     context.addMessage({ role: 'user', content: prompt })
 
-    // Phase 7 pipeline: attempt real AI, fall back to structured simulation
-    try {
-      const provider = this.registry.getActive()
-      if (provider) {
-        const messages = context.getMessages()
-        const chunks: string[] = []
+    const messages = context.getMessages()
+    const toolDefs =
+      allowedTools.length > 0
+        ? allowedTools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+            input_schema: t.parameters,
+          }))
+        : undefined
 
-        for await (const chunk of provider.chat({
-          model: this.registry.getActiveModel(),
-          messages,
-          systemPrompt,
-          maxTokens: 4096,
-        })) {
-          if (chunk.type === 'text' && chunk.content) {
-            chunks.push(chunk.content)
-          }
-          if (chunk.type === 'error') {
-            // Fall through to simulation on API error
-            throw new Error(chunk.error)
-          }
-        }
+    const modelToUse = options.modelOverride || agentDef?.model || model
+    // 'inherit' means use parent model
+    const resolvedModel = modelToUse === 'inherit' ? model : modelToUse
 
-        if (chunks.length > 0) {
-          return chunks.join('')
+    const chunks: string[] = []
+
+    try {
+      for await (const chunk of provider.chat({
+        model: resolvedModel,
+        messages,
+        systemPrompt,
+        tools: toolDefs,
+        maxTokens: 4096,
+      })) {
+        if (chunk.type === 'text' && chunk.content) {
+          chunks.push(chunk.content)
+        }
+        if (chunk.type === 'error') {
+          throw new Error(`Sub-agent execution failed: ${chunk.error}`)
+        }
+        if (chunk.type === 'stop') {
+          break
         }
       }
-    } catch {
-      // API unavailable — use simulation mode
-    }
-
-    // Simulation mode: return structured task analysis
-    return this.simulate(prompt, description, type)
-  }
-
-  private simulate(prompt: string, description: string, type: SubAgentType): string {
-    const lines: string[] = [
-      `── Sub-Agent Result (${type}) ──`,
-      '',
-      `Task: ${description}`,
-      `Prompt: ${prompt.slice(0, 200)}${prompt.length > 200 ? '...' : ''}`,
-      '',
-    ]
-
-    switch (type) {
-      case 'explore':
-        lines.push(
-          'Analysis: This exploration task would search the codebase for relevant',
-          'files, patterns, and structures. The sub-agent pipeline is ready — connect',
-          'a provider API key for real AI-powered exploration.',
-        )
-        break
-      case 'plan':
-        lines.push(
-          'Plan: A step-by-step implementation plan would be generated based on',
-          'the requirements. Use /plan mode for interactive planning.',
-        )
-        break
-      case 'code-review':
-        lines.push(
-          'Review: The code review sub-agent would analyze the specified files for',
-          'bugs, security issues, and code quality concerns. Use /review for',
-          'interactive code review.',
-        )
-        break
-      default:
-        lines.push(
-          'The sub-agent pipeline is operational. Connect an API key to enable',
-          'AI-powered sub-agent execution. The infrastructure for context isolation,',
-          'prompt routing, and result aggregation is in place.',
-        )
+    } catch (err) {
+      if (err instanceof Error && err.message.startsWith('Sub-agent')) {
+        throw err
+      }
+      throw new Error(`Sub-agent execution failed: ${String(err)}`)
     }
 
-    return lines.join('\n')
+    return chunks.join('')
   }
 }

package/src/agent/types.ts

@@ -0,0 +1,39 @@
+// apps/cli/src/agent/types.ts
+
+export type SubAgentType = 'general' | 'explore' | 'plan' | 'code-review'
+
+export interface AgentFrontmatter {
+  name: string
+  description: string
+  tools?: string // comma-separated allowlist
+  disallowedTools?: string
+  model?: string // 'sonnet' | 'opus' | 'haiku' | 'inherit' | full model ID
+  permissionMode?: 'default' | 'acceptEdits' | 'auto' | 'bypass' | 'plan'
+  maxTurns?: number
+  skills?: string
+  background?: boolean
+}
+
+export interface AgentDefinition {
+  name: string
+  description: string
+  systemPrompt: string // markdown body after frontmatter
+  tools?: string
+  disallowedTools?: string
+  model: string
+  permissionMode: string
+  maxTurns?: number
+  skills?: string[]
+  background: boolean
+  source: 'builtin' | 'project' | 'user'
+  filePath?: string
+}
+
+export interface SubAgentOptions {
+  type?: SubAgentType
+  agentDef?: AgentDefinition
+  systemPrompt?: string
+  maxContextMessages?: number
+  allowedTools?: string[]
+  modelOverride?: string
+}

package/src/agent-view/agent-view-manager.ts

@@ -0,0 +1,217 @@
+/**
+ * AgentViewManager — multi-session lifecycle manager for background agent sessions.
+ *
+ * Each session represents a background sub-agent task. The manager tracks
+ * status transitions, elapsed time, and provides grouping/peek/attach/kill
+ * operations used by the Agent View Dashboard TUI.
+ */
+
+export type SessionStatus = 'needs-input' | 'working' | 'completed' | 'failed'
+
+export interface SessionMessage {
+  role: 'user' | 'assistant' | 'system'
+  content: string
+}
+
+export interface AgentSession {
+  id: string
+  title: string
+  status: SessionStatus
+  provider: string
+  model: string
+  task: string
+  createdAt: Date
+  startedAt?: Date
+  completedAt?: Date
+  elapsedMs: number
+  messages: SessionMessage[]
+}
+
+export interface CreateSessionOptions {
+  provider?: string
+  model?: string
+}
+
+export interface SessionPeek {
+  session: AgentSession
+  recentMessages: SessionMessage[]
+}
+
+export type StatusGroups = Record<SessionStatus, AgentSession[]>
+
+export class AgentViewManager {
+  private sessions: Map<string, AgentSession> = new Map()
+  private sessionOrder: string[] = []
+  private idCounter = 0
+
+  /**
+   * Create a new background agent session.
+   */
+  create(title: string, task: string, options: CreateSessionOptions = {}): AgentSession {
+    const id = `agent-${++this.idCounter}-${Date.now()}`
+    const session: AgentSession = {
+      id,
+      title,
+      status: 'needs-input',
+      provider: options.provider ?? 'unknown',
+      model: options.model ?? 'unknown',
+      task,
+      createdAt: new Date(),
+      elapsedMs: 0,
+      messages: [],
+    }
+
+    this.sessions.set(id, session)
+    this.sessionOrder.push(id)
+
+    return session
+  }
+
+  /**
+   * List all sessions in creation order (newest first).
+   */
+  list(): AgentSession[] {
+    return [...this.sessionOrder]
+      .reverse()
+      .map((id) => this.sessions.get(id)!)
+      .filter(Boolean)
+  }
+
+  /**
+   * Group all sessions by their current status.
+   * Returns a record with keys for all four statuses (empty arrays if none).
+   */
+  groupByStatus(): StatusGroups {
+    const groups: StatusGroups = {
+      'needs-input': [],
+      working: [],
+      completed: [],
+      failed: [],
+    }
+
+    for (const id of this.sessionOrder) {
+      const session = this.sessions.get(id)
+      if (session) {
+        groups[session.status].push(session)
+      }
+    }
+
+    return groups
+  }
+
+  /**
+   * Get a session by ID.
+   */
+  get(id: string): AgentSession | undefined {
+    return this.sessions.get(id)
+  }
+
+  /**
+   * Peek at a session — returns the session metadata and up to 5 recent messages.
+   */
+  peek(id: string): SessionPeek | undefined {
+    const session = this.sessions.get(id)
+    if (!session) return undefined
+
+    const recentMessages = session.messages.slice(-5)
+    return { session, recentMessages }
+  }
+
+  /**
+   * Attach to a session — marks the session as working (if needs-input) and
+   * returns it so the caller can switch the main UI to this session.
+   */
+  attach(id: string): AgentSession | undefined {
+    const session = this.sessions.get(id)
+    if (!session) return undefined
+
+    // If the session was waiting for input, transition to working
+    if (session.status === 'needs-input') {
+      session.status = 'working'
+      session.startedAt = new Date()
+    }
+
+    return session
+  }
+
+  /**
+   * Kill (terminate) a session. Only kills sessions that are not already completed/failed.
+   * Returns true if the session was found and killed, false otherwise.
+   */
+  kill(id: string): boolean {
+    const session = this.sessions.get(id)
+    if (!session) return false
+
+    // Don't re-kill already terminal sessions
+    if (session.status === 'completed' || session.status === 'failed') {
+      return false
+    }
+
+    session.status = 'failed'
+    session.completedAt = new Date()
+    return true
+  }
+
+  /**
+   * Update a session's status and optionally add a message.
+   */
+  updateStatus(id: string, status: SessionStatus): boolean {
+    const session = this.sessions.get(id)
+    if (!session) return false
+
+    session.status = status
+
+    if (status === 'working' && !session.startedAt) {
+      session.startedAt = new Date()
+    }
+    if ((status === 'completed' || status === 'failed') && !session.completedAt) {
+      session.completedAt = new Date()
+    }
+
+    return true
+  }
+
+  /**
+   * Add a message to a session's message history.
+   */
+  addMessage(id: string, message: SessionMessage): boolean {
+    const session = this.sessions.get(id)
+    if (!session) return false
+
+    session.messages.push(message)
+    return true
+  }
+
+  /**
+   * Count sessions by status.
+   */
+  countByStatus(): Record<SessionStatus, number> {
+    const counts: Record<SessionStatus, number> = {
+      'needs-input': 0,
+      working: 0,
+      completed: 0,
+      failed: 0,
+    }
+
+    for (const [, session] of this.sessions) {
+      counts[session.status]++
+    }
+
+    return counts
+  }
+
+  /**
+   * Remove all completed and failed sessions (cleanup).
+   */
+  prune(): number {
+    let removed = 0
+    for (const [id, session] of this.sessions) {
+      if (session.status === 'completed' || session.status === 'failed') {
+        this.sessions.delete(id)
+        this.sessionOrder = this.sessionOrder.filter((oid) => oid !== id)
+        removed++
+      }
+    }
+    return removed
+  }
+}