@miphamai/cli 0.33.1 → 0.34.0

package/src/ui/commands.ts

@@ -83,6 +83,8 @@ export interface CommandResult {
   forwardToAI?: string
   /** If set, restored messages to load into the session (used by /resume last). */
   forwardedMessages?: Message[]
+  /** If true, resume into current non-empty session — app should warn before loading */
+  resumeWarning?: boolean
   /** API Key 补录请求：切换前需用户输入 Key */
   needsApiKey?: {
     providerId: string
@@ -269,11 +271,31 @@ const exitCmd: CommandHandler = () => ({ content: '', exit: true })
 const compactCmd: CommandHandler = async (ctx) => {
   const t = resolveT(ctx)
   const context = ctx.engine.getContext()
-  const before = context.getEstimatedTokens()
-  await context.compact('user requested compaction')
-  const after = context.getEstimatedTokens()
+  const msgsBefore = context.getMessageCount()
+  const tokensBefore = context.getEstimatedTokens()
+
+  // Show start progress
+  process.stderr.write(
+    `🔄 Compacting: ${msgsBefore} messages, ${tokensBefore.toLocaleString()} tokens...\n`,
+  )
+
+  const startTime = Date.now()
+  const result = await context.compact('user requested compaction')
+  const elapsed = ((Date.now() - startTime) / 1000).toFixed(1)
+  const msgsAfter = context.getMessageCount()
+  const saved = result.before > 0 ? ((1 - result.after / result.before) * 100).toFixed(0) : '0'
+
   return {
-    content: `${t('commands.compact.confirmed')}\n${t('commands.compact.tokens', { before: before.toLocaleString(), after: after.toLocaleString(), saved: ((1 - after / before) * 100).toFixed(0) })}`,
+    content: [
+      t('commands.compact.confirmed'),
+      `Messages: ${msgsBefore} → ${msgsAfter} | Tokens: ${result.before.toLocaleString()} → ${result.after.toLocaleString()} (${saved}% saved)`,
+      `Duration: ${elapsed}s`,
+      msgsBefore > msgsAfter
+        ? `💡 Tip: Use /compact early to prevent automatic compaction delays.`
+        : '',
+    ]
+      .filter(Boolean)
+      .join('\n'),
   }
 }
 
@@ -907,6 +929,234 @@ const sisCleanupCmd: CommandHandler = async (ctx) => {
   return { content: lines.join('\n') }
 }
 
+// ═══════════════════════════════════════════════════════════════
+// Auto-Dream: Background Memory Consolidation
+// ═══════════════════════════════════════════════════════════════
+
+const dreamCmd: CommandHandler = async (ctx, args) => {
+  const t = resolveT(ctx)
+  const aggressive = args.includes('--aggressive') || args.includes('-a')
+  const status = args.includes('--status') || args.includes('-s')
+
+  const engine = ctx.engine.getDreamEngine?.()
+  if (!engine) {
+    return { content: 'DreamEngine 未初始化。请确认 Mipham Code 版本 >= v0.34.0。' }
+  }
+
+  if (status) {
+    const history = engine.getDreamHistory()
+    if (history.length === 0) {
+      return { content: '🌙 尚未运行过 Auto-Dream。使用 `/dream` 手动触发首次梦境整合。' }
+    }
+    const lines: string[] = ['## 🌙 Auto-Dream 历史', '']
+    for (const entry of history.slice(0, 5)) {
+      const ts = new Date(entry.timestamp).toLocaleString('zh-CN')
+      const total = entry.actions.length
+      const applied = entry.actions.filter((a) => a.autoApplied).length
+      const flagged = entry.actions.filter((a) => !a.autoApplied).length
+      lines.push(`- **${ts}**: ${total} 行动 (${applied} 自动应用, ${flagged} 标记审查)`)
+    }
+    return { content: lines.join('\n') }
+  }
+
+  const report = engine.dream({ aggressive })
+  const lines: string[] = [
+    '## 🌙 Auto-Dream 完成',
+    '',
+    `记忆整合: ${report.beforeCount} → ${report.afterCount}`,
+    ...(report.phases.deduplicated > 0 ? [`- 去重: ${report.phases.deduplicated} 条`] : []),
+    ...(report.phases.contradictionsFound > 0
+      ? [`- 矛盾冲突: ${report.phases.contradictionsFound} 处 (需人工裁决)`]
+      : []),
+    ...(report.phases.merged > 0 ? [`- 合并: ${report.phases.merged} 组`] : []),
+    ...(report.phases.solidified > 0
+      ? [`- 模糊标记: ${report.phases.solidified} 条 (建议固化)`]
+      : []),
+    ...(report.phases.pruned > 0 ? [`- 清理过期: ${report.phases.pruned} 条`] : []),
+    '',
+  ]
+
+  const flagged = report.actions.filter((a) => !a.autoApplied)
+  if (flagged.length > 0 && !aggressive) {
+    lines.push(`⚠️  ${flagged.length} 项待审查。使用 \`/dream --aggressive\` 自动应用所有操作。`)
+    lines.push('')
+    for (const action of flagged) {
+      lines.push(`- [ ] **${action.type}**: ${action.description}`)
+    }
+  }
+
+  if (report.actions.length === 0) {
+    lines.push('✅ 记忆干净，无需整理。')
+  }
+
+  return { content: lines.join('\n') }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Bug Report
+// ═══════════════════════════════════════════════════════════════
+
+const bugReportCmd: CommandHandler = async (ctx) => {
+  const t = resolveT(ctx)
+  const engine = ctx.engine
+  const lines: string[] = [
+    '## 🐛 Bug Report',
+    '',
+    '> Copy the report below and paste it into your GitHub Issue.',
+    '',
+    '---',
+    '',
+  ]
+
+  // ── Version & Runtime ──
+  lines.push('### Environment', '')
+  lines.push(`- **Mipham Code**: v${ctx.version}`)
+  lines.push(`- **Session**: ${ctx.sessionId}`)
+  lines.push(`- **Node**: ${process.version}`)
+  lines.push(`- **Platform**: ${process.platform} ${process.arch}`)
+  lines.push(
+    `- **OS**: ${process.platform === 'darwin' ? 'macOS' : process.platform === 'linux' ? 'Linux' : 'Windows'}`,
+  )
+  lines.push(`- **Provider**: ${ctx.providerId}`)
+  lines.push(`- **Model**: ${ctx.modelId}`)
+  lines.push('')
+
+  // ── SIS errors ──
+  try {
+    const db = engine.getErrorSignatureDB?.()
+    if (db) {
+      const active = db.getActive()
+      if (active.length > 0) {
+        lines.push('### Active Error Signatures', '')
+        for (const sig of active.slice(0, 10)) {
+          lines.push(
+            `- \`${sig.id}\`: ${sig.pattern} (${sig.category}, ${sig.occurrences}x, ${(sig.successRate * 100).toFixed(0)}% success)`,
+          )
+        }
+        lines.push('')
+      }
+    }
+  } catch {
+    // SIS unavailable
+  }
+
+  // ── Hook health ──
+  try {
+    const hookEngine = engine.getHookEngine?.()
+    if (hookEngine) {
+      const health = hookEngine.getHookHealth()
+      const disabled = health.filter((h) => h.health.disabled)
+      if (disabled.length > 0) {
+        lines.push('### Disabled Hooks', '')
+        for (const entry of disabled) {
+          lines.push(
+            `- \`${entry.key}\`: ${entry.health.failures} failures, disabled at ${new Date(entry.health.disabledAt).toISOString()}`,
+          )
+        }
+        lines.push('')
+      }
+    }
+  } catch {
+    // Hook health unavailable
+  }
+
+  // ── Recent dream log ──
+  try {
+    const dreamEngine = engine.getDreamEngine?.()
+    if (dreamEngine) {
+      const history = dreamEngine.getDreamHistory()
+      if (history.length > 0) {
+        const last = history[0]!
+        lines.push('### Last Auto-Dream', '')
+        lines.push(`- **Ran at**: ${last.timestamp}`)
+        lines.push(
+          `- **Actions**: ${last.actions.length} (${last.actions.filter((a: { autoApplied: boolean }) => a.autoApplied).length} applied)`,
+        )
+        lines.push('')
+      }
+    }
+  } catch {
+    // Dream engine unavailable
+  }
+
+  // ── Steps to reproduce (template) ──
+  lines.push('### Steps to Reproduce', '')
+  lines.push('1. ')
+  lines.push('2. ')
+  lines.push('3. ')
+  lines.push('')
+  lines.push('### Expected Behavior', '')
+  lines.push('')
+  lines.push('### Actual Behavior', '')
+  lines.push('')
+  lines.push('---')
+  lines.push(`🤖 Generated with Mipham Code v${ctx.version}`)
+
+  return { content: lines.join('\n'), copyContent: lines.join('\n') }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Feedback
+// ═══════════════════════════════════════════════════════════════
+// Changelog
+// ═══════════════════════════════════════════════════════════════
+
+const changelogCmd: CommandHandler = async (ctx) => {
+  const t = resolveT(ctx)
+  const lines: string[] = ['## 📋 Changelog', '']
+
+  try {
+    const { execSync } = await import('node:child_process')
+    const tags = execSync('git tag --sort=-creatordate', { encoding: 'utf-8', timeout: 5000 })
+      .trim()
+      .split('\n')
+      .filter(Boolean)
+      .slice(0, 15)
+
+    if (tags.length === 0) {
+      lines.push('No version tags found.')
+      return { content: lines.join('\n') }
+    }
+
+    lines.push(`Current: **v${ctx.version}**`, '')
+
+    for (let i = 0; i < tags.length; i++) {
+      const tag = tags[i]!
+      const nextTag = tags[i + 1]
+      try {
+        const range = nextTag ? `${nextTag}..${tag}` : tag
+        const log = execSync(
+          `git log --oneline --no-merges ${range} --format="%s" 2>/dev/null | head -8`,
+          { encoding: 'utf-8', timeout: 5000 },
+        )
+          .trim()
+          .split('\n')
+          .filter(Boolean)
+
+        const isCurrent = tag === `v${ctx.version}`
+        lines.push(`### ${tag}${isCurrent ? ' ← current' : ''}`, '')
+        if (log.length > 0) {
+          for (const entry of log) {
+            lines.push(`- ${entry}`)
+          }
+        } else {
+          lines.push('  _(release tag only)_')
+        }
+        lines.push('')
+      } catch {
+        lines.push(`### ${tag}`, '', '  _(details unavailable)_', '')
+      }
+    }
+  } catch {
+    lines.push('Unable to read git history. Make sure you are in the Mipham Code repository.')
+  }
+
+  lines.push('---')
+  lines.push(`Full history: \`git log --oneline\``)
+
+  return { content: lines.join('\n') }
+}
+
 // ═══════════════════════════════════════════════════════════════
 // Workflow
 // ═══════════════════════════════════════════════════════════════
@@ -2125,25 +2375,69 @@ const statsCmd: CommandHandler = (ctx) => {
   const assistantMsgs = msgs.filter((m) => m.role === 'assistant').length
   const systemMsgs = msgs.filter((m) => m.role === 'system').length
 
-  return {
-    content: [
-      t('commands.stats.title'),
-      '',
-      t('commands.stats.messages', {
-        total: String(msgs.length),
-        user: String(userMsgs),
-        assistant: String(assistantMsgs),
-        system: String(systemMsgs),
-      }),
-      t('commands.stats.tokens', { tokens: tokens.toLocaleString() }),
-      t('commands.stats.tools', { count: String(tools.size) }),
-      t('commands.stats.provider', { provider: ctx.providerId }),
-      t('commands.stats.model', { model: ctx.modelId }),
-      t('commands.stats.permission', { permission: ctx.config.permission }),
-      '',
-      t('commands.stats.usage', { pct: ((tokens / 200_000) * 100).toFixed(1) }),
-    ].join('\n'),
+  const base = [
+    t('commands.stats.title'),
+    '',
+    t('commands.stats.messages', {
+      total: String(msgs.length),
+      user: String(userMsgs),
+      assistant: String(assistantMsgs),
+      system: String(systemMsgs),
+    }),
+    t('commands.stats.tokens', { tokens: tokens.toLocaleString() }),
+    t('commands.stats.tools', { count: String(tools.size) }),
+    t('commands.stats.provider', { provider: ctx.providerId }),
+    t('commands.stats.model', { model: ctx.modelId }),
+    t('commands.stats.permission', { permission: ctx.config.permission }),
+    '',
+    t('commands.stats.usage', { pct: ((tokens / 200_000) * 100).toFixed(1) }),
+  ]
+
+  // ── CRSI & SIS extensions ──
+  const engine = ctx.engine
+  const extras: string[] = []
+
+  try {
+    const db = engine.getErrorSignatureDB?.()
+    if (db) {
+      const s = db.getStats()
+      if (s.total > 0) {
+        extras.push(
+          '',
+          '── SIS Self-Immune ──',
+          `Signatures: ${s.total} total, ${s.active} active | Success rate: ${(s.avgSuccessRate * 100).toFixed(0)}%`,
+        )
+      }
+    }
+  } catch {
+    /* SIS not initialized */
   }
+
+  try {
+    const autoMemory = engine.getAutoMemory?.()
+    if (autoMemory) {
+      const count = autoMemory.sessionReflectionCount ?? 0
+      if (count > 0) extras.push(`CRSI Reflections: ${count} turn(s) analyzed`)
+    }
+  } catch {
+    /* CRSI not initialized */
+  }
+
+  try {
+    const meta = engine.getMetaRuleEngine?.()
+    if (meta) {
+      const analysis = meta.analyze()
+      if (analysis.systemHealth) {
+        extras.push(
+          `System Health: ${analysis.systemHealth.score}/100 — ${analysis.systemHealth.assessment}`,
+        )
+      }
+    }
+  } catch {
+    /* Meta not initialized */
+  }
+
+  return { content: [...base, ...extras].join('\n') }
 }
 
 const summaryCmd: CommandHandler = (ctx) => {
@@ -2256,6 +2550,46 @@ const hooksCmd: CommandHandler = async (ctx) => {
   }
 }
 
+const hooksHealthCmd: CommandHandler = (ctx) => {
+  const hookEngine = ctx.engine.getHookEngine?.()
+  if (!hookEngine) {
+    return { content: 'Hook engine not available.' }
+  }
+
+  const health = hookEngine.getHookHealth()
+  if (health.length === 0) {
+    return { content: '✅ All hooks are healthy — no failures recorded.' }
+  }
+
+  const lines: string[] = ['## 🪝 Hook Health Status', '']
+  for (const { key, health: h } of health) {
+    const status = h.disabled ? '🔴 DISABLED' : h.failures > 0 ? '🟡 DEGRADED' : '🟢 HEALTHY'
+    lines.push(`### ${status} \`${key}\``)
+    lines.push(`| 连续失败 | ${h.failures} (threshold: 5) |`)
+    lines.push(`| 总失败次数 | ${h.totalFailures} |`)
+    if (h.disabled) {
+      const remaining = Math.max(0, 5 - (Date.now() - h.disabledAt) / 60_000)
+      lines.push(`| 自动恢复 | ${remaining.toFixed(0)} min remaining |`)
+      lines.push('')
+      lines.push(`Use \`/hooks enable "${key}"\` to re-enable manually.`)
+    }
+    lines.push('')
+  }
+  return { content: lines.join('\n') }
+}
+
+const hooksEnableCmd: CommandHandler = (ctx, args) => {
+  const hookEngine = ctx.engine.getHookEngine?.()
+  if (!hookEngine) return { content: 'Hook engine not available.' }
+  const keyArg = args[0]?.trim().replace(/"/g, '')
+  if (!keyArg) {
+    return { content: 'Usage: /hooks enable "<hook-key>"\n\nUse /hooks health to see hook keys.' }
+  }
+  return hookEngine.reEnableHook(keyArg)
+    ? { content: `✅ Hook "${keyArg}" re-enabled.` }
+    : { content: `Hook "${keyArg}" not found or not disabled. Use /hooks health to check status.` }
+}
+
 const batchCmd: CommandHandler = async (ctx) => {
   const t = resolveT(ctx)
   return { content: t('commands.batch.title') }
@@ -2426,6 +2760,7 @@ const resumeLastCmd: CommandHandler = async (ctx) => {
         : t('commands.resume.restored_full_footer', { loaded: String(messages.length) }),
     ].join('\n'),
     forwardedMessages: messages,
+    resumeWarning: true,
   }
 }
 
@@ -3094,31 +3429,57 @@ To switch providers without clearing keys, use /switch <provider> <model>.`,
 // Phase 4 — Feedback
 // ═══════════════════════════════════════════════════════════════
 
-const feedbackCmd: CommandHandler = (ctx, args) => {
+const feedbackCmd: CommandHandler = async (ctx, args) => {
   const message = args.join(' ').trim()
 
   const lines: string[] = ['── Feedback ──', '']
 
+  // If a message was provided, save it to ~/.mipham/feedback/
   if (message) {
-    lines.push('Your feedback:')
-    lines.push('')
-    lines.push('  """')
-    for (const line of message.split('\n')) {
-      lines.push('  ' + line)
+    try {
+      const { writeFileSync, mkdirSync, existsSync } = await import('node:fs')
+      const { join } = await import('node:path')
+      const { homedir } = await import('node:os')
+
+      const dir = join(homedir(), '.mipham', 'feedback')
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+
+      const ts = new Date().toISOString().replace(/[:.]/g, '-')
+      const file = join(dir, `feedback-${ts}.md`)
+      const content = [
+        '---',
+        `timestamp: ${new Date().toISOString()}`,
+        `version: ${ctx.version}`,
+        `session: ${ctx.sessionId}`,
+        `provider: ${ctx.providerId}`,
+        `model: ${ctx.modelId}`,
+        '---',
+        '',
+        message,
+      ].join('\n')
+      writeFileSync(file, content, 'utf-8')
+
+      lines.push('Your feedback:')
+      lines.push('')
+      lines.push('  """')
+      for (const line of message.split('\n')) {
+        lines.push('  ' + line)
+      }
+      lines.push('  """')
+      lines.push('')
+      lines.push(`✅ Saved to \`${file}\``)
+      lines.push('')
+    } catch (err) {
+      lines.push(`⚠️ Save failed: ${String(err)}`)
+      lines.push('')
     }
-    lines.push('  """')
-    lines.push('')
-    lines.push('── Preview Complete ──')
-    lines.push('')
-    lines.push('Copy the above and submit via one of the channels below.')
-    lines.push('')
   }
 
   lines.push('── Feedback Channels ──')
   lines.push('')
   lines.push('  🐛 Bug Reports')
   lines.push('     GitHub Issues: https://github.com/One-Mipham/mipham-code/issues')
-  lines.push('     Template:      Bug Report (include version + reproduction steps)')
+  lines.push('     Or run `/bug-report` to auto-generate a diagnostic report')
   lines.push('')
   lines.push('  💡 Feature Requests')
   lines.push('     GitHub Issues: https://github.com/One-Mipham/mipham-code/issues')
@@ -3499,6 +3860,9 @@ const commandsListCmd: CommandHandler = () => {
     '/recap': 'Session & Identity',
     '/export': 'Session & Identity',
     '/doctor': 'Session & Identity',
+    '/dream': 'Session & Identity',
+    '/bug-report': 'Session & Identity',
+    '/changelog': 'Session & Identity',
     '/resume': 'Session & Identity',
     '/resume last': 'Session & Identity',
     '/resume delete': 'Session & Identity',
@@ -3694,6 +4058,9 @@ registry.set('/sis errors', sisErrorsCmd)
 registry.set('/sis stats', sisStatsCmd)
 registry.set('/sis clear', sisClearCmd)
 registry.set('/sis cleanup', sisCleanupCmd)
+registry.set('/dream', dreamCmd)
+registry.set('/bug-report', bugReportCmd)
+registry.set('/changelog', changelogCmd)
 
 // Workflow
 registry.set('/plan', planCmd)
@@ -3776,6 +4143,8 @@ registry.set('/stats', statsCmd)
 registry.set('/summary', summaryCmd)
 registry.set('/cd', cdCmd)
 registry.set('/hooks', hooksCmd)
+registry.set('/hooks health', hooksHealthCmd)
+registry.set('/hooks enable', hooksEnableCmd)
 registry.set('/batch', batchCmd)
 
 // ═══════════════════════════════════════════════════════════════
@@ -3812,6 +4181,9 @@ const COMMAND_DESCRIPTIONS: Record<string, string> = {
   '/recap': 'Summarize session so far',
   '/export': 'Export conversation to file',
   '/doctor': 'System diagnostics',
+  '/dream': 'Background memory consolidation',
+  '/bug-report': 'Generate diagnostic report for GitHub Issues',
+  '/changelog': 'Recent version history',
   '/resume': 'List saved sessions',
   '/resume last': 'Restore the most recent saved session',
   '/resume delete': 'Delete a saved session',
@@ -3909,6 +4281,8 @@ const COMMAND_DESCRIPTIONS: Record<string, string> = {
   '/summary': 'Generate session summary',
   '/cd': 'Change session working directory',
   '/hooks': 'Manage lifecycle hook scripts',
+  '/hooks health': 'Check hook health — see failures, disabled hooks, recovery status',
+  '/hooks enable': 'Manually re-enable a hook that was auto-disabled after repeated failures',
   '/batch': 'Apply changes across multiple files',
 }
 

package/src/ui/error-boundary.tsx

@@ -0,0 +1,85 @@
+/**
+ * Fix 8: Error Boundary for UI Rendering Protection
+ *
+ * Catches rendering errors in the React/Ink component tree,
+ * preventing the "layout freeze" bug where the interactive session
+ * stops redrawing while the process stays alive.
+ *
+ * Recovery path: renders a fallback message with a hint that the
+ * user can press Enter to attempt recovery (re-render).
+ */
+
+import React, { Component } from 'react'
+import { Text, Box } from 'ink'
+
+interface Props {
+  children: React.ReactNode
+  /** Called when a render error is caught */
+  onError?: (error: Error, errorInfo: React.ErrorInfo) => void
+}
+
+interface State {
+  hasError: boolean
+  error: Error | null
+  errorCount: number
+}
+
+export class ErrorBoundary extends Component<Props, State> {
+  private resetTimer: ReturnType<typeof setTimeout> | null = null
+
+  constructor(props: Props) {
+    super(props)
+    this.state = { hasError: false, error: null, errorCount: 0 }
+  }
+
+  static getDerivedStateFromError(error: Error): Partial<State> {
+    return { hasError: true, error }
+  }
+
+  override componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void {
+    // Log to stderr for diagnostics
+    process.stderr.write(
+      `\n⚠️  UI Error Boundary caught: ${error.message}\n` +
+        `   Component: ${errorInfo.componentStack?.slice(0, 200) || 'unknown'}\n`,
+    )
+
+    this.props.onError?.(error, errorInfo)
+
+    // Auto-recovery: reset after 5 seconds to attempt re-render
+    this.resetTimer = setTimeout(() => {
+      this.setState((prev) => ({
+        hasError: false,
+        error: null,
+        errorCount: prev.errorCount,
+      }))
+    }, 5_000)
+  }
+
+  override componentWillUnmount(): void {
+    if (this.resetTimer) {
+      clearTimeout(this.resetTimer)
+    }
+  }
+
+  override render(): React.ReactNode {
+    if (this.state.hasError) {
+      return (
+        <Box flexDirection="column" padding={1}>
+          <Text color="red" bold>
+            ⚠️ UI Render Error
+          </Text>
+          <Text dimColor>{this.state.error?.message || 'Unknown rendering error'}</Text>
+          <Text> </Text>
+          <Text dimColor>
+            The terminal interface encountered a rendering issue. Auto-recovery in 5 seconds...
+            Press Enter to attempt immediate recovery.
+          </Text>
+          <Text> </Text>
+          <Text color="yellow">Your session data and conversation history are preserved.</Text>
+        </Box>
+      )
+    }
+
+    return this.props.children
+  }
+}