@miphamai/cli 0.32.7 → 0.33.0

package/package.json

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

package/src/core/auto-corrector.ts

@@ -0,0 +1,220 @@
+/**
+ * SIS Phase 2: Auto-Corrector — Post-Error Self-Healing
+ *
+ * Second defense line of the self-immune system. When a tool call fails:
+ *   1. Analyzes the error against ErrorSignatureDB for known patterns
+ *   2. If a high-confidence fix exists → returns corrected params for re-execution
+ *   3. If a low-confidence match → returns suggestion without auto-applying
+ *   4. Feeds new error patterns back to ErrorSignatureDB for future immunity
+ *
+ * Distinct from PreFlightChecker (pre-execution prevention) — AutoCorrector
+ * handles errors AFTER they occur, enabling real-time self-healing.
+ *
+ * Flow:
+ *   Tool executes → fails → AutoCorrector.analyze() → match & fix
+ *     → if fix available: re-execute with corrected params
+ *     → if no fix: record error signature, let user handle
+ */
+
+import type { ErrorSignatureDB, ErrorSignature } from './error-signature-db.js'
+
+// ── Types ──
+
+export interface CorrectionResult {
+  /** Whether a correction was found */
+  corrected: boolean
+  /** The action taken */
+  action: 'retry' | 'suggest' | 'record-only'
+  /** Corrected parameters (for 'retry' action) */
+  correctedParams?: Record<string, unknown>
+  /** Human-readable suggestion (for 'suggest' action) */
+  suggestion?: string
+  /** Matched error signature (for tracking) */
+  matchedSignature?: string
+  /** New signature created (for tracking) */
+  newSignatureId?: string
+}
+
+// ── Constants ──
+
+/** Minimum success rate to auto-retry with corrected params */
+const AUTO_RETRY_THRESHOLD = 0.7
+
+/** Maximum retry attempts per tool call to prevent infinite loops */
+const MAX_RETRIES = 1
+
+// ── Corrector ──
+
+export class AutoCorrector {
+  private errorDB: ErrorSignatureDB
+
+  constructor(errorDB: ErrorSignatureDB) {
+    this.errorDB = errorDB
+  }
+
+  /**
+   * Analyze a failed tool call and attempt correction.
+   *
+   * @param toolName  — e.g. 'Bash', 'Write'
+   * @param params    — original tool parameters
+   * @param error     — error message from the failed execution
+   * @param retryCount — current retry count (0-indexed)
+   * @returns CorrectionResult with action and corrected params if applicable
+   */
+  analyze(
+    toolName: string,
+    params: Record<string, unknown>,
+    error: string,
+    retryCount: number = 0,
+  ): CorrectionResult {
+    // Guard against infinite retry loops
+    if (retryCount >= MAX_RETRIES) {
+      return { corrected: false, action: 'record-only' }
+    }
+
+    // ── Step 1: Try to match against known error signatures ──
+    const sig = this.errorDB.match(toolName, {
+      ...params,
+      error,
+    })
+
+    if (sig) {
+      return this.handleKnownError(sig, params, error)
+    }
+
+    // ── Step 2: No match — record as new signature for future immunity ──
+    return this.handleUnknownError(toolName, params, error)
+  }
+
+  /**
+   * Record a manual correction (user fixed it themselves).
+   * Updates the signature's success rate.
+   */
+  recordManualFix(signatureId: string, success: boolean): void {
+    this.errorDB.recordResult(signatureId, success)
+  }
+
+  // ── Private ──
+
+  /** Handle a known error pattern with an existing signature. */
+  private handleKnownError(
+    sig: ErrorSignature,
+    params: Record<string, unknown>,
+    _error: string,
+  ): CorrectionResult {
+    const confidence = sig.successRate
+
+    // High confidence → auto-retry with corrected params
+    if (
+      confidence >= AUTO_RETRY_THRESHOLD &&
+      sig.fixStrategy !== 'warn' &&
+      sig.fixStrategy !== 'block'
+    ) {
+      const correctedParams = this.applyFix(sig, params)
+      return {
+        corrected: true,
+        action: 'retry',
+        correctedParams,
+        matchedSignature: sig.id,
+      }
+    }
+
+    // Low/medium confidence → suggest but don't auto-apply
+    return {
+      corrected: false,
+      action: 'suggest',
+      suggestion: `🔧 SIS 建议: ${sig.explanation}\n   修复方案: ${sig.fixStrategy} → ${sig.fixAction}\n   历史成功率: ${Math.round(confidence * 100)}% (${sig.occurrences} 次)\n   使用 \`/sis errors\` 查看详情`,
+      matchedSignature: sig.id,
+    }
+  }
+
+  /** Handle an unknown error — record it for future immunity. */
+  private handleUnknownError(
+    toolName: string,
+    params: Record<string, unknown>,
+    error: string,
+  ): CorrectionResult {
+    // Extract a searchable pattern from the error
+    const pattern = this.extractPattern(error)
+    const category = this.categorizeError(error, toolName, params)
+
+    const sig = this.errorDB.insert({
+      pattern,
+      category,
+      toolName,
+      fixStrategy: 'warn', // default: warn until we learn a fix
+      fixAction: '',
+      explanation: `未知错误模式: ${error.slice(0, 100)}`,
+    })
+
+    return {
+      corrected: false,
+      action: 'record-only',
+      newSignatureId: sig.id,
+      suggestion:
+        `🆕 SIS 已记录新错误签名 \`${sig.id}\` (${category})。` + `此错误再次发生时将被自动识别。`,
+    }
+  }
+
+  /** Apply a signature's fix to the original params. */
+  private applyFix(sig: ErrorSignature, params: Record<string, unknown>): Record<string, unknown> {
+    switch (sig.fixStrategy) {
+      case 'replace':
+        return { ...params, command: sig.fixAction }
+
+      case 'prepend': {
+        const cmd = String(params.command ?? '')
+        return { ...params, command: `${sig.fixAction} ${cmd}` }
+      }
+
+      case 'append': {
+        const cmd = String(params.command ?? '')
+        return { ...params, command: `${cmd} ${sig.fixAction}` }
+      }
+
+      default:
+        return params
+    }
+  }
+
+  /**
+   * Extract a stable, searchable pattern from an error message.
+   * Strips dynamic content (paths, timestamps, UUIDs) to create a reusable signature.
+   */
+  private extractPattern(error: string): string {
+    // Remove dynamic content
+    const cleaned = error
+      .replace(/\/[^\s]+\/[^\s]*/g, '/<path>') // paths
+      .replace(/\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}/g, '<timestamp>') // timestamps
+      .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, '<uuid>') // UUIDs
+      .replace(/\d+/g, '<n>') // numbers
+      .replace(/\s+/g, ' ') // normalize whitespace
+      .trim()
+
+    // Take first 200 chars as the pattern
+    return cleaned.slice(0, 200)
+  }
+
+  /**
+   * Categorize an error into one of the known CRSI categories.
+   * Mirrors AutoMemoryEngine.categorizeFailure() logic for consistency.
+   */
+  private categorizeError(
+    error: string,
+    toolName: string,
+    params: Record<string, unknown>,
+  ): string {
+    const err = error.toLowerCase()
+    const cmd = String(params.command || params.description || '').toLowerCase()
+
+    if (err.includes('timeout') || err.includes('timed out')) return 'timeout'
+    if (cmd.includes('--force') || cmd.includes('rm -rf')) return 'tool-params'
+    if (err.includes('import') || err.includes('module') || err.includes('.js')) return 'import'
+    if (toolName === 'Grep' && err.includes('no matches')) return 'search'
+    if (err.includes('permission') || err.includes('denied') || err.includes('eacces'))
+      return 'tool-params'
+    if (err.includes('not found') || err.includes('enoent')) return 'semantic'
+
+    return 'semantic'
+  }
+}

package/src/core/auto-memory.ts

@@ -15,6 +15,7 @@ import { MemoryManager, type MemoryEntry } from './memory/memory-manager.js'
 import type { PatternAnalyzer, Pattern } from '../agent/pattern-analyzer.js'
 import type { ExperienceRuleEngine, ToolRule } from './rule-engine.js'
 import type { EffectivenessTracker } from '../agent/effectiveness-tracker.js'
+import type { ErrorSignatureDB } from './error-signature-db.js'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
 
@@ -86,6 +87,7 @@ export class AutoMemoryEngine {
   private patternAnalyzer?: PatternAnalyzer
   private ruleEngine?: ExperienceRuleEngine
   private effectivenessTracker?: EffectivenessTracker
+  private errorSignatureDB?: ErrorSignatureDB
 
   /** Accumulated reflections for the current session (not yet persisted to disk). */
   private sessionReflections: TurnReflection[] = []
@@ -111,6 +113,15 @@ export class AutoMemoryEngine {
     this.effectivenessTracker = effectivenessTracker
   }
 
+  /**
+   * Wire the SIS (Self-Immune System) error signature database.
+   * Enables persistent error memory — known failure patterns are
+   * saved and can be intercepted before execution by PreFlightChecker.
+   */
+  setErrorSignatureDB(db: ErrorSignatureDB): void {
+    this.errorSignatureDB = db
+  }
+
   // ── Core API ──
 
   /**
@@ -345,6 +356,24 @@ export class AutoMemoryEngine {
       if (this.effectivenessTracker) {
         this.effectivenessTracker.recordApplication(toolRule.id, true)
       }
+
+      // ── SIS: persist error signature for cross-session immunity ──
+      if (this.errorSignatureDB) {
+        const examples = pattern.examples || []
+        const errorText = examples[0] || ''
+        this.errorSignatureDB.insert({
+          pattern: errorText.slice(0, 200), // first 200 chars as match pattern
+          category,
+          toolName: toolRule.toolName,
+          fixStrategy: 'replace',
+          fixAction: String(
+            toolRule.fix({ command: errorText }).modified?.command ||
+              toolRule.fix({}).modified?.command ||
+              '',
+          ),
+          explanation: `CRSI 自动生成: ${toolRule.id} — ${pattern.category} 类错误 (${count} 次发生)`,
+        })
+      }
     }
   }
 

package/src/core/engine.ts

@@ -22,6 +22,10 @@ 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 { ErrorSignatureDB } from './error-signature-db.js'
+import { PreFlightChecker } from './preflight-checker.js'
+import { AutoCorrector } from './auto-corrector.js'
+import { MetaRuleEngine } from './meta-rule-engine.js'
 import { UsageTracker } from './usage-tracker'
 import { buildRequest, sendInferenceCheck, isInferenceHookEnabled } from './inference-hook'
 import { getFileInboxTransport } from '../agent/cross-session/file-inbox'
@@ -47,6 +51,10 @@ export class QueryEngine {
   private _patternAnalyzer?: PatternAnalyzer
   private _effectivenessTracker?: EffectivenessTracker
   private _autoMemory?: AutoMemoryEngine
+  private _errorSignatureDB?: ErrorSignatureDB
+  private _preflightChecker?: PreFlightChecker
+  private _autoCorrector?: AutoCorrector
+  private _metaRuleEngine?: MetaRuleEngine
   private goal?: string
   private maxGoalLoops = 20
   private lastAssistantContent?: string
@@ -902,6 +910,25 @@ export class QueryEngine {
       }
     }
 
+    // ── SIS PreFlightChecker — known error pattern interception ──
+    const preflight = this.getPreFlightChecker().check(name, effectiveParams)
+    if (preflight.action === 'block') {
+      return {
+        success: false,
+        content: preflight.warning || 'SIS 免疫系统拦截了此操作',
+        error: preflight.warning,
+      }
+    }
+    if (preflight.action === 'fix' && preflight.modifiedParams) {
+      effectiveParams = preflight.modifiedParams
+      if (preflight.warning) {
+        hookWarnings = [...hookWarnings, preflight.warning]
+      }
+    }
+    if (preflight.action === 'warn' && preflight.warning) {
+      hookWarnings = [...hookWarnings, preflight.warning]
+    }
+
     try {
       const result = await tool.execute(effectiveParams, {
         cwd: process.cwd(),
@@ -973,7 +1000,19 @@ export class QueryEngine {
       // information disclosure to the LLM conversation context.
       const message =
         err instanceof Error ? err.message : String(err).split('\n')[0] || 'Unknown error'
-      return { success: false, content: '', error: `Tool execution failed: ${message}` }
+
+      // ── SIS AutoCorrector — post-error self-healing ──
+      const correction = this.getAutoCorrector().analyze(name, effectiveParams, message)
+
+      let errorContent = `Tool execution failed: ${message}`
+      if (correction.suggestion) {
+        errorContent += '\n\n' + correction.suggestion
+      }
+      if (correction.action === 'retry' && correction.correctedParams) {
+        errorContent += '\n💡 SIS 已自动修正参数，下次执行时将使用修正后的命令。'
+      }
+
+      return { success: false, content: '', error: errorContent }
     }
   }
 
@@ -1033,10 +1072,67 @@ export class QueryEngine {
         this.getRuleEngine() || new ExperienceRuleEngine(),
         this.getEffectivenessTracker(),
       )
+      // Wire SIS error signature DB for cross-session immunity
+      this._autoMemory.setErrorSignatureDB(this.getErrorSignatureDB())
     }
     return this._autoMemory
   }
 
+  /**
+   * SIS Phase 0: Lazily-initialized ErrorSignatureDB singleton.
+   * Provides persistent storage of known error patterns across sessions.
+   * Public accessor for CLI commands (/sis errors, /sis stats, /sis clear).
+   */
+  getErrorSignatureDB(): ErrorSignatureDB {
+    if (!this._errorSignatureDB) {
+      this._errorSignatureDB = new ErrorSignatureDB()
+    }
+    return this._errorSignatureDB
+  }
+
+  /**
+   * SIS Phase 0: Lazily-initialized PreFlightChecker singleton.
+   * Checks tool calls against ErrorSignatureDB + ExperienceRuleEngine
+   * before execution, enabling preventive error interception.
+   */
+  private getPreFlightChecker(): PreFlightChecker {
+    if (!this._preflightChecker) {
+      this._preflightChecker = new PreFlightChecker(
+        this.getErrorSignatureDB(),
+        this.getRuleEngine(),
+      )
+    }
+    return this._preflightChecker
+  }
+
+  /**
+   * SIS Phase 2: Lazily-initialized AutoCorrector singleton.
+   * Analyzes failed tool calls and suggests corrections based on
+   * the error signature database.
+   */
+  private getAutoCorrector(): AutoCorrector {
+    if (!this._autoCorrector) {
+      this._autoCorrector = new AutoCorrector(this.getErrorSignatureDB())
+    }
+    return this._autoCorrector
+  }
+
+  /**
+   * SIS Phase 3 (RSI Level 3): Lazily-initialized MetaRuleEngine singleton.
+   * Analyzes accumulated SIS data (ErrorSignatureDB + EffectivenessTracker)
+   * to discover meta-rules — rules about rules. This is the recursive
+   * self-improvement core: the system improving its own ability to improve.
+   */
+  getMetaRuleEngine(): MetaRuleEngine {
+    if (!this._metaRuleEngine) {
+      this._metaRuleEngine = new MetaRuleEngine(
+        this.getErrorSignatureDB(),
+        this.getEffectivenessTracker(),
+      )
+    }
+    return this._metaRuleEngine
+  }
+
   /** Register a tool dynamically (used by MCP auto-registration). */
   registerTool(tool: ToolDefinition): void {
     if (this.tools.has(tool.name)) {