@miphamai/cli 0.23.0 → 0.24.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.23.0",
+  "version": "0.24.1",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",

package/src/agent/agent-context.ts

@@ -5,7 +5,9 @@ import { homedir } from 'node:os'
 import { ContextManager } from '../core/context'
 import type { ToolDefinition } from '../shared/index.ts'
 import type { AgentDefinition } from './types'
+import type { CrsiConfig } from '../shared/index.ts'
 import { AgentExperience } from './agent-experience'
+import { ExperienceRuleExtractor } from './experience-rules.js'
 
 export interface AgentContextResult {
   context: ContextManager
@@ -15,8 +17,14 @@ export interface AgentContextResult {
 /**
  * Load agent memory files from the appropriate scope directory.
  * Returns combined content for injection into the system prompt.
+ *
+ * @param crsiRuleInjection — when false, skip experience rule extraction (CRSI feature flag).
  */
-function loadAgentMemory(agentName: string, scope: 'user' | 'project' | 'local'): string {
+function loadAgentMemory(
+  agentName: string,
+  scope: 'user' | 'project' | 'local',
+  crsiRuleInjection = true,
+): string {
   let memoryDir: string
   const home = homedir()
 
@@ -56,63 +64,16 @@ function loadAgentMemory(agentName: string, scope: 'user' | 'project' | 'local')
     }
   }
 
-  // Load auto-accumulated experience (always from user scope)
-  const exp = new AgentExperience(agentName)
-  const experienceContent = exp.getExperience()
-
+  // Load auto-accumulated experience rules (always from user scope)
+  // Gated by crsi.ruleInjection feature flag
   let experienceMemory = ''
-  if (experienceContent) {
-    const lines = experienceContent.split('\n')
-    const statsIdx = lines.findIndex((l) => l.startsWith('## Stats'))
-    const successIdx = lines.findIndex((l) => l.startsWith('## Success Patterns'))
-    const failureIdx = lines.findIndex((l) => l.startsWith('## Failure Patterns'))
-
-    // Header: content before the first section
-    const firstSection = Math.min(
-      successIdx !== -1 ? successIdx : Infinity,
-      failureIdx !== -1 ? failureIdx : Infinity,
-      statsIdx !== -1 ? statsIdx : Infinity,
-    )
-    const header = lines.slice(0, firstSection === Infinity ? 3 : firstSection)
-
-    // Last 5 success entries (summary line only, not detail)
-    const successLines: string[] = []
-    if (successIdx !== -1) {
-      const endIdx = Math.min(
-        failureIdx !== -1 && failureIdx > successIdx ? failureIdx : Infinity,
-        statsIdx !== -1 && statsIdx > successIdx ? statsIdx : Infinity,
-      )
-      successLines.push(
-        ...lines
-          .slice(successIdx + 1, endIdx === Infinity ? undefined : endIdx)
-          .filter((l) => l.startsWith('- ['))
-          .slice(-5),
-      )
-    }
-
-    // Last 3 failure entries (summary line only, not detail)
-    const failureLines: string[] = []
-    if (failureIdx !== -1) {
-      const endIdx = statsIdx !== -1 && statsIdx > failureIdx ? statsIdx : Infinity
-      failureLines.push(
-        ...lines
-          .slice(failureIdx + 1, endIdx === Infinity ? undefined : endIdx)
-          .filter((l) => l.startsWith('- ['))
-          .slice(-3),
-      )
-    }
-
-    // Stats section (header + stat line)
-    const stats = statsIdx !== -1 ? lines.slice(statsIdx, statsIdx + 3) : []
+  if (crsiRuleInjection) {
+    const exp = new AgentExperience(agentName)
+    const extractor = new ExperienceRuleExtractor()
+    const rules = extractor.prioritize(exp.getRules())
 
-    if (successLines.length > 0 || failureLines.length > 0) {
-      experienceMemory = [
-        '## Agent Experience',
-        ...header.filter((l) => l.trim()),
-        ...successLines,
-        ...failureLines,
-        ...stats,
-      ].join('\n')
+    if (rules.length > 0) {
+      experienceMemory = extractor.formatForInjection(rules)
     }
   }
 
@@ -139,6 +100,7 @@ export function createAgentContext(
   agentDef: AgentDefinition,
   toolRegistry: Map<string, ToolDefinition>,
   contextWindow?: number,
+  crsiConfig?: Partial<CrsiConfig>,
 ): AgentContextResult {
   // Create isolated context
   const context = new ContextManager({
@@ -149,7 +111,8 @@ export function createAgentContext(
   // Build system prompt with optional agent memory
   let systemPrompt = agentDef.systemPrompt
   if (agentDef.memory) {
-    const memory = loadAgentMemory(agentDef.name, agentDef.memory)
+    const ruleInjection = crsiConfig?.ruleInjection !== false
+    const memory = loadAgentMemory(agentDef.name, agentDef.memory, ruleInjection)
     if (memory) {
       systemPrompt = `${systemPrompt}\n\n---\n\n${memory}`
     }

package/src/agent/agent-experience.ts

@@ -1,5 +1,6 @@
 import { mkdirSync, readFileSync, writeFileSync, existsSync, unlinkSync } from 'node:fs'
 import { join } from 'node:path'
+import { ExperienceRuleExtractor, type ExperienceRule } from './experience-rules.js'
 
 const MAX_EXPERIENCES = 20
 
@@ -46,6 +47,13 @@ export class AgentExperience {
     }
   }
 
+  getRules(): ExperienceRule[] {
+    const content = this.getExperience()
+    if (!content) return []
+    const extractor = new ExperienceRuleExtractor()
+    return extractor.extract(content, this.agentName)
+  }
+
   private appendToSection(section: string, entry: string, type: 'success' | 'failure'): void {
     mkdirSync(this.expDir, { recursive: true })
 

package/src/agent/effectiveness-tracker.ts

@@ -0,0 +1,149 @@
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+
+export interface RuleEffectiveness {
+  ruleId: string
+  appliedCount: number
+  successAfterCount: number
+  preRuleFailureRate: number
+  postRuleFailureRate: number
+  status: 'active' | 'degrading' | 'disabled'
+  createdAt: string
+  lastEvaluatedAt: string
+  evaluationHistory: Array<{
+    date: string
+    appliedCount: number
+    failureRate: number
+  }>
+}
+
+const EVAL_THRESHOLD = 10 // evaluate after 10 applications
+const STORE_FILE = 'effectiveness.json'
+
+export class EffectivenessTracker {
+  private data: Map<string, RuleEffectiveness>
+  private storePath: string
+
+  constructor(storeDir: string = join(process.env.HOME || '~', '.mipham', 'rule-engine')) {
+    this.storePath = join(storeDir, STORE_FILE)
+    this.data = new Map()
+  }
+
+  recordApplication(ruleId: string, success: boolean): void {
+    let eff = this.data.get(ruleId)
+    if (!eff) {
+      eff = {
+        ruleId,
+        appliedCount: 0,
+        successAfterCount: 0,
+        preRuleFailureRate: 1.0,
+        postRuleFailureRate: 0,
+        status: 'active',
+        createdAt: new Date().toISOString().slice(0, 10),
+        lastEvaluatedAt: '',
+        evaluationHistory: [],
+      }
+      this.data.set(ruleId, eff)
+    }
+
+    eff.appliedCount++
+    if (success) eff.successAfterCount++
+
+    // Calculate current failure rate
+    if (eff.appliedCount >= EVAL_THRESHOLD) {
+      eff.postRuleFailureRate = 1 - eff.successAfterCount / eff.appliedCount
+    }
+  }
+
+  /**
+   * Evaluate rule effectiveness and return auto-management actions.
+   *
+   * @param autoRuleManagement — when false, skip auto-degrade/disable/enable logic
+   *   but still record evaluation history for manual review. Default true.
+   */
+  evaluate(autoRuleManagement = true): {
+    upgrades: string[]
+    degradations: string[]
+    disables: string[]
+  } {
+    const result = {
+      upgrades: [] as string[],
+      degradations: [] as string[],
+      disables: [] as string[],
+    }
+    const now = new Date().toISOString().slice(0, 10)
+
+    for (const [ruleId, eff] of this.data) {
+      if (eff.appliedCount < EVAL_THRESHOLD) continue
+
+      eff.lastEvaluatedAt = now
+      eff.evaluationHistory.push({
+        date: now,
+        appliedCount: eff.appliedCount,
+        failureRate: eff.postRuleFailureRate,
+      })
+
+      // Keep max 10 history entries
+      if (eff.evaluationHistory.length > 10) {
+        eff.evaluationHistory = eff.evaluationHistory.slice(-10)
+      }
+
+      // Auto-management is gated by crsi.autoRuleManagement feature flag
+      if (!autoRuleManagement) continue
+
+      // Degrade: active rule with high failure rate
+      if (eff.status === 'active' && eff.postRuleFailureRate > 0.6) {
+        eff.status = 'degrading'
+        result.degradations.push(ruleId)
+      }
+
+      // Disable: degrading rule with no improvement across evaluations
+      if (eff.status === 'degrading' && eff.evaluationHistory.length >= 2) {
+        const last = eff.evaluationHistory[eff.evaluationHistory.length - 1]
+        const prev = eff.evaluationHistory[eff.evaluationHistory.length - 2]
+        if (last!.failureRate >= prev!.failureRate) {
+          eff.status = 'disabled'
+          result.disables.push(ruleId)
+        }
+      }
+
+      // Upgrade: degrading rule that has improved significantly
+      if (eff.status === 'degrading' && eff.postRuleFailureRate < 0.4) {
+        eff.status = 'active'
+        result.upgrades.push(ruleId)
+      }
+    }
+
+    return result
+  }
+
+  getEffectiveness(ruleId: string): RuleEffectiveness | null {
+    return this.data.get(ruleId) || null
+  }
+
+  persist(): void {
+    const dir = dirname(this.storePath)
+    mkdirSync(dir, { recursive: true })
+
+    const obj: Record<string, RuleEffectiveness> = {}
+    for (const [k, v] of this.data) {
+      obj[k] = v
+    }
+    writeFileSync(this.storePath, JSON.stringify(obj, null, 2), 'utf-8')
+  }
+
+  load(): void {
+    if (!existsSync(this.storePath)) return
+    try {
+      const raw = JSON.parse(readFileSync(this.storePath, 'utf-8'))
+      this.data = new Map(Object.entries(raw))
+    } catch {
+      // Corrupt file — start fresh
+      this.data = new Map()
+    }
+  }
+
+  get allRules(): RuleEffectiveness[] {
+    return Array.from(this.data.values())
+  }
+}

package/src/agent/experience-rules.ts

@@ -0,0 +1,188 @@
+export interface ExperienceRule {
+  id: string // rule-<category>-<shortHash>
+  type: 'mandatory' | 'warning'
+  condition: string
+  action: string
+  evidence: {
+    failureCount: number
+    lastFailure: string // ISO date
+    examples: string[]
+  }
+  category: 'timeout' | 'import' | 'search' | 'tool-params' | 'semantic'
+  source: 'agent-experience' | 'manual' | 'pattern-analyzer'
+  agentName: string
+  createdAt: string // ISO date
+}
+
+export interface FailureEntry {
+  date: string
+  description: string
+}
+
+export function parseFailureEntries(content: string): FailureEntry[] {
+  const entries: FailureEntry[] = []
+  const failureIdx = content.indexOf('## Failure Patterns')
+  if (failureIdx === -1) return entries
+
+  const afterFailure = content.slice(failureIdx)
+  const nextSection = afterFailure.indexOf('\n## ', '## Failure Patterns'.length)
+  const section = nextSection !== -1 ? afterFailure.slice(0, nextSection) : afterFailure
+
+  const lines = section.split('\n')
+  for (const line of lines) {
+    const match = line.match(/^- \[(\d{4}-\d{2}-\d{2})\]\s+(.+)/)
+    if (match && match[1] && match[2]) {
+      entries.push({ date: match[1], description: match[2].trim() })
+    }
+  }
+  return entries
+}
+
+export function categorize(description: string): ExperienceRule['category'] {
+  const lower = description.toLowerCase()
+  if (lower.includes('timeout')) return 'timeout'
+  if (/module_not_found|import|\.js/.test(lower)) return 'import'
+  if (/grep|token.*overflow|search.*scope/.test(lower)) return 'search'
+  if (/bash|command.*fail|docker|npm|pnpm|cargo|brew/.test(lower)) return 'tool-params'
+  return 'semantic'
+}
+
+function createRuleId(category: string, description: string): string {
+  // Hash the first 30 chars of description for uniqueness
+  const hash = description
+    .slice(0, 30)
+    .split('')
+    .reduce((acc, c) => {
+      return ((acc << 5) - acc + c.charCodeAt(0)) | 0
+    }, 0)
+    .toString(36)
+    .slice(-6)
+  return `rule-${category}-${hash}`
+}
+
+function conditionForCategory(category: string, entries: FailureEntry[]): string {
+  const combined = entries.map((e) => e.description).join('; ')
+  switch (category) {
+    case 'timeout':
+      return 'heavy CLI commands (npm/docker/pnpm)'
+    case 'import':
+      return 'ESM module imports missing .js extension'
+    case 'search':
+      return 'full-repository Grep without directory scoping'
+    case 'tool-params':
+      return combined.slice(0, 100)
+    default:
+      return combined.slice(0, 100)
+  }
+}
+
+function actionForCategory(category: string): string {
+  switch (category) {
+    case 'timeout':
+      return 'set Bash timeout ≥ 300000ms for heavy commands'
+    case 'import':
+      return 'always append .js extension to ESM relative imports'
+    case 'search':
+      return 'use Glob to narrow directory before Grep'
+    case 'tool-params':
+      return 'review and adjust tool parameters before execution'
+    default:
+      return 'verify tool parameters match known good patterns'
+  }
+}
+
+export class ExperienceRuleExtractor {
+  extract(content: string, agentName: string): ExperienceRule[] {
+    if (!content || !content.includes('## Failure Patterns')) return []
+
+    const entries = parseFailureEntries(content)
+    if (entries.length < 2) return []
+
+    // Group by category
+    const byCategory = new Map<string, FailureEntry[]>()
+    for (const entry of entries) {
+      const cat = categorize(entry.description)
+      const existing = byCategory.get(cat) || []
+      existing.push(entry)
+      byCategory.set(cat, existing)
+    }
+
+    const rules: ExperienceRule[] = []
+    for (const [category, catEntries] of byCategory) {
+      if (catEntries.length < 2) continue
+
+      const type: 'mandatory' | 'warning' = catEntries.length >= 3 ? 'mandatory' : 'warning'
+      const firstEntry = catEntries[0]
+      const lastEntry = catEntries[catEntries.length - 1]
+      if (!firstEntry || !lastEntry) continue
+
+      rules.push({
+        id: createRuleId(category, firstEntry.description),
+        type,
+        condition: conditionForCategory(category, catEntries),
+        action: actionForCategory(category),
+        evidence: {
+          failureCount: catEntries.length,
+          lastFailure: lastEntry.date,
+          examples: catEntries.slice(0, 3).map((e) => e.description),
+        },
+        category: category as ExperienceRule['category'],
+        source: 'agent-experience',
+        agentName,
+        createdAt: new Date().toISOString().slice(0, 10),
+      })
+    }
+
+    return rules
+  }
+
+  prioritize(rules: ExperienceRule[]): ExperienceRule[] {
+    const order: Record<string, number> = {
+      mandatory: 0,
+      warning: 1,
+    }
+    return [...rules].sort((a, b) => {
+      const aOrder = order[a.type] ?? 0
+      const bOrder = order[b.type] ?? 0
+      const typeDiff = aOrder - bOrder
+      if (typeDiff !== 0) return typeDiff
+      // Within same type, more failures first
+      return b.evidence.failureCount - a.evidence.failureCount
+    })
+  }
+
+  formatForInjection(rules: ExperienceRule[]): string {
+    if (rules.length === 0) return ''
+
+    const mandatory = rules.filter((r) => r.type === 'mandatory')
+    const warnings = rules.filter((r) => r.type === 'warning')
+
+    let output = ''
+
+    if (mandatory.length > 0) {
+      output += '## ⚠️ Active Mandatory Rules (learned from past failures)\n\n'
+      for (const r of mandatory) {
+        const idx = mandatory.indexOf(r) + 1
+        output += `${idx}. [${r.category}] ${r.condition} → ${r.action}\n`
+        output += `   Evidence: ${r.evidence.failureCount} failures`
+        if (r.evidence.lastFailure) output += `, last: ${r.evidence.lastFailure}`
+        output += '\n'
+        if (r.evidence.examples.length > 0) {
+          output += `   Example: ${r.evidence.examples[0]}\n`
+        }
+        output += '\n'
+      }
+    }
+
+    if (warnings.length > 0) {
+      output += '## ⚡ Observed Patterns (warning level)\n\n'
+      for (const r of warnings) {
+        const idx = warnings.indexOf(r) + 1
+        output += `${idx}. [${r.category}] ${r.condition} → ${r.action}\n`
+        output += `   Evidence: ${r.evidence.failureCount} occurrences\n\n`
+      }
+    }
+
+    return output.trim()
+  }
+}

package/src/agent/pattern-analyzer.ts

@@ -0,0 +1,154 @@
+import { readdirSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+import { AgentExperience } from './agent-experience.js'
+import { parseFailureEntries, categorize, type ExperienceRule } from './experience-rules.js'
+import type { ToolRule } from '../core/rule-engine.js'
+
+export interface Pattern {
+  id: string
+  category: 'timeout' | 'import' | 'search' | 'tool-params' | 'semantic'
+  agentName: string
+  frequency: number
+  confidence: 'high' | 'medium' | 'low'
+  examples: string[]
+  firstSeen: string
+  lastSeen: string
+}
+
+export class PatternAnalyzer {
+  analyzeAgent(agentName: string, baseDir?: string): Pattern[] {
+    const dir = baseDir || join(homedir(), '.mipham', 'agent-memory')
+    const exp = new AgentExperience(agentName, dir)
+    const content = exp.getExperience()
+    if (!content) return []
+
+    const allEntries = parseFailureEntries(content)
+
+    // Group by category
+    const byCategory = new Map<string, { descriptions: string[]; dates: string[] }>()
+    for (const entry of allEntries) {
+      const cat = categorize(entry.description)
+      const existing = byCategory.get(cat) || { descriptions: [], dates: [] }
+      existing.descriptions.push(entry.description)
+      existing.dates.push(entry.date)
+      byCategory.set(cat, existing)
+    }
+
+    const patterns: Pattern[] = []
+    for (const [category, data] of byCategory) {
+      if (data.descriptions.length < 3) continue
+
+      patterns.push({
+        id: `pattern-${category}-${agentName}`,
+        category: category as Pattern['category'],
+        agentName,
+        frequency: data.descriptions.length,
+        confidence: data.descriptions.length >= 5 ? 'high' : 'medium',
+        examples: data.descriptions.slice(0, 5),
+        firstSeen: data.dates[0] ?? '',
+        lastSeen: data.dates[data.dates.length - 1] ?? '',
+      })
+    }
+
+    return patterns
+  }
+
+  analyzeAllAgents(baseDir?: string): Pattern[] {
+    const dir = baseDir || join(homedir(), '.mipham', 'agent-memory')
+    if (!existsSync(dir)) return []
+
+    let agents: string[]
+    try {
+      agents = readdirSync(dir, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name)
+    } catch {
+      return []
+    }
+
+    const allPatterns: Pattern[] = []
+    for (const agent of agents) {
+      allPatterns.push(...this.analyzeAgent(agent, baseDir))
+    }
+    return allPatterns
+  }
+
+  toRule(pattern: Pattern): ExperienceRule {
+    return {
+      id: `${pattern.id}-${Date.now().toString(36)}`,
+      type: pattern.frequency >= 3 ? 'mandatory' : 'warning',
+      condition: this._conditionForCategory(pattern),
+      action: this._actionForCategory(pattern.category),
+      evidence: {
+        failureCount: pattern.frequency,
+        lastFailure: pattern.lastSeen,
+        examples: pattern.examples.slice(0, 3),
+      },
+      category: pattern.category,
+      source: 'pattern-analyzer',
+      agentName: pattern.agentName,
+      createdAt: new Date().toISOString().slice(0, 10),
+    }
+  }
+
+  toToolRule(pattern: Pattern): ToolRule {
+    const toolNameMap: Record<string, string> = {
+      timeout: 'Bash',
+      'tool-params': 'Bash',
+      import: 'Write',
+      search: 'Grep',
+      semantic: 'Bash',
+    }
+
+    return {
+      id: pattern.id,
+      toolName: toolNameMap[pattern.category] || 'Bash',
+      category: pattern.category,
+      match: (p: Record<string, unknown>): boolean => {
+        if (pattern.category === 'timeout') {
+          const cmd = String(p.command ?? '')
+          const heavy = /npm|docker|pnpm|cargo|brew|install|build/.test(cmd)
+          if (!heavy) return false
+          const timeout = (p as Record<string, unknown>).timeout as number | undefined
+          return !timeout || timeout < 300_000
+        }
+        return true
+      },
+      fix: (p: Record<string, unknown>) => ({
+        modified: pattern.category === 'timeout' ? { ...p, timeout: 300_000 } : p,
+        warning: `🤖 [auto-rule] ${pattern.category}: ${pattern.frequency} 次同类失败 — ${this._actionForCategory(pattern.category)}`,
+      }),
+      source: 'pattern-analyzer',
+      enabled: true,
+    }
+  }
+
+  // ── Private helpers ──
+
+  private _conditionForCategory(pattern: Pattern): string {
+    switch (pattern.category) {
+      case 'timeout':
+        return 'heavy CLI commands (npm/docker/pnpm/cargo)'
+      case 'import':
+        return 'ESM module imports missing .js extension'
+      case 'search':
+        return 'full-repository search without directory scoping'
+      default:
+        return pattern.examples[0]?.slice(0, 100) || 'unknown condition'
+    }
+  }
+
+  private _actionForCategory(category: string): string {
+    switch (category) {
+      case 'timeout':
+        return 'set Bash timeout ≥ 300000ms for heavy commands'
+      case 'import':
+        return 'append .js extension to ESM relative imports'
+      case 'search':
+        return 'use Glob to narrow directory before Grep'
+      default:
+        return 'review and adjust tool parameters before execution'
+    }
+  }
+}