@miphamai/cli 0.32.6 → 0.33.0

package/src/core/preflight-checker.ts

@@ -0,0 +1,218 @@
+/**
+ * SIS (Self-Immune System) Phase 0: Pre-Flight Checker
+ *
+ * Pre-execution interception layer that checks tool calls against:
+ *   1. ErrorSignatureDB — known error patterns with proven fixes
+ *   2. ExperienceRuleEngine — CRSI Phase 1 dynamic rules
+ *
+ * Returns one of four actions:
+ *   - 'allow'  → no issue, proceed normally
+ *   - 'warn'   → known risky pattern, show warning but allow
+ *   - 'fix'    → known error with proven fix, auto-correct params
+ *   - 'block'  → known dangerous pattern, refuse execution
+ *
+ * Priority: block > fix > warn > allow
+ *   (most restrictive action wins when multiple sources match)
+ */
+
+import type { ErrorSignatureDB, ErrorSignature } from './error-signature-db.js'
+import type { ExperienceRuleEngine } from './rule-engine.js'
+
+// ── Types ──
+
+export interface PreFlightResult {
+  /** The action to take */
+  action: 'allow' | 'warn' | 'fix' | 'block'
+  /** Warning message (for 'warn' and 'block' actions) */
+  warning?: string
+  /** Modified parameters (for 'fix' action) */
+  modifiedParams?: Record<string, unknown>
+  /** Matched error signature ID (for tracking) */
+  matchedSignature?: string
+  /** Human-readable explanation of the fix */
+  explanation?: string
+}
+
+// ── Action Priority ──
+
+const ACTION_PRIORITY: Record<PreFlightResult['action'], number> = {
+  allow: 0,
+  warn: 1,
+  fix: 2,
+  block: 3,
+}
+
+// ── Checker ──
+
+export class PreFlightChecker {
+  private errorDB: ErrorSignatureDB
+  private ruleEngine?: ExperienceRuleEngine
+
+  constructor(errorDB: ErrorSignatureDB, ruleEngine?: ExperienceRuleEngine) {
+    this.errorDB = errorDB
+    this.ruleEngine = ruleEngine
+  }
+
+  /**
+   * Check a tool call before execution.
+   *
+   * @param toolName — e.g. 'Bash', 'Write', 'Grep'
+   * @param params  — tool input parameters
+   * @returns PreFlightResult with the strictest applicable action
+   */
+  check(toolName: string, params: Record<string, unknown>): PreFlightResult {
+    const results: PreFlightResult[] = []
+
+    // ── Layer 1: ErrorSignatureDB ──
+    const sig = this.errorDB.match(toolName, params)
+    if (sig) {
+      results.push(this.signatureToResult(sig, params))
+    }
+
+    // ── Layer 2: ExperienceRuleEngine ──
+    if (this.ruleEngine) {
+      const ruleResult = this.checkRuleEngine(toolName, params)
+      if (ruleResult) {
+        results.push(ruleResult)
+      }
+    }
+
+    // ── Merge: pick the most restrictive result ──
+    if (results.length === 0) {
+      return { action: 'allow' }
+    }
+
+    return results.reduce((best, curr) =>
+      ACTION_PRIORITY[curr.action] > ACTION_PRIORITY[best.action] ? curr : best,
+    )
+  }
+
+  /**
+   * Set/update the rule engine reference.
+   * Useful when the rule engine is wired after construction.
+   */
+  setRuleEngine(ruleEngine: ExperienceRuleEngine): void {
+    this.ruleEngine = ruleEngine
+  }
+
+  // ── Private: Signature Conversion ──
+
+  /**
+   * Convert an ErrorSignature to a PreFlightResult based on its fixStrategy.
+   */
+  private signatureToResult(sig: ErrorSignature, params: Record<string, unknown>): PreFlightResult {
+    const base = {
+      matchedSignature: sig.id,
+      explanation: sig.explanation,
+    }
+
+    switch (sig.fixStrategy) {
+      case 'block':
+        return {
+          ...base,
+          action: 'block',
+          warning: `⛔ SIS 免疫拦截: ${sig.explanation} (${sig.occurrences} 次历史发生，成功率 ${Math.round(sig.successRate * 100)}%)`,
+        }
+
+      case 'warn':
+        return {
+          ...base,
+          action: 'warn',
+          warning: `⚠️ SIS 预警: ${sig.explanation} (${sig.occurrences} 次历史发生)`,
+        }
+
+      case 'replace':
+        return {
+          ...base,
+          action: 'fix',
+          warning: `🔧 SIS 自动修复: ${sig.explanation}`,
+          modifiedParams: this.applyReplace(sig),
+        }
+
+      case 'prepend':
+        return {
+          ...base,
+          action: 'fix',
+          warning: `🔧 SIS 自动修复: ${sig.explanation}`,
+          modifiedParams: this.applyPrepend(params, sig),
+        }
+
+      case 'append':
+        return {
+          ...base,
+          action: 'fix',
+          warning: `🔧 SIS 自动修复: ${sig.explanation}`,
+          modifiedParams: this.applyAppend(params, sig),
+        }
+
+      default:
+        return { ...base, action: 'warn', warning: sig.explanation }
+    }
+  }
+
+  // ── Private: Rule Engine Check ──
+
+  /**
+   * Check against the ExperienceRuleEngine.
+   * Converts the rule engine's {modified, warnings} output to a PreFlightResult.
+   */
+  private checkRuleEngine(
+    toolName: string,
+    params: Record<string, unknown>,
+  ): PreFlightResult | null {
+    if (!this.ruleEngine) return null
+
+    try {
+      const { modified, warnings } = this.ruleEngine.intercept(toolName, params)
+      const hasWarnings = warnings.length > 0
+      const hasModifications = JSON.stringify(modified) !== JSON.stringify(params)
+
+      if (!hasWarnings && !hasModifications) return null
+
+      if (hasModifications) {
+        return {
+          action: 'fix',
+          warning: warnings.join('; '),
+          modifiedParams: modified,
+          explanation: 'CRSI 规则引擎自动修正',
+        }
+      }
+
+      if (hasWarnings) {
+        return {
+          action: 'warn',
+          warning: warnings.join('; '),
+        }
+      }
+    } catch {
+      // Rule engine errors are non-fatal
+    }
+
+    return null
+  }
+
+  // ── Private: Fix Application Helpers ──
+
+  /** 'replace' strategy: replace the entire command string. */
+  private applyReplace(sig: ErrorSignature): Record<string, unknown> {
+    return { command: sig.fixAction }
+  }
+
+  /** 'prepend' strategy: prepend text to the command. */
+  private applyPrepend(
+    params: Record<string, unknown>,
+    sig: ErrorSignature,
+  ): Record<string, unknown> {
+    const cmd = String(params.command ?? '')
+    return { ...params, command: `${sig.fixAction} ${cmd}` }
+  }
+
+  /** 'append' strategy: append text to the command. */
+  private applyAppend(
+    params: Record<string, unknown>,
+    sig: ErrorSignature,
+  ): Record<string, unknown> {
+    const cmd = String(params.command ?? '')
+    return { ...params, command: `${cmd} ${sig.fixAction}` }
+  }
+}

package/src/tools/file/grep.ts

@@ -4,7 +4,15 @@ import { resolveSafe } from '../../security/path'
 
 export const grepTool: ToolDefinition = {
   name: 'Grep',
-  description: 'Search file contents using ripgrep. Fast regex search across files.',
+  description:
+    'Search file contents using ripgrep (rg) — the recommended code search tool. ' +
+    '~10× faster than grep, with automatic fallback to grep if rg is unavailable. ' +
+    'Use this for single-shot regex searches across files. ' +
+    'Prefer Grep over Bash grep/rg for code search; use Bash only for complex ' +
+    'multi-step pipelines (e.g., pipe to sort/uniq/wc, or chained find+xargs). ' +
+    'Best practice: narrow scope with `path` (directory/file) and `include` ' +
+    '(glob pattern, e.g. "*.ts") before searching. ' +
+    'The `pattern` parameter accepts full regex syntax (e.g., "log.*Error", "\\bclass\\s+\\w+").',
   category: 'file',
   permission: 'auto',
   parameters: {

package/src/ui/command-picker.tsx

@@ -17,6 +17,31 @@ interface CommandPickerProps {
 
 const PAGE_SIZE = 12
 
+/**
+ * Split a string into segments, marking which substrings match the query.
+ * Case-insensitive matching. Used to bold matching characters in the picker.
+ */
+function highlightMatches(text: string, query: string): { text: string; match: boolean }[] {
+  if (!query) return [{ text, match: false }]
+  const lowerText = text.toLowerCase()
+  const lowerQuery = query.toLowerCase()
+  const segments: { text: string; match: boolean }[] = []
+  let pos = 0
+  while (pos < text.length) {
+    const idx = lowerText.indexOf(lowerQuery, pos)
+    if (idx === -1) {
+      segments.push({ text: text.slice(pos), match: false })
+      break
+    }
+    if (idx > pos) {
+      segments.push({ text: text.slice(pos, idx), match: false })
+    }
+    segments.push({ text: text.slice(idx, idx + query.length), match: true })
+    pos = idx + query.length
+  }
+  return segments
+}
+
 /**
  * CommandPicker — interactive slash-command selector.
  *
@@ -107,12 +132,20 @@ export function CommandPicker({
         {visible.map((cmd, i) => {
           const globalIdx = i + scrollStart
           const isCursor = globalIdx === cursorIdx
+          const query = filter.startsWith('/') ? filter.slice(1) : filter
+          const segments = highlightMatches(cmd.name, query)
+          const padLen = Math.max(0, 20 - cmd.name.length)
           return (
             <Box key={cmd.name}>
               <Text color={itemColor(isCursor)} bold={itemBold(isCursor)}>
                 {isCursor ? '▶ ' : '  '}
-                {cmd.name.padEnd(20)}
               </Text>
+              {segments.map((seg, j) => (
+                <Text key={j} color={itemColor(isCursor)} bold={itemBold(isCursor) || seg.match}>
+                  {seg.text}
+                </Text>
+              ))}
+              {padLen > 0 && <Text color={itemColor(isCursor)}>{' '.repeat(padLen)}</Text>}
               <Text dimColor>{cmd.description}</Text>
             </Box>
           )

package/src/ui/commands.ts

@@ -656,6 +656,257 @@ const crsiStatsCmd: CommandHandler = async (ctx) => {
   return { content: lines.join('\n') }
 }
 
+const crsiHealthCmd: CommandHandler = async (ctx) => {
+  const engine = ctx.engine.getRuleEngine()
+  const tracker = ctx.engine.getEffectivenessTracker()
+  const db = ctx.engine.getErrorSignatureDB?.()
+  const patternAnalyzer = ctx.engine.getPatternAnalyzer?.()
+
+  const lines: string[] = ['## 🏥 CRSI 系统健康仪表盘', '']
+
+  // ── CRSI Section ──
+  lines.push('### 🧠 CRSI 学习子系统', '')
+  if (engine) {
+    const rules = engine.getActiveRules()
+    const builtin = rules.filter((r) => r.source === 'builtin').length
+    const auto = rules.filter((r) => r.source === 'pattern-analyzer').length
+    const manual = rules.filter((r) => r.source === 'manual').length
+
+    lines.push(`| 指标 | 值 |`)
+    lines.push(`|------|----|`)
+    lines.push(`| 活跃规则 | ${rules.length} (内置 ${builtin} · 自动 ${auto} · 手动 ${manual}) |`)
+
+    if (tracker) {
+      let interceptions = 0
+      let successes = 0
+      for (const r of rules) {
+        const eff = tracker.getEffectiveness(r.id)
+        if (eff) {
+          interceptions += eff.appliedCount
+          successes += eff.successAfterCount
+        }
+      }
+      const crsiRate = interceptions > 0 ? Math.round((successes / interceptions) * 100) : 100
+      lines.push(`| 总拦截次数 | ${interceptions} |`)
+      lines.push(`| 拦截成功率 | ${crsiRate}% |`)
+    }
+
+    // Pattern analysis depth
+    if (patternAnalyzer) {
+      const patterns = patternAnalyzer.analyzeAllAgents()
+      lines.push(`| 已检测模式 | ${patterns.length} |`)
+    }
+
+    lines.push('')
+    lines.push('CRSI 命令: `/crsi rules` `/crsi stats` `/crsi analyze`')
+  } else {
+    lines.push('CRSI 规则引擎未初始化')
+  }
+
+  // ── SIS Section ──
+  lines.push('', '### 🛡️ SIS 自免疫子系统', '')
+  if (db) {
+    const stats = db.getStats()
+    const healthEmoji =
+      stats.avgSuccessRate >= 0.8 ? '🟢' : stats.avgSuccessRate >= 0.5 ? '🟡' : '🔴'
+
+    lines.push(`| 指标 | 值 |`)
+    lines.push(`|------|----|`)
+    lines.push(
+      `| 免疫记忆 | ${stats.total} 条 (🟢${stats.active} · 🟡${stats.degraded} · ⚫${stats.retired}) |`,
+    )
+    lines.push(`| 平均成功率 | ${Math.round(stats.avgSuccessRate * 100)}% |`)
+    lines.push(`| 总拦截 | ${stats.totalInterceptions} 次 |`)
+
+    lines.push('')
+    lines.push('SIS 命令: `/sis errors` `/sis stats` `/sis clear <id>`')
+  } else {
+    lines.push('SIS 自免疫系统未初始化')
+  }
+
+  // ── Overall Health Score ──
+  lines.push('', '### 📊 综合健康评分', '')
+  const crsiScore = engine ? 50 : 0
+  const sisScore = db ? (db.getStats().avgSuccessRate >= 0.8 ? 50 : 25) : 0
+  const totalScore = crsiScore + sisScore
+
+  const grade =
+    totalScore >= 80
+      ? '🟢 A — 优秀'
+      : totalScore >= 50
+        ? '🟡 B — 良好'
+        : totalScore >= 25
+          ? '🟠 C — 需关注'
+          : '🔴 D — 待初始化'
+
+  lines.push(`| 子系统 | 状态 | 得分 |`)
+  lines.push(`|--------|------|------|`)
+  lines.push(`| CRSI 学习 | ${engine ? '✅ 在线' : '❌ 离线'} | ${crsiScore}/50 |`)
+  lines.push(`| SIS 免疫 | ${db ? '✅ 在线' : '❌ 离线'} | ${sisScore}/50 |`)
+  lines.push(`| **综合** | **${grade}** | **${totalScore}/100** |`)
+
+  return { content: lines.join('\n') }
+}
+
+const crsiMetaCmd: CommandHandler = async (ctx) => {
+  const metaEngine = ctx.engine.getMetaRuleEngine?.()
+  if (!metaEngine) {
+    return { content: 'MetaRuleEngine 未初始化。请先运行 `/crsi health` 初始化 CRSI 系统。' }
+  }
+
+  const result = metaEngine.analyze()
+  const lines: string[] = ['## 🔮 CRSI 元规则分析 (RSI Level 3)', '']
+
+  // ── System Health ──
+  lines.push('### 📊 系统健康评分', '')
+  const h = result.systemHealth
+  lines.push(`| 组件 | 得分 |`)
+  lines.push(`|------|------|`)
+  lines.push(`| 错误签名 | ${h.components.errorSignatures}/100 |`)
+  lines.push(`| 预防拦截 | ${h.components.preflightPrevention}/100 |`)
+  lines.push(`| 自动修复 | ${h.components.autoCorrection}/100 |`)
+  lines.push(`| 免疫记忆 | ${h.components.immuneMemory}/100 |`)
+  lines.push(`| 规则有效性 | ${h.components.ruleEffectiveness}/100 |`)
+  lines.push(`| **综合** | **${h.score}/100** |`)
+  lines.push('')
+  lines.push(h.assessment)
+  lines.push('')
+
+  // ── Recommendations ──
+  lines.push('### 💡 优化建议', '')
+  for (const rec of h.recommendations) {
+    lines.push(`- ${rec}`)
+  }
+  lines.push('')
+
+  // ── Meta-Rules ──
+  if (result.metaRules.length > 0) {
+    lines.push(`### 🧬 发现 ${result.metaRules.length} 条元规则`, '')
+
+    for (const mr of result.metaRules) {
+      const confIcon = mr.confidence === 'high' ? '🔴' : mr.confidence === 'medium' ? '🟡' : '🟢'
+      const autoLabel = mr.autoApplicable ? ' [可自动应用]' : ''
+      lines.push(`#### ${confIcon} ${mr.title}${autoLabel}`)
+      lines.push('')
+      lines.push(mr.description)
+      lines.push('')
+      lines.push(`> **建议**: ${mr.recommendation}`)
+      lines.push('')
+      lines.push(
+        `置信度: ${mr.confidence} | 样本量: ${mr.evidence.sampleSize} | 生成时间: ${mr.generatedAt}`,
+      )
+      lines.push('')
+    }
+  } else {
+    lines.push('### 🧬 元规则', '')
+    lines.push(
+      '暂无元规则生成。当系统积累足够的错误签名和规则数据后，元规则引擎将自动发现跨规则模式。',
+    )
+    lines.push('')
+  }
+
+  // ── Auto-applicable summary ──
+  const autoApplicable = metaEngine.getAutoApplicable(result.metaRules)
+  if (autoApplicable.length > 0) {
+    lines.push('### ⚡ 可自动应用', '')
+    lines.push(`${autoApplicable.length} 条元规则可安全自动应用：`)
+    for (const mr of autoApplicable) {
+      lines.push(`- \`${mr.id}\`: ${mr.recommendation}`)
+    }
+    lines.push('')
+    lines.push('使用 `/crsi meta --apply` 自动应用高置信度元规则。')
+  }
+
+  return { content: lines.join('\n') }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// SIS (Self-Immune System)
+// ═══════════════════════════════════════════════════════════════
+
+const sisErrorsCmd: CommandHandler = (ctx) => {
+  const db = ctx.engine.getErrorSignatureDB?.()
+  if (!db) {
+    return { content: 'SIS 自免疫系统未初始化。' }
+  }
+  const sigs = db.getActive()
+  if (sigs.length === 0) {
+    return { content: '🛡️ SIS 免疫记忆为空 — 尚未记录任何错误签名。' }
+  }
+  const lines: string[] = ['## 🛡️ SIS 免疫记忆', '']
+  for (const sig of sigs) {
+    const statusIcon = sig.status === 'active' ? '🟢' : '🟡'
+    lines.push(`- ${statusIcon} \`${sig.id}\` [${sig.category}] ${sig.toolName}`)
+    lines.push(`  模式: \`${sig.pattern.slice(0, 80)}${sig.pattern.length > 80 ? '...' : ''}\``)
+    lines.push(
+      `  修复: ${sig.fixStrategy} → ${sig.fixAction.slice(0, 60)} | 发生 ${sig.occurrences} 次 | 成功率 ${Math.round(sig.successRate * 100)}%`,
+    )
+    lines.push('')
+  }
+  lines.push(`共 ${sigs.length} 条活跃免疫记忆`)
+  lines.push('', '使用 `/sis stats` 查看汇总统计，`/sis clear <id>` 清除指定签名')
+  return { content: lines.join('\n') }
+}
+
+const sisStatsCmd: CommandHandler = (ctx) => {
+  const db = ctx.engine.getErrorSignatureDB?.()
+  if (!db) {
+    return { content: 'SIS 自免疫系统未初始化。' }
+  }
+  const stats = db.getStats()
+  const lines: string[] = ['## 🛡️ SIS 自免疫统计', '']
+  lines.push(`总签名数: ${stats.total}`)
+  lines.push(
+    `🟢 活跃: ${stats.active}  |  🟡 降级: ${stats.degraded}  |  ⚫ 已退役: ${stats.retired}`,
+  )
+  lines.push(`平均成功率: ${Math.round(stats.avgSuccessRate * 100)}%`)
+  lines.push(`总拦截次数: ${stats.totalInterceptions}`)
+  return { content: lines.join('\n') }
+}
+
+const sisClearCmd: CommandHandler = (ctx, args) => {
+  const db = ctx.engine.getErrorSignatureDB?.()
+  if (!db) {
+    return { content: 'SIS 自免疫系统未初始化。' }
+  }
+  const sigId = args[0]?.trim()
+  if (!sigId) {
+    return { content: 'Usage: /sis clear <signature-id>\n\n使用 `/sis errors` 查看所有签名 ID。' }
+  }
+  const sig = db.get(sigId)
+  if (!sig) {
+    return { content: `签名 \`${sigId}\` 未找到。` }
+  }
+  db.retire(sigId)
+  return { content: `已退役签名 \`${sigId}\` (${sig.pattern.slice(0, 50)}...)` }
+}
+
+const sisCleanupCmd: CommandHandler = async (ctx) => {
+  const db = ctx.engine.getErrorSignatureDB?.()
+  if (!db) {
+    return { content: 'SIS 自免疫系统未初始化。' }
+  }
+  // Use dynamic import for ESM compatibility
+  const { ImmuneMemoryGC } = await import('../../src/core/immune-memory-gc.js')
+  const gc = new ImmuneMemoryGC(db)
+  const report = gc.collect()
+  const lines: string[] = ['## 🧹 SIS 免疫记忆清理完成', '']
+  lines.push(`清理前: ${report.before} 条签名`)
+  lines.push(`清理后: ${report.after} 条签名`)
+  lines.push('')
+  if (report.retiredRemoved > 0) lines.push(`🗑️  移除过期退役: ${report.retiredRemoved} 条`)
+  if (report.zeroSuccessRetired > 0) lines.push(`⚠️  退役零成功率: ${report.zeroSuccessRetired} 条`)
+  if (report.duplicatesMerged > 0) lines.push(`🔗 合并重复签名: ${report.duplicatesMerged} 条`)
+  if (
+    report.retiredRemoved === 0 &&
+    report.zeroSuccessRetired === 0 &&
+    report.duplicatesMerged === 0
+  ) {
+    lines.push('✅ 免疫记忆干净，无需清理')
+  }
+  return { content: lines.join('\n') }
+}
+
 // ═══════════════════════════════════════════════════════════════
 // Workflow
 // ═══════════════════════════════════════════════════════════════
@@ -3288,6 +3539,11 @@ const commandsListCmd: CommandHandler = () => {
     '/crsi analyze': 'Tools & Skills',
     '/crsi restore': 'Tools & Skills',
     '/crsi stats': 'Tools & Skills',
+    '/crsi health': 'Tools & Skills',
+    '/crsi meta': 'Tools & Skills',
+    '/sis errors': 'Tools & Skills',
+    '/sis stats': 'Tools & Skills',
+    '/sis clear': 'Tools & Skills',
     '/plan': 'Workflow',
     '/no-plan': 'Workflow',
     '/tdd': 'Workflow',
@@ -3432,6 +3688,12 @@ registry.set('/crsi disable', crsiDisableCmd)
 registry.set('/crsi analyze', crsiAnalyzeCmd)
 registry.set('/crsi restore', crsiRestoreCmd)
 registry.set('/crsi stats', crsiStatsCmd)
+registry.set('/crsi health', crsiHealthCmd)
+registry.set('/crsi meta', crsiMetaCmd)
+registry.set('/sis errors', sisErrorsCmd)
+registry.set('/sis stats', sisStatsCmd)
+registry.set('/sis clear', sisClearCmd)
+registry.set('/sis cleanup', sisCleanupCmd)
 
 // Workflow
 registry.set('/plan', planCmd)
@@ -3588,6 +3850,12 @@ const COMMAND_DESCRIPTIONS: Record<string, string> = {
   '/crsi analyze': 'Manually trigger CRSI pattern analysis across all agents',
   '/crsi restore': 'Restore a disabled or degraded CRSI rule',
   '/crsi stats': 'Show CRSI overall effectiveness statistics',
+  '/crsi health': 'CRSI + SIS unified health dashboard with scoring',
+  '/crsi meta': 'RSI Level 3 meta-rule analysis — rules that improve the rules',
+  '/sis errors': 'List all active SIS immune memory signatures',
+  '/sis stats': 'Show SIS self-immune system aggregate statistics',
+  '/sis clear': 'Retire an immune memory signature by ID',
+  '/sis cleanup': 'Run immune memory garbage collection (dedup + cleanup)',
   '/plan': 'Enter plan mode',
   '/no-plan': 'Exit plan mode',
   '/tdd': 'Test-Driven Development workflow (RED → GREEN → REFACTOR)',