@miphamai/cli 0.23.0 → 0.24.1

package/src/agent/sub-agent.ts

@@ -7,6 +7,16 @@ import { getMessageBus } from './message-bus'
 import type { HookEngine } from '../core/hooks'
 import type { PermissionSystem } from '../core/permission'
 import { AgentExperience } from './agent-experience'
+import { PatternAnalyzer } from './pattern-analyzer.js'
+import type { ExperienceRuleEngine } from '../core/rule-engine.js'
+
+// Singleton instances (created lazily)
+let _patternAnalyzer: PatternAnalyzer | undefined
+
+function getPatternAnalyzer(): PatternAnalyzer {
+  if (!_patternAnalyzer) _patternAnalyzer = new PatternAnalyzer()
+  return _patternAnalyzer
+}
 
 const TYPE_SYSTEM_PROMPTS: Record<SubAgentType, string> = {
   general: 'You are a focused sub-agent. Complete the assigned task thoroughly and return results.',
@@ -32,6 +42,7 @@ export class SubAgent {
     private toolRegistry: Map<string, ToolDefinition>,
     private permission?: PermissionSystem,
     private hookEngine?: HookEngine,
+    private ruleEngine?: ExperienceRuleEngine,
   ) {}
 
   /**
@@ -85,6 +96,24 @@ export class SubAgent {
             options.agentDef,
           )
         }
+
+        // CRSI: trigger pattern analysis after each agent execution
+        // Gated by crsi.autoPatternAnalysis feature flag
+        if (options.autoPatternAnalysis !== false) {
+          try {
+            const analyzer = getPatternAnalyzer()
+            const agentName = options.agentDef?.name || agentType
+            const patterns = analyzer.analyzeAgent(agentName)
+            if (patterns.length > 0 && this.ruleEngine) {
+              for (const pattern of patterns) {
+                const toolRule = analyzer.toToolRule(pattern)
+                this.ruleEngine.register(toolRule)
+              }
+            }
+          } catch {
+            // Pattern analysis failure never blocks agent execution
+          }
+        }
       })
 
       return `[background-task:${taskId}]`
@@ -97,6 +126,25 @@ export class SubAgent {
         await this.hookEngine.executeSubagentStop(agentType, description, 'sub-agent', true, result)
       }
       this.logSuccessExperience(agentType, description, result, options.agentDef)
+
+      // CRSI: trigger pattern analysis after successful sync execution
+      // Gated by crsi.autoPatternAnalysis feature flag
+      if (options.autoPatternAnalysis !== false) {
+        try {
+          const analyzer = getPatternAnalyzer()
+          const agentName = options.agentDef?.name || agentType
+          const patterns = analyzer.analyzeAgent(agentName)
+          if (patterns.length > 0 && this.ruleEngine) {
+            for (const pattern of patterns) {
+              const toolRule = analyzer.toToolRule(pattern)
+              this.ruleEngine.register(toolRule)
+            }
+          }
+        } catch {
+          // Pattern analysis failure never blocks agent execution
+        }
+      }
+
       return result
     } catch (err) {
       if (this.hookEngine) {
@@ -109,6 +157,25 @@ export class SubAgent {
         )
       }
       this.logFailureExperience(agentType, description, String(err), options.agentDef)
+
+      // CRSI: trigger pattern analysis after failed sync execution (failures produce patterns too)
+      // Gated by crsi.autoPatternAnalysis feature flag
+      if (options.autoPatternAnalysis !== false) {
+        try {
+          const analyzer = getPatternAnalyzer()
+          const agentName = options.agentDef?.name || agentType
+          const patterns = analyzer.analyzeAgent(agentName)
+          if (patterns.length > 0 && this.ruleEngine) {
+            for (const pattern of patterns) {
+              const toolRule = analyzer.toToolRule(pattern)
+              this.ruleEngine.register(toolRule)
+            }
+          }
+        } catch {
+          // Pattern analysis failure never blocks agent execution
+        }
+      }
+
       throw err
     }
   }

package/src/agent/types.ts

@@ -46,4 +46,6 @@ export interface SubAgentOptions {
   onProgress?: (chunk: string) => void
   /** When set, tool executions use this path as cwd (git worktree isolation). */
   worktreePath?: string
+  /** CRSI: when false, skip pattern analysis after agent execution. Default true. */
+  autoPatternAnalysis?: boolean
 }

package/src/config/defaults.ts

@@ -22,6 +22,12 @@ export const DEFAULT_CONFIG: MiphamConfig = {
     mcp: { oauthEnabled: true },
     context: { useRealTokenizer: true, adaptiveThresholds: true },
   },
+  crsi: {
+    ruleInjection: true,
+    preToolHook: true,
+    autoPatternAnalysis: true,
+    autoRuleManagement: true,
+  },
 }
 
 export const DEFAULT_INFERENCE_HOOK_CONFIG: InferenceHookConfig = {

package/src/core/engine.ts

@@ -3,6 +3,7 @@ import type {
   ToolDefinition,
   ToolResult,
   InferenceHookConfig,
+  CrsiConfig,
 } from '../shared/index.ts'
 import { ProviderRegistry } from '../providers/registry'
 import { ContextManager } from './context'
@@ -16,6 +17,9 @@ import type { AgentViewManager } from '../agent-view/agent-view-manager'
 import type { SkillsLoader } from '../skills/loader'
 import { getBackgroundAgentRegistry } from '../agent/background-registry'
 import { RulesLoader } from './rules-loader'
+import { ExperienceRuleEngine } from './rule-engine.js'
+import { PatternAnalyzer } from '../agent/pattern-analyzer.js'
+import { EffectivenessTracker } from '../agent/effectiveness-tracker.js'
 import { UsageTracker } from './usage-tracker'
 import { buildRequest, sendInferenceCheck, isInferenceHookEnabled } from './inference-hook'
 import { getFileInboxTransport } from '../agent/cross-session/file-inbox'
@@ -37,6 +41,9 @@ export class QueryEngine {
   private agentRegistry?: AgentRegistry
   private agentViewManager?: AgentViewManager
   private skillsLoader?: SkillsLoader
+  private ruleEngine?: ExperienceRuleEngine
+  private _patternAnalyzer?: PatternAnalyzer
+  private _effectivenessTracker?: EffectivenessTracker
   private goal?: string
   private maxGoalLoops = 20
   private lastAssistantContent?: string
@@ -54,7 +61,10 @@ export class QueryEngine {
     private context: ContextManager,
     private tools: Map<string, ToolDefinition>,
     private permission: PermissionSystem = new PermissionSystem('default'),
-  ) {}
+    ruleEngine?: ExperienceRuleEngine,
+  ) {
+    this.ruleEngine = ruleEngine
+  }
 
   /** Session identifier for cross-session messaging. Set by the app startup via setSessionId(). */
   private sessionId: string = 'session-1'
@@ -128,6 +138,8 @@ export class QueryEngine {
   private usageTracker = new UsageTracker()
   /** Inference hook (DLP) configuration. */
   private inferenceHookConfig?: InferenceHookConfig
+  /** CRSI feature flags. */
+  private crsiConfig?: Partial<CrsiConfig>
 
   /** Register the rules loader. */
   setRulesLoader(loader: RulesLoader): void {
@@ -140,6 +152,11 @@ export class QueryEngine {
     this.inferenceHookConfig = config
   }
 
+  /** Register CRSI feature flags. */
+  setCrsiConfig(config: Partial<CrsiConfig> | undefined): void {
+    this.crsiConfig = config
+  }
+
   /** Pending task notifications from background agents (cleared after draining). */
   private pendingTaskNotifications: Array<StreamChunk> = []
 
@@ -796,6 +813,7 @@ export class QueryEngine {
 
     // Run PreToolUse hooks
     let effectiveParams = params
+    let hookWarnings: string[] = []
     if (this.hookEngine) {
       const preResult = await this.hookEngine.executePreToolUse(name, params, this.sessionId)
       if (!preResult.allowed) {
@@ -810,6 +828,17 @@ export class QueryEngine {
       }
     }
 
+    // CRSI RuleEngine intercept — gated by crsi.preToolHook feature flag
+    if (this.crsiConfig?.preToolHook !== false && this.ruleEngine) {
+      const ruleResult = this.ruleEngine.intercept(name, effectiveParams)
+      if (Object.keys(ruleResult.modified).length > 0) {
+        effectiveParams = ruleResult.modified
+      }
+      if (ruleResult.warnings.length > 0) {
+        hookWarnings = ruleResult.warnings
+      }
+    }
+
     try {
       const result = await tool.execute(effectiveParams, {
         cwd: process.cwd(),
@@ -823,16 +852,35 @@ export class QueryEngine {
         agentRegistry: this.agentRegistry,
         backgroundAgentRegistry: getBackgroundAgentRegistry(),
         permissionSystem: this.permission,
+        ruleEngine: this.ruleEngine,
       })
 
       // Track touched files for rules matching
       this.trackTouchedFile(name, effectiveParams)
 
+      // Prepend CRSI warnings to result content
+      if (hookWarnings.length > 0 && result.success) {
+        result.content = hookWarnings.join('\n') + '\n' + (result.content || '')
+      }
+
       // Run PostToolUse hooks
       if (this.hookEngine) {
         await this.hookEngine.executePostToolUse(name, effectiveParams, result, this.sessionId)
       }
 
+      // CRSI: Track rule effectiveness after tool execution
+      if (hookWarnings.length > 0) {
+        const tracker = this.getEffectivenessTracker()
+        for (const warning of hookWarnings) {
+          const match = warning.match(/^\[rule:([^\]]+)\]/)
+          const ruleId = match?.[1]
+          if (ruleId) {
+            tracker.recordApplication(ruleId, result.success)
+          }
+        }
+        tracker.persist()
+      }
+
       return result
     } catch (err) {
       // Sanitize error: strip stack traces and internal paths to prevent
@@ -864,6 +912,27 @@ export class QueryEngine {
     return this.tools
   }
 
+  getRuleEngine(): ExperienceRuleEngine | undefined {
+    return this.ruleEngine
+  }
+
+  /** Lazily-initialized PatternAnalyzer singleton. */
+  getPatternAnalyzer(): PatternAnalyzer {
+    if (!this._patternAnalyzer) {
+      this._patternAnalyzer = new PatternAnalyzer()
+    }
+    return this._patternAnalyzer
+  }
+
+  /** Lazily-initialized EffectivenessTracker singleton. */
+  getEffectivenessTracker(): EffectivenessTracker {
+    if (!this._effectivenessTracker) {
+      this._effectivenessTracker = new EffectivenessTracker()
+      this._effectivenessTracker.load()
+    }
+    return this._effectivenessTracker
+  }
+
   /** Register a tool dynamically (used by MCP auto-registration). */
   registerTool(tool: ToolDefinition): void {
     if (this.tools.has(tool.name)) {

package/src/core/rule-engine.ts

@@ -0,0 +1,179 @@
+import type { ExperienceRule } from '../agent/experience-rules.js'
+import { mkdirSync, writeFileSync, readFileSync, existsSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+
+export interface ToolRule {
+  id: string
+  toolName: string
+  category: string
+  match: (params: Record<string, unknown>) => boolean
+  fix: (params: Record<string, unknown>) => {
+    modified: Record<string, unknown>
+    warning: string
+  }
+  source: 'builtin' | 'pattern-analyzer' | 'manual'
+  enabled: boolean
+}
+
+const BUILTIN_RULES: ToolRule[] = [
+  {
+    id: 'rule-timeout-bash-heavy',
+    toolName: 'Bash',
+    category: 'timeout',
+    match: (p: Record<string, unknown>) => {
+      const cmd = String(p.command ?? '')
+      const heavy = /npm (install|ci|test)|docker build|pnpm install|cargo build|brew install/.test(
+        cmd,
+      )
+      if (!heavy) return false
+      const timeout = (p as Record<string, unknown>).timeout as number | undefined
+      return !timeout || timeout < 300_000
+    },
+    fix: (p: Record<string, unknown>) => {
+      const prevTimeout = (p as Record<string, unknown>).timeout as number | undefined
+      return {
+        modified: { ...p, timeout: 300_000 },
+        warning: `⏱️ timeout 已从 ${prevTimeout || 'default'}ms 自动提升至 300000ms（该命令类型历史超时率 > 50%）`,
+      }
+    },
+    source: 'builtin',
+    enabled: true,
+  },
+  {
+    id: 'rule-git-force-protection',
+    toolName: 'Bash',
+    category: 'tool-params',
+    match: (p: Record<string, unknown>) => {
+      const cmd = String(p.command ?? '')
+      return /git (push|reset) .*--force/.test(cmd) && !p.dangerouslyDisableSandbox
+    },
+    fix: (p: Record<string, unknown>) => ({
+      modified: p,
+      warning: '⚠️ 检测到 git --force 操作。如需执行请设置 dangerouslyDisableSandbox: true',
+    }),
+    source: 'builtin',
+    enabled: true,
+  },
+]
+
+export class ExperienceRuleEngine {
+  private rules: ToolRule[]
+  private storePath: string
+
+  constructor(storeDir: string = join(process.env.HOME || '~', '.mipham', 'rule-engine')) {
+    this.rules = [...BUILTIN_RULES.map((r) => ({ ...r }))]
+    this.storePath = join(storeDir, 'rules.json')
+    this.load()
+  }
+
+  register(rule: ToolRule): void {
+    // Replace if same ID exists, otherwise append
+    const idx = this.rules.findIndex((r) => r.id === rule.id)
+    if (idx !== -1) {
+      this.rules[idx] = rule
+    } else {
+      this.rules.push(rule)
+    }
+    this.persist()
+  }
+
+  intercept(
+    toolName: string,
+    params: Record<string, unknown>,
+  ): { modified: Record<string, unknown>; warnings: string[] } {
+    let modified = params
+    const warnings: string[] = []
+
+    for (const rule of this.rules) {
+      if (!rule.enabled) continue
+      if (rule.toolName !== toolName) continue
+
+      try {
+        if (rule.match(modified)) {
+          const result = rule.fix(modified)
+          modified = result.modified
+          if (result.warning) {
+            warnings.push(`[rule:${rule.id}] ${result.warning}`)
+          }
+        }
+      } catch {
+        // Rule match/fix failures never block execution
+      }
+    }
+
+    return { modified, warnings }
+  }
+
+  convertFromExperienceRules(experienceRules: ExperienceRule[]): ToolRule[] {
+    return experienceRules.map((er): ToolRule => {
+      // Map experience rule category to tool name
+      const toolNameMap: Record<string, string> = {
+        timeout: 'Bash',
+        'tool-params': 'Bash',
+        import: 'Write',
+        search: 'Grep',
+        semantic: 'Bash',
+      }
+      const toolName = toolNameMap[er.category] || 'Bash'
+
+      return {
+        id: er.id,
+        toolName,
+        category: er.category,
+        match: (p: Record<string, unknown>): boolean => {
+          if (er.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
+          }
+          // Default: always match for the given tool
+          return true
+        },
+        fix: (p: Record<string, unknown>) => ({
+          modified: { ...p, timeout: 300_000 },
+          warning: `⏱️ [auto-rule] ${er.action} (${er.evidence.failureCount} 次历史失败)`,
+        }),
+        source: 'pattern-analyzer',
+        enabled: true,
+      }
+    })
+  }
+
+  getActiveRules(): ToolRule[] {
+    return this.rules.filter((r) => r.enabled)
+  }
+
+  setRuleEnabled(id: string, enabled: boolean): void {
+    const rule = this.rules.find((r) => r.id === id)
+    if (rule) {
+      rule.enabled = enabled
+      this.persist()
+    }
+  }
+
+  /** Persist non-builtin rules to disk. */
+  persist(): void {
+    const nonBuiltin = this.rules.filter((r) => r.source !== 'builtin')
+    const dir = dirname(this.storePath)
+    mkdirSync(dir, { recursive: true })
+    writeFileSync(this.storePath, JSON.stringify(nonBuiltin, null, 2), 'utf-8')
+  }
+
+  /** Load persisted non-builtin rules from disk. Rejects rules whose IDs conflict with builtins. */
+  load(): void {
+    if (!existsSync(this.storePath)) return
+    try {
+      const raw = JSON.parse(readFileSync(this.storePath, 'utf-8')) as ToolRule[]
+      const builtinIds = new Set(BUILTIN_RULES.map((r) => r.id))
+      for (const rule of raw) {
+        // Reject if a builtin with the same ID exists (builtins always win)
+        if (builtinIds.has(rule.id)) continue
+        this.rules.push(rule)
+      }
+    } catch {
+      // Corrupt file — start fresh with only builtins
+    }
+  }
+}

package/src/index.tsx

@@ -20,6 +20,7 @@ import { InstructionsLoader } from './core/instructions'
 import { loadSessionMemories, getMemoryManager } from './core/memory/memory-loader'
 import { ContextManager } from './core/context'
 import { QueryEngine } from './core/engine'
+import { ExperienceRuleEngine } from './core/rule-engine.js'
 import { SessionStore } from './core/session-store'
 import type { PermissionLevel } from './shared/types'
 import { SkillsLoader } from './skills/loader'
@@ -247,7 +248,8 @@ export async function runApp(options: RunOptions): Promise<void> {
   const artifactServer = new ArtifactServer(artifactsDir, ARTIFACT_PORT)
 
   // Create query engine
-  const engine = new QueryEngine(registry, context, tools)
+  const ruleEngine = new ExperienceRuleEngine()
+  const engine = new QueryEngine(registry, context, tools, undefined, ruleEngine)
   engine.setHookEngine(hookEngine)
   engine.setArtifactServer(artifactServer)
   engine.setAgentViewManager(agentViewManager)

package/src/shared/types.ts

@@ -72,6 +72,7 @@ export interface ToolContext {
   agentRegistry?: import('../agent/agent-registry').AgentRegistry
   backgroundAgentRegistry?: import('../agent/background-registry').BackgroundAgentRegistry
   permissionSystem?: import('../core/permission').PermissionSystem
+  ruleEngine?: import('../core/rule-engine').ExperienceRuleEngine
 }
 
 // ── Artifact Types ──
@@ -162,6 +163,8 @@ export interface MiphamConfig {
   }
   /** Phase 9 feature flags. All default to true. */
   features?: Partial<FeatureFlags>
+  /** Phase 10 CRSI feature flags. All default to true. */
+  crsi?: Partial<CrsiConfig>
 }
 
 export interface FeatureFlags {
@@ -169,6 +172,17 @@ export interface FeatureFlags {
   context: { useRealTokenizer: boolean; adaptiveThresholds: boolean }
 }
 
+export interface CrsiConfig {
+  /** Extract and inject experience rules into agent system prompts. */
+  ruleInjection: boolean
+  /** Intercept tool calls and auto-fix known failure patterns before execution. */
+  preToolHook: boolean
+  /** Analyze agent outcomes for recurring failure patterns. */
+  autoPatternAnalysis: boolean
+  /** Auto-degrade/disable low-effectiveness rules based on success-rate tracking. */
+  autoRuleManagement: boolean
+}
+
 export interface McpServerConfig {
   name: string
   command: string

package/src/tools/agent/agent.ts

@@ -60,7 +60,13 @@ export const agentTool: ToolDefinition = {
     const agentDef = ctx.agentRegistry?.resolve(agentType)
 
     try {
-      const sub = new SubAgent(registry, toolRegistry, ctx.permissionSystem)
+      const sub = new SubAgent(
+        registry,
+        toolRegistry,
+        ctx.permissionSystem,
+        undefined,
+        ctx.ruleEngine,
+      )
       const result = await sub.execute(prompt, description, {
         type: agentType,
         agentDef,

package/src/tools/file/edit.ts

@@ -2,10 +2,65 @@ import { readFileSync, writeFileSync } from 'node:fs'
 import type { ToolDefinition } from '../../shared/index.ts'
 import { resolveSafe } from '../../security/path'
 
+/**
+ * Characters considered part of an identifier in source code.
+ * A match is only valid if it sits at identifier boundaries —
+ * i.e. not embedded inside a larger identifier word.
+ */
+function isIdentifierChar(c: string): boolean {
+  return /[a-zA-Z0-9_$]/.test(c)
+}
+
+/**
+ * Find all valid occurrences of `oldStr` in `content`.
+ * A match is valid only when it does NOT sit inside a larger identifier:
+ * - If oldStr starts with an identifier char, the char before the match
+ *   must NOT be an identifier char (or the match must be at position 0).
+ * - If oldStr ends with an identifier char, the char after the match
+ *   must NOT be an identifier char (or the match must be at end of file).
+ */
+function findValidMatches(content: string, oldStr: string): number[] {
+  const indices: number[] = []
+  // oldStr is guaranteed non-empty by the required parameter validation
+  const oldFirst = oldStr[0]!
+  const oldLast = oldStr[oldStr.length - 1]!
+  const checkLeft = isIdentifierChar(oldFirst)
+  const checkRight = isIdentifierChar(oldLast)
+
+  let pos = 0
+  while (pos < content.length) {
+    const idx = content.indexOf(oldStr, pos)
+    if (idx === -1) break
+
+    // Left boundary check: if oldStr starts with identifier char,
+    // the character before the match must not be an identifier char.
+    if (checkLeft && idx > 0 && isIdentifierChar(content[idx - 1]!)) {
+      pos = idx + 1
+      continue
+    }
+
+    // Right boundary check: if oldStr ends with identifier char,
+    // the character after the match must not be an identifier char.
+    const afterIdx = idx + oldStr.length
+    if (checkRight && afterIdx < content.length && isIdentifierChar(content[afterIdx]!)) {
+      pos = idx + 1
+      continue
+    }
+
+    indices.push(idx)
+    pos = idx + 1
+  }
+
+  return indices
+}
+
 export const editTool: ToolDefinition = {
   name: 'Edit',
   description:
-    'Perform exact string replacement in a file. old_string must match exactly and be unique.',
+    'Perform exact string replacement in a file. ' +
+    'old_string must match exactly as a standalone occurrence — it will NOT match inside larger ' +
+    'identifiers or words (e.g. "user" will not match inside "username"). ' +
+    'Must be unique in the file (unless replace_all is used).',
   category: 'file',
   permission: 'ask',
   parameters: {
@@ -43,22 +98,30 @@ export const editTool: ToolDefinition = {
       }
     }
 
-    if (replaceAll) {
-      if (!content.includes(oldStr)) {
-        return { success: false, content: '', error: 'old_string not found in file' }
+    const matches = findValidMatches(content, oldStr)
+
+    if (matches.length === 0) {
+      return {
+        success: false,
+        content: '',
+        error:
+          'old_string not found in file. ' +
+          'It may appear only as part of a larger word/identifier — provide more context.',
       }
-      const updated = content.replaceAll(oldStr, newStr)
-      writeFileSync(filePath, updated, 'utf-8')
-      const count = content.split(oldStr).length - 1
-      return { success: true, content: `Replaced ${count} occurrences in ${filePath}` }
     }
 
-    const firstIndex = content.indexOf(oldStr)
-    if (firstIndex === -1) {
-      return { success: false, content: '', error: 'old_string not found in file' }
+    if (replaceAll) {
+      // Build result by splicing at each match (in reverse so indices stay valid)
+      let result = content
+      for (let i = matches.length - 1; i >= 0; i--) {
+        const idx = matches[i]!
+        result = result.slice(0, idx) + newStr + result.slice(idx + oldStr.length)
+      }
+      writeFileSync(filePath, result, 'utf-8')
+      return { success: true, content: `Replaced ${matches.length} occurrences in ${filePath}` }
     }
-    const secondIndex = content.indexOf(oldStr, firstIndex + 1)
-    if (secondIndex !== -1) {
+
+    if (matches.length > 1) {
       return {
         success: false,
         content: '',
@@ -66,8 +129,8 @@ export const editTool: ToolDefinition = {
       }
     }
 
-    const updated =
-      content.slice(0, firstIndex) + newStr + content.slice(firstIndex + oldStr.length)
+    const idx = matches[0]!
+    const updated = content.slice(0, idx) + newStr + content.slice(idx + oldStr.length)
     writeFileSync(filePath, updated, 'utf-8')
     return { success: true, content: `Replaced 1 occurrence in ${filePath}` }
   },