@miphamai/cli 0.3.0 → 0.5.0

package/src/core/engine.ts

@@ -1,11 +1,22 @@
-import type { Message, StreamChunk, ToolDefinition, ToolResult } from '../shared/index.ts'
+import type { StreamChunk, ToolDefinition, ToolResult } from '../shared/index.ts'
 import { ProviderRegistry } from '../providers/registry'
 import { ContextManager } from './context'
 import { PermissionSystem } from './permission'
 import type { HookEngine } from './hooks'
+import type { ArtifactServer } from '../artifacts/server'
+import type { AgentRegistry } from '../agent/agent-registry'
+import { analyzeForMemory } from './memory/memory-writer'
+import { getMemoryManager } from './memory/memory-loader'
+import type { AgentViewManager } from '../agent-view/agent-view-manager'
 
 export class QueryEngine {
   private hookEngine?: HookEngine
+  private artifactServer?: ArtifactServer
+  private agentRegistry?: AgentRegistry
+  private agentViewManager?: AgentViewManager
+  private goal?: string
+  private maxGoalLoops = 20
+  private lastAssistantContent?: string
 
   constructor(
     private registry: ProviderRegistry,
@@ -19,6 +30,41 @@ export class QueryEngine {
     this.hookEngine = hooks
   }
 
+  /** Register the artifact server for tool context. */
+  setArtifactServer(server: ArtifactServer): void {
+    this.artifactServer = server
+  }
+
+  /** Register the agent registry for custom agent definitions. */
+  setAgentRegistry(reg: AgentRegistry): void {
+    this.agentRegistry = reg
+  }
+
+  /** Get the registered agent registry (may be undefined if not wired). */
+  getAgentRegistry(): AgentRegistry | undefined {
+    return this.agentRegistry
+  }
+
+  /** Register the AgentViewManager for background agent session management. */
+  setAgentViewManager(mgr: AgentViewManager): void {
+    this.agentViewManager = mgr
+  }
+
+  /** Get the AgentViewManager (may be undefined if not wired). */
+  getAgentViewManager(): AgentViewManager | undefined {
+    return this.agentViewManager
+  }
+
+  /** Set the session goal for goal-driven execution. */
+  setGoal(goal: string): void {
+    this.goal = goal
+  }
+
+  /** Get the last assistant text content. */
+  getLastAssistantContent(): string | undefined {
+    return this.lastAssistantContent
+  }
+
   /** Wire LLM-based conversation summarization into the context manager. */
   setupContextSummarizer(): void {
     this.context.setSummarizer(async (messages, heading) => {
@@ -31,8 +77,7 @@ export class QueryEngine {
         .join('\n')
 
       // Build a minimal system prompt for summarization
-      const summaryPrompt =
-        `You are a conversation summarizer. Create a concise summary (1-3 paragraphs) of this conversation excerpt. Focus on: key topics discussed, decisions made, code changes mentioned, and open questions. Heading: ${heading}`
+      const summaryPrompt = `You are a conversation summarizer. Create a concise summary (1-3 paragraphs) of this conversation excerpt. Focus on: key topics discussed, decisions made, code changes mentioned, and open questions. Heading: ${heading}`
 
       // Collect full summary text from streaming response
       let summary = ''
@@ -64,12 +109,30 @@ export class QueryEngine {
   }
 
   async *process(userInput: string, signal?: AbortSignal): AsyncGenerator<StreamChunk> {
+    // Fire UserPromptSubmit hooks before processing
+    if (this.hookEngine) {
+      const submitResult = await this.hookEngine.executeUserPromptSubmit(userInput, 'session-1')
+      if (submitResult.additionalContext) {
+        this.context.addMessage({
+          role: 'user',
+          content: `[Hook context]: ${submitResult.additionalContext}`,
+        })
+      }
+      if (!submitResult.allowed) {
+        yield {
+          type: 'error',
+          error: submitResult.reason || 'User input blocked by hook.',
+        }
+        return
+      }
+    }
+
     // Add user message to context
     this.context.addMessage({ role: 'user', content: userInput })
 
     // Check compaction before processing
     if (this.context.needsCompaction()) {
-      await this.context.compact('conversation summary')
+      await this.compactWithHooks('conversation summary')
     }
 
     const systemPrompt = this.context.getSystemPrompt()
@@ -81,39 +144,39 @@ export class QueryEngine {
 
     // Stream model response
     try {
-    for await (const chunk of this.registry.chat({
-      model: this.registry.getActiveModel(),
-      messages,
-      systemPrompt,
-      tools: toolDefs.length > 0 ? toolDefs : undefined,
-      signal,
-    })) {
-      yield chunk
-
-      if (chunk.type === 'error') {
-        this.context.addMessage({ role: 'assistant', content: `Error: ${chunk.error}` })
-        return
-      }
+      for await (const chunk of this.registry.chat({
+        model: this.registry.getActiveModel(),
+        messages,
+        systemPrompt,
+        tools: toolDefs.length > 0 ? toolDefs : undefined,
+        signal,
+      })) {
+        yield chunk
 
-      if (chunk.type === 'text' && chunk.content) {
-        assistantContent += chunk.content
-      }
+        if (chunk.type === 'error') {
+          this.context.addMessage({ role: 'assistant', content: `Error: ${chunk.error}` })
+          return
+        }
 
-      if (chunk.type === 'tool_use' && chunk.toolUse) {
-        toolUses.push({
-          id: chunk.toolUse.id,
-          name: chunk.toolUse.name,
-          input: chunk.toolUse.input,
-        })
-      }
+        if (chunk.type === 'text' && chunk.content) {
+          assistantContent += chunk.content
+        }
 
-      if (chunk.type === 'stop') {
-        // Add assistant response to context
-        if (assistantContent) {
-          this.context.addMessage({ role: 'assistant', content: assistantContent })
+        if (chunk.type === 'tool_use' && chunk.toolUse) {
+          toolUses.push({
+            id: chunk.toolUse.id,
+            name: chunk.toolUse.name,
+            input: chunk.toolUse.input,
+          })
+        }
+
+        if (chunk.type === 'stop') {
+          // Add assistant response to context
+          if (assistantContent) {
+            this.context.addMessage({ role: 'assistant', content: assistantContent })
+          }
         }
       }
-    }
     } catch (err) {
       if (isAbortError(err)) {
         // User interrupted — keep partial content, stop gracefully
@@ -127,13 +190,27 @@ export class QueryEngine {
       return
     }
 
+    // Track last assistant content for goal checking
+    if (assistantContent) {
+      this.lastAssistantContent = assistantContent
+    }
+
+    // Analyze user message for memory-worthy content after AI response
+    if (assistantContent && userInput) {
+      try {
+        analyzeForMemory(userInput, getMemoryManager())
+      } catch {
+        // memory analysis is non-critical
+      }
+    }
+
     // Execute any tools that were requested
     for (const toolUse of toolUses) {
       const result = await this.executeTool(toolUse.name, toolUse.input)
       yield {
         type: 'tool_result',
         tool_use_id: toolUse.id,
-        content: result.success ? result.content : (result.error || result.content),
+        content: result.success ? result.content : result.error || result.content,
       }
 
       // Add tool use + result to context
@@ -150,6 +227,26 @@ export class QueryEngine {
     // If tools were executed, recursively continue the conversation
     if (toolUses.length > 0) {
       yield* this.continueWithTools(signal)
+      return
+    }
+
+    // Fire Stop hooks when AI finishes with no tool calls
+    yield* this.checkStopHook(signal)
+  }
+
+  async *processWithGoal(input: string, signal?: AbortSignal): AsyncGenerator<StreamChunk> {
+    let loop = 0
+    while (loop < this.maxGoalLoops) {
+      yield* this.process(input, signal)
+      loop++
+
+      if (!this.goal) break
+
+      // Ask AI to check the goal condition
+      const checkMsg = `Has this goal been achieved? "${this.goal}" Answer YES or NO with reason.`
+      yield* this.process(checkMsg, signal)
+      // If AI responds "YES", break
+      if (this.lastAssistantContent?.includes('YES')) break
     }
   }
 
@@ -165,26 +262,26 @@ export class QueryEngine {
       const toolUses: Array<{ id: string; name: string; input: Record<string, unknown> }> = []
 
       try {
-      for await (const chunk of this.registry.chat({
-        model: this.registry.getActiveModel(),
-        messages,
-        systemPrompt,
-        tools: toolDefs.length > 0 ? toolDefs : undefined,
-        signal,
-      })) {
-        yield chunk
+        for await (const chunk of this.registry.chat({
+          model: this.registry.getActiveModel(),
+          messages,
+          systemPrompt,
+          tools: toolDefs.length > 0 ? toolDefs : undefined,
+          signal,
+        })) {
+          yield chunk
 
-        if (chunk.type === 'error') return
-        if (chunk.type === 'text' && chunk.content) assistantContent += chunk.content
+          if (chunk.type === 'error') return
+          if (chunk.type === 'text' && chunk.content) assistantContent += chunk.content
 
-        if (chunk.type === 'tool_use' && chunk.toolUse) {
-          toolUses.push({
-            id: chunk.toolUse.id,
-            name: chunk.toolUse.name,
-            input: chunk.toolUse.input,
-          })
+          if (chunk.type === 'tool_use' && chunk.toolUse) {
+            toolUses.push({
+              id: chunk.toolUse.id,
+              name: chunk.toolUse.name,
+              input: chunk.toolUse.input,
+            })
+          }
         }
-      }
       } catch (err) {
         if (isAbortError(err)) {
           if (assistantContent) {
@@ -200,8 +297,11 @@ export class QueryEngine {
         this.context.addMessage({ role: 'assistant', content: assistantContent })
       }
 
-      // No more tool calls — conversation complete
-      if (toolUses.length === 0) return
+      // No more tool calls — fire Stop hook and potentially continue
+      if (toolUses.length === 0) {
+        yield* this.checkStopHook(signal)
+        return
+      }
 
       // Execute tools and feed results back to the model for the next turn
       for (const toolUse of toolUses) {
@@ -243,11 +343,7 @@ export class QueryEngine {
     // Run PreToolUse hooks
     let effectiveParams = params
     if (this.hookEngine) {
-      const preResult = await this.hookEngine.executePreToolUse(
-        name,
-        params,
-        'session-1',
-      )
+      const preResult = await this.hookEngine.executePreToolUse(name, params, 'session-1')
       if (!preResult.allowed) {
         return {
           success: false,
@@ -266,6 +362,10 @@ export class QueryEngine {
         sessionId: 'session-1',
         provider: this.registry.getActive().config.id,
         model: this.registry.getActiveModel(),
+        registry: this.registry,
+        toolRegistry: this.tools,
+        artifactServer: this.artifactServer,
+        agentRegistry: this.agentRegistry,
       })
 
       // Run PostToolUse hooks
@@ -292,6 +392,10 @@ export class QueryEngine {
     return this.context
   }
 
+  getRegistry(): ProviderRegistry {
+    return this.registry
+  }
+
   getTools(): Map<string, ToolDefinition> {
     return this.tools
   }
@@ -299,10 +403,55 @@ export class QueryEngine {
   switchProvider(providerId: string, modelId?: string): void {
     this.registry.switchProvider(providerId, modelId)
   }
+
+  /** Wrap context compaction with PreCompact/PostCompact hooks. */
+  private async compactWithHooks(heading: string): Promise<void> {
+    if (this.hookEngine) {
+      const preResult = await this.hookEngine.executePreCompact('session-1')
+      if (preResult.additionalContext) {
+        this.context.addMessage({
+          role: 'user',
+          content: `[Pre-compact context]: ${preResult.additionalContext}`,
+        })
+      }
+    }
+
+    await this.context.compact(heading)
+
+    if (this.hookEngine) {
+      const postResult = await this.hookEngine.executePostCompact('session-1')
+      if (postResult.additionalContext) {
+        this.context.addMessage({
+          role: 'user',
+          content: `[Post-compact context]: ${postResult.additionalContext}`,
+        })
+      }
+    }
+  }
+
+  /** Fire Stop hook. If blocked, feed the reason back to the AI and continue. */
+  private async *checkStopHook(signal?: AbortSignal): AsyncGenerator<StreamChunk> {
+    if (!this.hookEngine) return
+
+    const stopResult = await this.hookEngine.executeStop('session-1')
+    if (stopResult.decision === 'block') {
+      // Feed the block reason back to the AI and continue
+      this.context.addMessage({
+        role: 'user',
+        content: `[The Stop hook blocked completion]: ${stopResult.reason || 'Continue working.'}`,
+      })
+      yield* this.continueWithTools(signal)
+    }
+  }
 }
 
 function isAbortError(err: unknown): boolean {
   if (err instanceof Error && err.name === 'AbortError') return true
-  if (typeof DOMException !== 'undefined' && err instanceof DOMException && err.name === 'AbortError') return true
+  if (
+    typeof DOMException !== 'undefined' &&
+    err instanceof DOMException &&
+    err.name === 'AbortError'
+  )
+    return true
   return false
 }

package/src/core/hooks-config.ts

@@ -0,0 +1,52 @@
+import type { HookConfig, HookEvent, HookDefinition, HookContext } from '../shared/index.ts'
+import { executeHook } from './hooks-executor'
+
+interface HookConfigEntry {
+  matcher: string
+  hooks: HookConfig[]
+}
+
+interface SettingsHooks {
+  PreToolUse?: HookConfigEntry[]
+  PostToolUse?: HookConfigEntry[]
+  Stop?: HookConfigEntry[]
+  UserPromptSubmit?: HookConfigEntry[]
+  PreCompact?: HookConfigEntry[]
+  PostCompact?: HookConfigEntry[]
+  SessionStart?: HookConfigEntry[]
+  SessionEnd?: HookConfigEntry[]
+  Notification?: HookConfigEntry[]
+  ConfigChange?: HookConfigEntry[]
+}
+
+/**
+ * Load hook configurations from a settings object and convert them to
+ * executable HookDefinitions suitable for the HookEngine.
+ */
+export function loadHookConfigs(configs: SettingsHooks): HookDefinition[] {
+  const definitions: HookDefinition[] = []
+
+  for (const [eventName, entries] of Object.entries(configs)) {
+    if (!entries || !Array.isArray(entries)) continue
+
+    for (const entry of entries) {
+      const matcherRegex = entry.matcher ? new RegExp(entry.matcher) : null
+
+      for (const hookCfg of entry.hooks) {
+        definitions.push({
+          event: eventName as HookEvent,
+          toolName: entry.matcher || undefined,
+          handler: async (ctx: HookContext) => {
+            // Check matcher if tool-specific
+            if (matcherRegex && ctx.toolName && !matcherRegex.test(ctx.toolName)) {
+              return { allowed: true }
+            }
+            return executeHook(hookCfg, ctx)
+          },
+        })
+      }
+    }
+  }
+
+  return definitions
+}

package/src/core/hooks-executor.ts

@@ -0,0 +1,113 @@
+import { execSync } from 'node:child_process'
+import type { HookConfig, HookContext, HookResult } from '../shared/index.ts'
+
+/**
+ * Execute a hook based on its type, returning a HookResult.
+ *
+ * Supported types:
+ * - command: Execute a shell command. Exit code 0 = allow, 2 = block with stderr as reason.
+ * - http: POST to a URL, response body becomes additionalContext.
+ * - mcp_tool: Call an MCP tool (delegates to MCP client -- stub for now).
+ * - code: No-op (handled inline by the handler function directly).
+ */
+export async function executeHook(cfg: HookConfig, ctx: HookContext): Promise<HookResult> {
+  switch (cfg.type) {
+    case 'command':
+      return executeCommand(cfg, ctx)
+    case 'http':
+      return executeHttp(cfg, ctx)
+    case 'mcp_tool':
+      return executeMcpTool(cfg, ctx)
+    default:
+      return { allowed: true }
+  }
+}
+
+function substituteVars(template: string, ctx: HookContext): string {
+  return template
+    .replace(/\$TOOL_NAME/g, ctx.toolName || '')
+    .replace(/\$INPUT/g, ctx.toolInput ? JSON.stringify(ctx.toolInput) : '')
+    .replace(/\$SESSION_ID/g, ctx.sessionId)
+}
+
+function executeCommand(cfg: HookConfig, ctx: HookContext): HookResult {
+  if (!cfg.command) return { allowed: true }
+
+  try {
+    const args = cfg.args ? cfg.args.map((a) => substituteVars(a, ctx)) : []
+
+    const cmd = [cfg.command, ...args].join(' ')
+
+    execSync(cmd, {
+      timeout: 30_000,
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+
+    // Exit code 0 = success, allow
+    return { allowed: true }
+  } catch (err) {
+    const stderr = (err as { stderr?: string }).stderr || String(err)
+
+    // Exit code 2 = block with reason
+    if ((err as { status?: number }).status === 2) {
+      return {
+        allowed: false,
+        reason: stderr.trim() || 'Blocked by hook',
+        additionalContext: cfg.continueOnBlock ? stderr.trim() : undefined,
+      }
+    }
+
+    // Other non-zero exit: don't block, log the error as context
+    return {
+      allowed: true,
+      additionalContext: `Hook warning (${cfg.command}): ${stderr.trim()}`,
+    }
+  }
+}
+
+async function executeHttp(cfg: HookConfig, ctx: HookContext): Promise<HookResult> {
+  if (!cfg.url) return { allowed: true }
+
+  try {
+    const response = await fetch(cfg.url, {
+      method: cfg.method || 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(cfg.headers || {}),
+      },
+      body: JSON.stringify({
+        event: ctx.event,
+        toolName: ctx.toolName,
+        sessionId: ctx.sessionId,
+      }),
+      signal: AbortSignal.timeout(10_000),
+    })
+
+    const body = await response.text()
+
+    if (!response.ok) {
+      return {
+        allowed: false,
+        reason: `HTTP hook returned ${response.status}: ${body.slice(0, 200)}`,
+      }
+    }
+
+    return {
+      allowed: true,
+      additionalContext: body.slice(0, 2000) || undefined,
+    }
+  } catch (err) {
+    // HTTP hook failures should not block
+    return {
+      allowed: true,
+      additionalContext: `HTTP hook error (${cfg.url}): ${String(err)}`,
+    }
+  }
+}
+
+async function executeMcpTool(_cfg: HookConfig, _ctx: HookContext): Promise<HookResult> {
+  // Stub: MCP tool hook execution requires MCP client integration.
+  // For now, return allow to not block execution.
+  return { allowed: true }
+}