@miphamai/cli 0.4.0 → 0.5.0

package/src/core/context.ts

@@ -1,4 +1,9 @@
 import type { Message } from '../shared/index.ts'
+import { snipMessages } from './context-snip'
+import { microcompact } from './context-microcompact'
+import { reactiveCompact } from './context-compact'
+import { emergencyDrain } from './context-drain'
+import { NoopCacheTracker, type CacheTracker, type CacheStatus } from './context-token'
 
 export type Summarizer = (messages: Message[], heading: string) => Promise<string>
 
@@ -7,6 +12,17 @@ interface ContextConfig {
   compactionThreshold: number // e.g. 0.9 → compact at 90% usage
 }
 
+export interface CompactionStats {
+  snipCount: number
+  snipMessagesRemoved: number
+  microcompactCount: number
+  microcompactTokensSaved: number
+  compactCount: number
+  compactTokensSaved: number
+  drainCount: number
+  lastCompaction: Date | null
+}
+
 interface Checkpoint {
   id: number
   messages: Message[]
@@ -23,6 +39,20 @@ export class ContextManager {
   private checkpointCounter = 0
   private summarizer?: Summarizer
 
+  // ── Compression state ──
+  private cacheTracker: CacheTracker = new NoopCacheTracker()
+  private compactionStats: CompactionStats = {
+    snipCount: 0,
+    snipMessagesRemoved: 0,
+    microcompactCount: 0,
+    microcompactTokensSaved: 0,
+    compactCount: 0,
+    compactTokensSaved: 0,
+    drainCount: 0,
+    lastCompaction: null,
+  }
+  private compressionPending = false
+
   constructor(private config: ContextConfig) {}
 
   /** Set an optional LLM summarizer for intelligent compaction. */
@@ -44,6 +74,9 @@ export class ContextManager {
     this.estimatedTokens += this.estimateTokens(
       typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
     )
+
+    // Auto-trigger compression checks (fire-and-forget, don't await)
+    this.checkCompression()
   }
 
   getMessages(): Message[] {
@@ -102,6 +135,21 @@ export class ContextManager {
     return this.messages.length
   }
 
+  /**
+   * Replace all messages atomically (used by compaction layers).
+   * Preserves system prompt. Does NOT trigger compaction checks.
+   */
+  replaceMessages(messages: Message[]): void {
+    this.messages = messages
+    // Re-estimate tokens
+    this.estimatedTokens = this.estimateTokens(this.systemPrompt)
+    for (const msg of messages) {
+      this.estimatedTokens += this.estimateTokens(
+        typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+      )
+    }
+  }
+
   // ── Checkpoint / Rewind ──
 
   saveCheckpoint(label = 'auto'): number {
@@ -153,6 +201,127 @@ export class ContextManager {
     return this.checkpoints.at(-1)?.id
   }
 
+  // ── Cache tracker integration ──
+
+  /** Register a cache tracker for cache-aware microcompaction decisions. */
+  setCacheTracker(tracker: CacheTracker): void {
+    this.cacheTracker = tracker
+  }
+
+  /** Get a snapshot of the provider prompt-cache state. */
+  getCacheStatus(): CacheStatus {
+    return this.cacheTracker.getStatus()
+  }
+
+  // ── Compression stats ──
+
+  /** Return a copy of the current compaction statistics. */
+  getCompactionStats(): CompactionStats {
+    return { ...this.compactionStats }
+  }
+
+  // ── 413 recovery ──
+
+  /**
+   * Emergency context drain for 413 (context too large) errors.
+   * Progressively strips messages until the context fits.
+   * Returns true if recovery was possible, false if already minimal.
+   */
+  async on413Error(): Promise<boolean> {
+    const result = await emergencyDrain(this)
+    if (result) {
+      this.compactionStats.drainCount++
+      this.compactionStats.lastCompaction = new Date()
+    }
+    return result
+  }
+
+  // ── Forced compaction (e.g. /compact command) ──
+
+  /**
+   * Force compaction of the conversation history.
+   *
+   * Uses the provided summarizer, the internal summarizer, or falls back
+   * to emergency drain if neither is available.
+   */
+  async forceCompact(heading: string, summarizer?: Summarizer): Promise<void> {
+    const beforeTokens = this.estimatedTokens
+
+    if (summarizer) {
+      await reactiveCompact(this, summarizer, heading)
+    } else if (this.summarizer) {
+      await reactiveCompact(this, this.summarizer, heading)
+    } else {
+      // Fallback: simple truncation via drain
+      await emergencyDrain(this)
+    }
+
+    const tokensSaved = beforeTokens - this.estimatedTokens
+    this.compactionStats.compactCount++
+    if (tokensSaved > 0) {
+      this.compactionStats.compactTokensSaved += tokensSaved
+    }
+    this.compactionStats.lastCompaction = new Date()
+  }
+
+  // ── Private compression helpers ──
+
+  /**
+   * Check estimated token usage and auto-trigger compression.
+   *
+   * - At 70%: run microcompact (fire-and-forget)
+   * - At 85%: the existing needsCompaction() serves as a compact hint
+   */
+  private checkCompression(): void {
+    if (this.compressionPending) return
+
+    const usage = this.estimatedTokens / this.config.maxTokens
+
+    if (usage > 0.7) {
+      this.compressionPending = true
+      // Schedule microcompact asynchronously (fire-and-forget)
+      Promise.resolve().then(() => {
+        this.runMicrocompact()
+        this.compressionPending = false
+      })
+    }
+  }
+
+  /** Run snip + microcompact inline and update stats. */
+  private runMicrocompact(): void {
+    const { messages: snipped, removed } = snipMessages(this.messages)
+
+    if (removed > 0) {
+      this.compactionStats.snipCount++
+      this.compactionStats.snipMessagesRemoved += removed
+    }
+
+    // Microcompact: compress tool_results not needed for recent context
+    const keepRecent = 3
+    const { messages: compacted, tokensSaved } = microcompact(snipped, this.cacheTracker, {
+      keepRecent,
+    })
+
+    if (tokensSaved > 0) {
+      this.compactionStats.microcompactCount++
+      this.compactionStats.microcompactTokensSaved += tokensSaved
+      this.compactionStats.lastCompaction = new Date()
+    }
+
+    this.messages = compacted
+    this.reEstimateTokens()
+  }
+
+  /** Re-estimate tokens from system prompt + current messages. */
+  private reEstimateTokens(): void {
+    this.estimatedTokens = this.estimateTokens(this.systemPrompt)
+    for (const msg of this.messages) {
+      this.estimatedTokens += this.estimateTokens(
+        typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+      )
+    }
+  }
+
   /**
    * Estimate token count for a text string.
    *

package/src/core/engine.ts

@@ -4,10 +4,19 @@ 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,
@@ -26,6 +35,36 @@ export class QueryEngine {
     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) => {
@@ -70,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()
@@ -133,6 +190,20 @@ 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)
@@ -156,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
     }
   }
 
@@ -206,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) {
@@ -268,7 +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
@@ -295,6 +392,10 @@ export class QueryEngine {
     return this.context
   }
 
+  getRegistry(): ProviderRegistry {
+    return this.registry
+  }
+
   getTools(): Map<string, ToolDefinition> {
     return this.tools
   }
@@ -302,6 +403,46 @@ 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 {

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 }
+}