@yun520-1/heartflow 0.15.2

package/src/core/self-healing/self-healing-rl.js

@@ -0,0 +1,208 @@
+/**
+ * HeartFlow Self-Healing RL Module v11.5.9
+ * 基于 Reflexion/CRITIC 架构的修复策略学习
+ *
+ * 核心：Q-learning + ε-greedy 探索 + 持久化
+ * 数据来源：self-healing.js 的每次修复记录
+ * 学习信号：repair outcome (success=1, failure=-0.5)
+ *
+ * Paper: Reflexion (2023), CRITIC (2024)
+ * Persistence: data/healing-rl-state.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// 持久化路径
+const STATE_DIR = path.join(__dirname, '..', '..', 'data');
+const STATE_FILE = path.join(STATE_DIR, 'healing-rl-state.json');
+
+class HealingMemoryRL {
+  constructor(maxMemory = 100) {
+    this.maxMemory = maxMemory;
+    this.memory = [];
+    this.Q = {};       // Q-table: context-action → value
+    this.lr = 0.1;      // learning rate
+    this.gamma = 0.9;   // discount factor
+    this.epsilon = 0.15; // exploration rate
+    this.statsVersion = 0; // 用于检测版本变化
+
+    // 启动时从磁盘恢复
+    this._load();
+  }
+
+  /**
+   * 从磁盘加载 Q-table 和 memory
+   */
+  _load() {
+    try {
+      if (fs.existsSync(STATE_FILE)) {
+        const raw = fs.readFileSync(STATE_FILE, 'utf-8');
+        const state = JSON.parse(raw);
+        this.Q = state.Q || {};
+        this.memory = state.memory || [];
+        this.statsVersion = state.version || 0;
+        console.log(`[HealingMemoryRL] 从磁盘恢复: ${this.memory.length}条记忆, ${Object.keys(this.Q).length}个Q值`);
+      } else {
+        console.log('[HealingMemoryRL] 无历史记录，从空白开始');
+      }
+    } catch (e) {
+      console.warn('[HealingMemoryRL] 加载失败:', e.message);
+    }
+  }
+
+  /**
+   * 保存 Q-table 和 memory 到磁盘
+   */
+  _save() {
+    try {
+      if (!fs.existsSync(STATE_DIR)) {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+      }
+      const state = {
+        Q: this.Q,
+        memory: this.memory.slice(-this.maxMemory),
+        version: Date.now()
+      };
+      fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+    } catch (e) {
+      console.warn('[HealingMemoryRL] 保存失败:', e.message);
+    }
+  }
+
+  /**
+   * 记录修复结果
+   */
+  record(pattern, patch, success) {
+    this.memory.push({
+      pattern,
+      patch,
+      success: !!success,
+      timestamp: Date.now()
+    });
+    if (this.memory.length > this.maxMemory) {
+      this.memory = this.memory.slice(-this.maxMemory);
+    }
+    this._save(); // 每次记录后持久化
+  }
+
+  /**
+   * Q-learning 更新
+   */
+  learn(context, action, reward) {
+    const key = this._key(context, action);
+    const prev = this.Q[key] || 0;
+    // Cap Q-values to prevent divergence (max 100)
+    const maxFutureQ = Object.keys(this.Q).length > 0
+      ? Math.min(100, Math.max(...Object.values(this.Q), 0))
+      : 0;
+    this.Q[key] = Math.max(-10, Math.min(100, prev + this.lr * (reward + this.gamma * maxFutureQ - prev)));
+    this._save(); // 每次学习后持久化
+  }
+
+  /**
+   * ε-greedy 策略选择
+   */
+  selectAction(context, availableActions) {
+    if (!availableActions || availableActions.length === 0) return null;
+    if (Math.random() < this.epsilon) {
+      return availableActions[Math.floor(Math.random() * availableActions.length)];
+    }
+    let best = null, bestQ = -Infinity;
+    for (const action of availableActions) {
+      const q = this.Q[this._key(context, action)] || 0;
+      if (q > bestQ) { bestQ = q; best = action; }
+    }
+    return best || availableActions[0];
+  }
+
+  /**
+   * 从修复结果学习
+   */
+  updateFromRepair(context, action, success) {
+    const reward = success ? 1.0 : -0.5;
+    this.learn(context, action, reward);
+  }
+
+  /**
+   * 策略质量评估
+   */
+  getStrategyQuality(action) {
+    let total = 0, count = 0;
+    for (const [key, val] of Object.entries(this.Q)) {
+      if (key.endsWith(`"${action}"]`)) { total += val; count++; }
+    }
+    return count > 0 ? total / count : 0;
+  }
+
+  /**
+   * 历史最佳补丁（基于成功率）
+   */
+  bestPatch(pattern) {
+    const candidates = this.memory.filter(x => x.pattern === pattern);
+    if (!candidates.length) return null;
+    const scored = candidates.map(x => ({
+      ...x,
+      score: this.Q[this._key(x.pattern, x.patch)] || (x.success ? 1 : -0.5)
+    }));
+    scored.sort((a, b) => b.score - a.score);
+    return scored[0];
+  }
+
+  /**
+   * 按 Q 值排序所有补丁
+   */
+  rankedPatches(failureCtx) {
+    const ctx = String(failureCtx);
+    // Use exact match to avoid overly permissive substring matching
+    const candidates = this.memory.filter(x => {
+      const xCtx = String(x.pattern);
+      return xCtx === ctx;
+    });
+    if (!candidates.length) return this.memory.slice(-8).reverse().map(x => x.patch);
+    return candidates
+      .map(x => ({
+        ...x,
+        qVal: this.Q[this._key(x.pattern, x.patch)] || 0
+      }))
+      .sort((a, b) => b.qVal - a.qVal)
+      .map(x => x.patch);
+  }
+
+  /**
+   * 学习统计
+   */
+  stats() {
+    const successes = this.memory.filter(x => x.success).length;
+    const total = this.memory.length;
+    return {
+      total,
+      successes,
+      failRate: total > 0 ? (1 - successes / total).toFixed(3) : 'N/A',
+      qEntries: Object.keys(this.Q).length,
+      persisted: fs.existsSync(STATE_FILE),
+      topStrategies: Object.entries(this.Q)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 3)
+        .map(([k, v]) => ({ strategy: JSON.parse(k).action, q: v.toFixed(3) }))
+    };
+  }
+
+  _key(context, action) {
+    // 用完整内容哈希而非截断，避免不同输入产生相同 key（hash 冲突）
+    const ctx = String(context);
+    const act = String(action);
+    // FNV-1a 哈希（比 JSON.stringify 更稳定，避免字符编码问题）
+    const hashStr = (str) => {
+      let hash = 2166136261;
+      for (let i = 0; i < str.length; i++) {
+        hash ^= str.charCodeAt(i);
+        hash = (hash * 16777619) >>> 0;
+      }
+      return hash.toString(36);
+    };
+    return JSON.stringify({ ctx: hashStr(ctx), action: hashStr(act) });
+  }
+}
+
+module.exports = { HealingMemoryRL };

package/src/core/self-healing/self-healing.js

@@ -0,0 +1,142 @@
+/**
+ * HeartFlow Self-Healing v11.5.6
+ * 
+ * Recovery loop with RL-based repair strategy learning.
+ * - detect repeated failures
+ * - classify recovery path
+ * - emit concrete repair hints
+ * - learn from repair outcomes (Q-learning)
+ * 
+ * Paper: Reflexion (2023), CRITIC (2024)
+ */
+
+const { HealingMemoryRL } = require('./self-healing-rl.js');
+
+class SelfHealing {
+  constructor(options = {}) {
+    this.maxRetries = options.maxRetries ?? 2;
+    this.backoffMs = options.backoffMs ?? 150;
+    this.failureWindow = [];
+    this.rl = new HealingMemoryRL(options.maxMemory ?? 100);
+    this._pendingCtx = new Map(); // pending repair attempts for RL update
+  }
+
+  normalizeError(errorLike = {}) {
+    if (!errorLike) return { message: '', code: null, transient: false };
+    if (typeof errorLike === 'string') {
+      return this.normalizeError({ message: errorLike });
+    }
+
+    const message = String(
+      errorLike.message || errorLike.error || errorLike.summary || ''
+    );
+    const code = errorLike.code || errorLike.statusCode || errorLike.status || null;
+    const transient = /timeout|econnreset|eagain|temporar|busy|rate limit|429|throttle/i.test(message)
+      || [408, 423, 425, 429, 500, 502, 503, 504].includes(Number(code));
+
+    return { message, code, transient };
+  }
+
+  record(event = {}, repairOutcome = null) {
+    const normalized = this.normalizeError(event);
+    const item = {
+      type: String(event.type || 'unknown'),
+      message: normalized.message,
+      code: normalized.code,
+      transient: normalized.transient,
+      ts: Date.now(),
+    };
+    this.failureWindow.push(item);
+    if (this.failureWindow.length > 20) this.failureWindow.shift();
+
+    // RL: 关闭修复闭环
+    if (repairOutcome !== null) {
+      // 用 normalized.message 精确匹配 _pendingCtx 的 key
+      const pending = this._pendingCtx.get(normalized.message);
+      if (pending) {
+        // Q-key 用 record() 时传入的同一个 pattern
+        this.rl.updateFromRepair(normalized.message, pending.strategy, repairOutcome);
+        this.rl.record(normalized.message, pending.strategy, repairOutcome);
+        this._pendingCtx.delete(normalized.message);
+      }
+    }
+    return item;
+  }
+
+  summarize() {
+    const counts = this.failureWindow.reduce((acc, x) => {
+      acc[x.type] = (acc[x.type] || 0) + 1;
+      return acc;
+    }, {});
+    const top = Object.entries(counts).sort((a, b) => b[1] - a[1])[0];
+    return {
+      total: this.failureWindow.length,
+      counts,
+      summary: top ? `${top[0]} x${top[1]}` : 'no failures',
+    };
+  }
+
+  shouldRetry(result = {}) {
+    const normalized = this.normalizeError(result);
+    return normalized.transient && (result.attempt || 0) < this.maxRetries;
+  }
+
+  repairHints(result = {}) {
+    const message = this.normalizeError(result).message;
+    const hints = [];
+    if (/timeout/i.test(message)) hints.push('use smaller scope or longer timeout');
+    if (/rate limit|429|throttle/i.test(message)) hints.push('pause and retry with exponential backoff');
+    if (/syntax|parse|unexpected token/i.test(message)) hints.push('re-read the target file and patch smaller');
+    if (/module not found|cannot find/i.test(message)) hints.push('verify imports and relative paths');
+    if (/unknown option|invalid option/i.test(message)) hints.push('remove unsupported CLI flags');
+    if (/execution_failed|invalid_structure/i.test(message)) hints.push('force structured result output before retrying');
+    if (hints.length === 0) hints.push('reduce the failure surface and retry once');
+    return [...new Set(hints)];
+  }
+
+  createRetryPlan(result = {}) {
+    const attempt = Number(result.attempt || 0) + 1;
+    const canRetry = this.shouldRetry({ ...result, attempt });
+    const delay = this.backoffMs * Math.max(1, 2 ** (attempt - 1));
+    return {
+      attempt,
+      canRetry,
+      delay,
+      strategy: canRetry ? 'exponential_backoff' : 'manual_repair',
+    };
+  }
+
+  recover(result = {}) {
+    const retry = this.createRetryPlan(result);
+    const snapshot = this.summarize();
+    const message = this.normalizeError(result).message;
+    const hints = this.repairHints(result);
+    // pattern = normalized.message，贯穿 record/learn/selectAction
+    const pattern = message;
+
+    // RL: 用 Q-learning 排序策略
+    const ranked = this.rl.rankedPatches(pattern);
+    const available = [...new Set([...ranked, ...hints])];
+
+    // RL: 记录待验证的修复策略（key = message，精确匹配）
+    if (hints.length > 0) {
+      const chosen = this.rl.selectAction(pattern, available) || hints[0];
+      this._pendingCtx.set(message, { context: pattern, strategy: chosen, ts: Date.now() });
+    }
+
+    return {
+      ok: !!result.ok,
+      attempt: retry.attempt,
+      canRetry: retry.canRetry,
+      backoffMs: retry.delay,
+      strategy: retry.strategy,
+      hints: available.slice(0, 5),
+      summary: snapshot.summary,
+      details: snapshot,
+      next_step: retry.canRetry ? 'retry' : 'repair',
+      rlStats: this.rl.stats(),
+    };
+  }
+}
+
+module.exports = { SelfHealing };