@yun520-1/heartflow 0.15.2 → 0.16.0

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

@@ -1,208 +0,0 @@
-/**
- * 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

@@ -1,142 +0,0 @@
-/**
- * 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 };