@miphamai/cli 0.37.0 → 0.39.0

package/src/core/compaction-progress.ts

@@ -1,205 +0,0 @@
-/**
- * P1.1: Compaction Progress Tracker
- *
- * Provides user-visible progress feedback during context compaction:
- *   - Phase indicator (which compaction layer is active)
- *   - Message count (how many messages being processed)
- *   - Retry countdown for API-based summarization
- *   - Stuck detection hints
- *
- * Designed as an event emitter that the UI layer subscribes to.
- * Falls back to stderr output when no UI subscriber is registered.
- */
-
-// ── Types ──
-
-export type CompactionPhase =
-  'microcompact' | 'snip' | 'reactive-compact' | 'emergency-drain' | 'complete'
-
-export interface CompactionStatus {
-  phase: CompactionPhase
-  /** Human-readable description of current action */
-  message: string
-  /** 0-100 percentage, or -1 if indeterminate */
-  percent: number
-  /** Total messages before compaction */
-  messagesBefore: number
-  /** Messages remaining after compaction */
-  messagesAfter: number
-  /** Tokens before compaction */
-  tokensBefore: number
-  /** Tokens after compaction */
-  tokensAfter: number
-  /** Elapsed ms since compaction started */
-  elapsedMs: number
-  /** Retry count for summarization API calls */
-  retryCount: number
-  /** Whether a retry is in progress */
-  retrying: boolean
-  /** Whether the compaction appears stuck (no progress for >30s) */
-  stuck: boolean
-}
-
-export type ProgressCallback = (status: CompactionStatus) => void
-
-// ── Constants ──
-
-/** Timeout in ms after which we consider compaction "stuck" */
-const STUCK_TIMEOUT_MS = 30_000
-
-/** Max retries for summarizer API calls */
-const MAX_SUMMARIZER_RETRIES = 3
-
-/** Retry delay in ms between summarizer attempts */
-const RETRY_DELAY_MS = 2_000
-
-// ── Tracker ──
-
-export class CompactionProgressTracker {
-  private callback: ProgressCallback | null = null
-  private status: CompactionStatus
-  private startTime = 0
-  private lastProgressTime = 0
-
-  constructor(messagesBefore: number, tokensBefore: number) {
-    this.status = {
-      phase: 'microcompact',
-      message: 'Starting compaction...',
-      percent: 0,
-      messagesBefore,
-      messagesAfter: messagesBefore,
-      tokensBefore,
-      tokensAfter: tokensBefore,
-      elapsedMs: 0,
-      retryCount: 0,
-      retrying: false,
-      stuck: false,
-    }
-    this.startTime = Date.now()
-    this.lastProgressTime = Date.now()
-  }
-
-  /** Register a UI callback for progress updates. */
-  onProgress(cb: ProgressCallback): void {
-    this.callback = cb
-  }
-
-  /** Update phase with new values. */
-  update(partial: {
-    phase?: CompactionPhase
-    message?: string
-    percent?: number
-    messagesAfter?: number
-    tokensAfter?: number
-    retrying?: boolean
-  }): void {
-    if (partial.phase !== undefined) this.status.phase = partial.phase
-    if (partial.message !== undefined) this.status.message = partial.message
-    if (partial.percent !== undefined) this.status.percent = partial.percent
-    if (partial.messagesAfter !== undefined) this.status.messagesAfter = partial.messagesAfter
-    if (partial.tokensAfter !== undefined) this.status.tokensAfter = partial.tokensAfter
-    if (partial.retrying !== undefined) this.status.retrying = partial.retrying
-
-    this.status.elapsedMs = Date.now() - this.startTime
-
-    // Check for stuck detection
-    if (this.status.phase !== 'complete') {
-      const timeSinceProgress = Date.now() - this.lastProgressTime
-      this.status.stuck = timeSinceProgress > STUCK_TIMEOUT_MS
-    }
-
-    this.emit()
-  }
-
-  /** Mark current retry attempt. */
-  onRetry(attempt: number): void {
-    this.status.retryCount = attempt
-    this.status.retrying = true
-    this.emit()
-  }
-
-  /** Mark retry as complete (success or giving up). */
-  onRetryComplete(): void {
-    this.status.retrying = false
-    this.lastProgressTime = Date.now()
-    this.status.stuck = false
-    this.emit()
-  }
-
-  /** Mark compaction as complete. */
-  complete(messagesAfter: number, tokensAfter: number): void {
-    this.status.phase = 'complete'
-    this.status.percent = 100
-    this.status.messagesAfter = messagesAfter
-    this.status.tokensAfter = tokensAfter
-    this.status.message = `Compaction complete: ${this.status.messagesBefore} → ${messagesAfter} messages`
-    this.status.elapsedMs = Date.now() - this.startTime
-    this.emit()
-  }
-
-  /** Get current status. */
-  getStatus(): CompactionStatus {
-    return { ...this.status }
-  }
-
-  /** Generate a compact summary string for CLI display. */
-  getSummary(): string {
-    const s = this.status
-    const elapsed = (s.elapsedMs / 1000).toFixed(1)
-    const stuckHint = s.stuck ? ' (stalled — press Esc to cancel)' : ''
-    const retryHint = s.retrying ? ` [retry ${s.retryCount}/${MAX_SUMMARIZER_RETRIES}...]` : ''
-    const pct = s.percent >= 0 ? ` ${s.percent}%` : ''
-    return `🔄 [${s.phase}]${pct} ${s.message}${retryHint}${stuckHint} (${elapsed}s)`
-  }
-
-  private emit(): void {
-    if (this.callback) {
-      try {
-        this.callback(this.getStatus())
-      } catch {
-        // UI callback failure shouldn't block compaction
-      }
-    }
-  }
-
-  // ── Static helpers ──
-
-  /** Retry a summarizer call with backoff and progress tracking. */
-  static async retrySummarizer(
-    summarizer: () => Promise<string>,
-    tracker: CompactionProgressTracker,
-    messagesToSummarize: number,
-  ): Promise<string> {
-    let lastError: Error | undefined
-
-    for (let attempt = 1; attempt <= MAX_SUMMARIZER_RETRIES; attempt++) {
-      try {
-        tracker.update({
-          message: `Summarizing ${messagesToSummarize} messages${attempt > 1 ? ` (attempt ${attempt}/${MAX_SUMMARIZER_RETRIES})` : ''}...`,
-          percent: 30 + attempt * 20,
-          retrying: attempt > 1,
-        })
-
-        const result = await summarizer()
-        tracker.onRetryComplete()
-        return result
-      } catch (err) {
-        lastError = err instanceof Error ? err : new Error(String(err))
-
-        if (attempt < MAX_SUMMARIZER_RETRIES) {
-          tracker.onRetry(attempt)
-          // Wait before retry
-          await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS))
-          tracker.onRetryComplete()
-        }
-      }
-    }
-
-    tracker.update({
-      message: `Summarization failed after ${MAX_SUMMARIZER_RETRIES} attempts — falling back to truncation`,
-      percent: 60,
-    })
-
-    throw lastError ?? new Error('Summarization failed')
-  }
-}

package/src/core/context-compact.ts

@@ -1,124 +0,0 @@
-import type { ContextManager, Summarizer } from './context'
-import { snipMessages } from './context-snip'
-import { CompactionProgressTracker } from './compaction-progress'
-
-/**
- * Layer 3: Reactive Compact — API-based summarization.
- *
- * When the context exceeds the compaction threshold, uses an LLM summarizer
- * to condense the conversation history, keeping recent messages intact.
- *
- * After compaction, the context contains:
- * 1. A summary message of the truncated history
- * 2. The most recent N messages (kept intact)
- * 3. The system prompt (unchanged)
- */
-/**
- * Adaptive keep-recent count: scales with context window size.
- * 128K → 20, 200K → 20, 500K → 40, 1M → 80
- */
-function getKeepRecent(contextWindow: number): number {
-  return Math.max(20, Math.floor(contextWindow / 12500))
-}
-
-export interface CompactResult {
-  /** Messages before compaction */
-  beforeCount: number
-  /** Messages after compaction */
-  afterCount: number
-  /** Whether compaction was actually performed */
-  compacted: boolean
-  /** Progress summary for display */
-  summary: string
-}
-
-export async function reactiveCompact(
-  context: ContextManager,
-  summarizer: Summarizer,
-  heading: string,
-  keepRecent?: number,
-): Promise<CompactResult> {
-  // Use explicit override, or adaptive default based on context window
-  const effectiveKeepRecent = keepRecent ?? getKeepRecent(context.getMaxTokens())
-  const messages = context.getMessages()
-  const tokensBefore = context.getEstimatedTokens()
-
-  if (messages.length <= effectiveKeepRecent + 4) {
-    return {
-      beforeCount: messages.length,
-      afterCount: messages.length,
-      compacted: false,
-      summary: `Context has ${messages.length} messages — no compaction needed (threshold: ${effectiveKeepRecent + 4}).`,
-    }
-  }
-
-  // ── Progress tracker ──
-  const tracker = new CompactionProgressTracker(messages.length, tokensBefore)
-  tracker.update({ phase: 'snip', message: 'Snipping empty pairs...', percent: 5 })
-
-  // First, run snip to remove empty pairs
-  const { messages: snipped } = snipMessages(messages)
-  tracker.update({
-    phase: 'snip',
-    message: `Snipped ${messages.length - snipped.length} empty pairs`,
-    percent: 15,
-    messagesAfter: snipped.length,
-  })
-
-  if (snipped.length <= effectiveKeepRecent + 4) {
-    const afterCount = snipped.length
-    tracker.complete(afterCount, tokensBefore)
-    return {
-      beforeCount: messages.length,
-      afterCount,
-      compacted: true,
-      summary: `Snip-only: ${messages.length} → ${afterCount} messages (removed ${messages.length - afterCount} empty pairs).`,
-    }
-  }
-
-  // Split: old messages to summarize, recent messages to keep
-  const toSummarize = snipped.slice(0, -effectiveKeepRecent)
-  const toKeep = snipped.slice(-effectiveKeepRecent)
-
-  tracker.update({
-    phase: 'reactive-compact',
-    message: `Summarizing ${toSummarize.length} messages...`,
-    percent: 20,
-  })
-
-  // Generate summary with retry logic
-  let summary: string
-  try {
-    summary = await CompactionProgressTracker.retrySummarizer(
-      () => summarizer(toSummarize, heading),
-      tracker,
-      toSummarize.length,
-    )
-  } catch {
-    // On summarizer failure, do a simple truncation
-    tracker.update({
-      message: `Summarizer unavailable — truncating to last ${effectiveKeepRecent} messages.`,
-      percent: 80,
-    })
-    summary = `Earlier conversation (${toSummarize.length} messages) omitted due to context limits.`
-  }
-
-  // Rebuild messages: summary + recent
-  const summaryMsg = {
-    role: 'user' as const,
-    content: `[Earlier conversation summary — ${heading}]: ${summary.slice(0, 8000)}`,
-  }
-
-  const newMessages = [summaryMsg, ...toKeep]
-  context.replaceMessages(newMessages)
-
-  const tokensAfter = context.getEstimatedTokens()
-  tracker.complete(newMessages.length, tokensAfter)
-
-  return {
-    beforeCount: messages.length,
-    afterCount: newMessages.length,
-    compacted: true,
-    summary: tracker.getSummary(),
-  }
-}

package/src/core/context-drain.ts

@@ -1,113 +0,0 @@
-import type { ContextManager } from './context'
-import type { CompactionProgressTracker } from './compaction-progress'
-
-const MINIMAL_KEEP = 5
-let drainLevel = 0
-
-/**
- * Layer 4: Emergency Drain — 413 error recovery.
- *
- * Called when a 413 (context too large) error is received.
- * Progressively strips messages until the context fits:
- *
- * Level 1: Drop earliest 50% of messages
- * Level 2+: Keep only system prompt + last 5 messages
- *
- * Returns drain result with progress summary.
- */
-export interface DrainResult {
-  /** Whether recovery was possible */
-  recovered: boolean
-  /** Messages before drain */
-  beforeCount: number
-  /** Messages after drain */
-  afterCount: number
-  /** Current drain level */
-  level: number
-  /** Human-readable summary */
-  summary: string
-}
-
-export async function emergencyDrain(
-  context: ContextManager,
-  progress?: CompactionProgressTracker,
-): Promise<DrainResult> {
-  const messages = context.getMessages()
-
-  if (messages.length <= MINIMAL_KEEP) {
-    return {
-      recovered: false,
-      beforeCount: messages.length,
-      afterCount: messages.length,
-      level: drainLevel,
-      summary: `Cannot drain further: already at minimal ${messages.length} messages.`,
-    }
-  }
-
-  progress?.update({
-    phase: 'emergency-drain',
-    message: `Emergency drain level ${drainLevel + 1}: recovering from 413 error...`,
-    percent: 50,
-  })
-
-  if (drainLevel === 0) {
-    // First attempt: drop earliest 50%
-    const keepCount = Math.max(MINIMAL_KEEP, Math.floor(messages.length / 2))
-    const kept = messages.slice(-keepCount)
-    context.replaceMessages(kept)
-    drainLevel++
-    progress?.update({
-      phase: 'emergency-drain',
-      message: `Drain level 1: dropped ${messages.length - keepCount} messages (${messages.length} → ${keepCount})`,
-      percent: 80,
-      messagesAfter: keepCount,
-    })
-    return {
-      recovered: true,
-      beforeCount: messages.length,
-      afterCount: keepCount,
-      level: drainLevel,
-      summary: `Emergency drain level 1: ${messages.length} → ${keepCount} messages (dropped earliest 50%).`,
-    }
-  }
-
-  // Subsequent attempts: keep only system + last MINIMAL_KEEP messages
-  const kept = messages.slice(-MINIMAL_KEEP)
-
-  // Add a summary placeholder if we're dropping a lot
-  if (messages.length > MINIMAL_KEEP * 2) {
-    const summaryMsg = {
-      role: 'user' as const,
-      content: `[Emergency context drain level ${drainLevel + 1}: ${messages.length - MINIMAL_KEEP} earlier messages discarded due to token limit.]`,
-    }
-    context.replaceMessages([summaryMsg, ...kept])
-  } else {
-    context.replaceMessages(kept)
-  }
-
-  drainLevel++
-  progress?.update({
-    phase: 'emergency-drain',
-    message: `Drain level ${drainLevel}: ${messages.length} → ${kept.length} messages`,
-    percent: 90,
-    messagesAfter: kept.length,
-  })
-
-  return {
-    recovered: true,
-    beforeCount: messages.length,
-    afterCount: kept.length,
-    level: drainLevel,
-    summary: `Emergency drain level ${drainLevel}: ${messages.length} → ${kept.length} messages.`,
-  }
-}
-
-/** Reset drain level (call at session start). */
-export function resetDrainLevel(): void {
-  drainLevel = 0
-}
-
-/** Get current drain level for display. */
-export function getDrainLevel(): number {
-  return drainLevel
-}