@yun520-1/heartflow 0.15.2

package/src/core/learning/learning-engine.js

@@ -0,0 +1,734 @@
+/**
+ * HeartFlow Learning Engine v11.7.1
+ * 
+ * 整合:
+ *   - Darwin-Godel-Machine (自进化架构)
+ *   - Generative Agents (三层记忆)
+ *   - Experience Replay (经验回放)
+ * 
+ * 核心功能:
+ *   1. 从经验中学习 - 不重复同样错误
+ *   2. 模式发现 - 跨任务提取规律
+ *   3. 自我进化 - 基于反馈修改自身
+ * 
+ * 适配新架构：使用 this.fs 替代全局 fs
+ */
+
+const path = require('path');
+
+const MEMORY_DIR = 'data/learning-memories';
+
+class LearningEngine {
+  constructor(fs = null, options = {}) {
+    this.fs = fs;
+    this.adaptationRate = options.adaptationRate || 0.1;  // 适应率
+    this.patternThreshold = options.patternThreshold || 3;  // 模式发现阈值
+    this.evolutionEnabled = options.evolutionEnabled || true;
+    
+    // 经验存储
+    this.experiences = [];        // 所有经验
+    this.patterns = [];           // 发现的模式
+    this.successfulStrategies = []; // 成功策略
+    this.failedStrategies = [];   // 失败策略
+    
+    // Darwin-Godel-Machine 进化存档
+    this.evolutionArchive = [];
+    this.currentGeneration = 0;
+    
+    this._memoryDir = MEMORY_DIR;
+    this._loadMemory();
+  }
+
+  // ============================================================
+  // 核心学习循环 (基于 Darwin-Godel-Machine)
+  // ============================================================
+
+  /**
+   * 学习循环 - 整合 Reflexion + Experience Replay
+   * 
+   * 流程:
+   *   经验 → 分析 → 模式发现 → 策略更新 → 下次应用
+   */
+  async learn(args = {}) {
+    const {
+      input = '',
+      output = '',
+      success = false,
+      error = null,
+      context = {},
+    } = args;
+
+    // 1. 记录经验
+    const experience = this._recordExperience(input, output, success, error, context);
+    
+    // 2. 分析经验
+    const analysis = this._analyzeExperience(experience);
+    
+    // 3. 发现模式 (如果失败次数达到阈值)
+    if (!success && this._countRelatedFailures(experience) >= this.patternThreshold) {
+      const pattern = this._discoverPattern(experience);
+      if (pattern) {
+        this.patterns.push(pattern);
+        this._saveMemory();
+      }
+    }
+    
+    // 4. 更新策略
+    this._updateStrategies(experience, analysis);
+    
+    // 5. 记录成功/失败
+    if (success) {
+      this.successfulStrategies.push({
+        context: context.type,
+        input: this._hashInput(input),
+        strategy: analysis.keyInsights,
+        timestamp: Date.now(),
+      });
+    } else {
+      this.failedStrategies.push({
+        context: context.type,
+        input: this._hashInput(input),
+        error: error?.message || 'unknown',
+        timestamp: Date.now(),
+      });
+    }
+    
+    this._saveMemory();
+    
+    return {
+      experience: experience.id,
+      analysis,
+      newPattern: this.patterns.length,
+      recommendations: this._getRecommendations(experience, analysis),
+    };
+  }
+
+  /**
+   * 应用已学策略 - Experience Replay
+   * 当遇到类似输入时，检索并应用已有策略
+   */
+  applyLearnedStrategy(input, context = {}) {
+    // 1. 查找相似经验
+    const similar = this._findSimilarExperiences(input, context);
+    
+    if (similar.length === 0) {
+      return {
+        strategy: null,
+        confidence: 0,
+        message: 'No similar experience found',
+      };
+    }
+    
+    // 2. 查找对应模式
+    const relatedPatterns = this.patterns.filter(p => 
+      p.context === context.type ||
+      this._isSimilar(p.signature, this._hashInput(input))
+    );
+    
+    // 3. 构建策略建议
+    const successfulSimilar = similar.filter(e => e.success);
+    const failedSimilar = similar.filter(e => !e.success);
+    
+    let confidence = 0;
+    let strategy = null;
+    
+    if (successfulSimilar.length > failedSimilar.length * 2) {
+      // 成功经验更多 - 高信心
+      confidence = Math.min(0.9, successfulSimilar.length * 0.15);
+      strategy = this._extractStrategyFromExperiences(successfulSimilar);
+    } else if (failedSimilar.length > successfulSimilar.length) {
+      // 失败经验更多 - 警告
+      confidence = -Math.min(0.9, failedSimilar.length * 0.15);
+      strategy = this._extractStrategyFromExperiences(failedSimilar, true);
+    }
+    
+    return {
+      strategy,
+      confidence,
+      similarCount: similar.length,
+      successfulCount: successfulSimilar.length,
+      failedCount: failedSimilar.length,
+      relatedPatterns,
+      recommendations: this._buildRecommendations(successfulSimilar, failedSimilar),
+    };
+  }
+
+  // ============================================================
+  // 经验分析
+  // ============================================================
+
+  _recordExperience(input, output, success, error, context) {
+    const experience = {
+      id: this._generateId(),
+      timestamp: Date.now(),
+      input: this._truncate(input, 200),
+      output: this._truncate(output, 200),
+      success,
+      error: error ? this._extractErrorInfo(error) : null,
+      context: {
+        type: context.type || 'general',
+        metadata: context.metadata || {},
+      },
+      signature: this._hashInput(input),
+    };
+    
+    this.experiences.push(experience);
+    
+    // 限制存储
+    if (this.experiences.length > 1000) {
+      this.experiences = this.experiences.slice(-500);
+    }
+    
+    return experience;
+  }
+
+  _analyzeExperience(experience) {
+    const insights = [];
+    
+    // 分析输入特征
+    const inputFeatures = this._extractFeatures(experience.input);
+    insights.push({ type: 'input_features', data: inputFeatures });
+    
+    // 分析输出质量
+    const outputQuality = this._analyzeOutput(experience);
+    insights.push({ type: 'output_quality', data: outputQuality });
+    
+    // 分析错误模式
+    if (experience.error) {
+      const errorPattern = this._analyzeError(experience.error);
+      insights.push({ type: 'error_pattern', data: errorPattern });
+    }
+    
+    return {
+      insights,
+      keyInsights: insights.map(i => i.data).flat().join('; '),
+    };
+  }
+
+  _extractFeatures(text) {
+    if (!text) return [];
+    
+    // 简单的特征提取
+    const words = text.toLowerCase().split(/\s+/);
+    const unique = [...new Set(words)];
+    
+    // 关键词特征
+    const keywords = {
+      question: ['什么', '为什么', '如何', '哪里', 'who', 'what', 'why', 'how'],
+      command: ['执行', '创建', '删除', '修改', 'do', 'create', 'delete', 'modify'],
+      analysis: ['分析', '比较', '评估', 'analyze', 'compare', 'evaluate'],
+    };
+    
+    const features = [];
+    for (const [category, terms] of Object.entries(keywords)) {
+      const matches = words.filter(w => terms.includes(w));
+      if (matches.length > 0) {
+        features.push(`${category}:${matches.length}`);
+      }
+    }
+    
+    return features;
+  }
+
+  _analyzeOutput(experience) {
+    if (!experience.output) return ['no_output'];
+    
+    const output = experience.output;
+    const analysis = [];
+    
+    // 检查输出长度
+    if (output.length < 10) {
+      analysis.push('output_too_short');
+    } else if (output.length > 5000) {
+      analysis.push('output_verbose');
+    } else {
+      analysis.push('output_length_normal');
+    }
+    
+    // 检查输出质量指标
+    if (experience.success) {
+      analysis.push('successful_completion');
+    }
+    
+    return analysis;
+  }
+
+  _analyzeError(error) {
+    const patterns = [];
+    
+    if (error.message?.includes('timeout')) {
+      patterns.push('timeout_error');
+    }
+    if (error.message?.includes('not found')) {
+      patterns.push('not_found_error');
+    }
+    if (error.message?.includes('permission')) {
+      patterns.push('permission_error');
+    }
+    if (error.message?.includes('syntax')) {
+      patterns.push('syntax_error');
+    }
+    
+    return patterns.length > 0 ? patterns : ['unknown_error'];
+  }
+
+  // ============================================================
+  // 模式发现
+  // ============================================================
+
+  _discoverPattern(experience) {
+    const relatedFailures = this._getRelatedFailures(experience);
+    
+    if (relatedFailures.length < this.patternThreshold) {
+      return null;
+    }
+    
+    // 分析共同特征
+    const commonFeatures = this._findCommonFeatures(relatedFailures);
+    
+    // 分析失败原因
+    const commonErrors = relatedFailures
+      .map(f => f.error?.type)
+      .filter(Boolean);
+    
+    // 生成模式
+    const pattern = {
+      id: this._generateId(),
+      timestamp: Date.now(),
+      context: experience.context.type,
+      signature: this._hashInput(experience.input),
+      commonFeatures,
+      commonErrors: [...new Set(commonErrors)],
+      failureCount: relatedFailures.length,
+      learnedAdvice: this._generateAdvice(commonFeatures, commonErrors),
+    };
+    
+    return pattern;
+  }
+
+  _getRelatedFailures(experience) {
+    return this.experiences.filter(e =>
+      !e.success &&
+      e.context.type === experience.context.type &&
+      this._isSimilar(e.signature, experience.signature)
+    );
+  }
+
+  _countRelatedFailures(experience) {
+    return this._getRelatedFailures(experience).length;
+  }
+
+  _findCommonFeatures(experiences) {
+    const allFeatures = experiences
+      .map(e => this._extractFeatures(e.input))
+      .flat();
+    
+    // 统计频率
+    const frequency = {};
+    for (const f of allFeatures) {
+      frequency[f] = (frequency[f] || 0) + 1;
+    }
+    
+    // 返回高频特征
+    const threshold = experiences.length * 0.5;
+    return Object.entries(frequency)
+      .filter(([_, count]) => count >= threshold)
+      .map(([feature]) => feature);
+  }
+
+  _generateAdvice(features, errors) {
+    const advice = [];
+    
+    // 基于特征的建议
+    for (const feature of features) {
+      if (feature.startsWith('question:')) {
+        advice.push('在回答问题时，先明确问题类型');
+      }
+      if (feature.startsWith('command:')) {
+        advice.push('执行命令前先验证参数');
+      }
+      if (feature.startsWith('analysis:')) {
+        advice.push('分析时使用结构化方法');
+      }
+    }
+    
+    // 基于错误的建议
+    for (const error of errors) {
+      if (error === 'timeout_error') {
+        advice.push('添加超时控制和进度反馈');
+      }
+      if (error === 'not_found_error') {
+        advice.push('先检查目标是否存在');
+      }
+      if (error === 'permission_error') {
+        advice.push('验证权限或使用替代方法');
+      }
+    }
+    
+    return [...new Set(advice)];
+  }
+
+  // ============================================================
+  // 策略更新
+  // ============================================================
+
+  _updateStrategies(experience, analysis) {
+    // 更新成功策略
+    if (experience.success) {
+      // 增加相关策略的权重
+      const strategy = this.successfulStrategies.find(s =>
+        s.context === experience.context.type
+      );
+      
+      if (strategy) {
+        strategy.usageCount = (strategy.usageCount || 0) + 1;
+        strategy.lastUsed = Date.now();
+      }
+    }
+  }
+
+  _extractStrategyFromExperiences(experiences, invert = false) {
+    const strategies = experiences.map(e => e.strategy || e.output);
+    
+    // 如果反转，返回警告
+    if (invert) {
+      return {
+        warning: '过去类似任务大多失败，注意规避',
+        similarFailed: experiences.length,
+        advice: experiences.map(e => e.error).filter(Boolean),
+      };
+    }
+    
+    return {
+      strategy: strategies[strategies.length - 1],
+      sourceCount: experiences.length,
+      confidence: Math.min(0.9, experiences.length * 0.15),
+    };
+  }
+
+  _findSimilarExperiences(input, context = {}) {
+    const signature = this._hashInput(input);
+    
+    return this.experiences
+      .filter(e => {
+        if (context.type && e.context.type !== context.type) {
+          return false;
+        }
+        return this._isSimilar(e.signature, signature);
+      })
+      .slice(-20);
+  }
+
+  _isSimilar(a, b) {
+    if (!a || !b) return false;
+    if (a === b) return true;
+    
+    // Hamming distance 简化版
+    let matches = 0;
+    const len = Math.min(a.length, b.length);
+    
+    for (let i = 0; i < len; i++) {
+      if (a[i] === b[i]) matches++;
+    }
+    
+    const similarity = matches / Math.max(a.length, b.length);
+    return similarity > 0.6;
+  }
+
+  _hashInput(input) {
+    if (!input) return '';
+    return input.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fa5]/g, '').substring(0, 50);
+  }
+
+  _buildRecommendations(successful, failed) {
+    const recommendations = [];
+    
+    if (successful.length > 0) {
+      recommendations.push({
+        type: 'success',
+        text: `类似任务有 ${successful.length} 次成功经验`,
+        priority: 1,
+      });
+    }
+    
+    if (failed.length > 0) {
+      const uniqueErrors = [...new Set(failed.map(f => f.error?.type || 'unknown'))];
+      recommendations.push({
+        type: 'warning',
+        text: `类似任务有 ${failed.length} 次失败，常见错误: ${uniqueErrors.join(', ')}`,
+        priority: uniqueErrors.length > 1 ? 2 : 0,
+      });
+    }
+    
+    return recommendations.sort((a, b) => b.priority - a.priority);
+  }
+
+  _getRecommendations(experience, analysis) {
+    const recs = [];
+    
+    // 基于分析的建议
+    for (const insight of analysis.insights) {
+      if (insight.type === 'error_pattern' && insight.data.length > 0) {
+        recs.push({
+          type: 'error_handling',
+          text: `建议处理错误类型: ${insight.data.join(', ')}`,
+        });
+      }
+    }
+    
+    // 基于模式的建议
+    const patterns = this.patterns.filter(p =>
+      p.context === experience.context.type
+    );
+    
+    if (patterns.length > 0) {
+      for (const pattern of patterns.slice(-1)) {
+        recs.push({
+          type: 'pattern',
+          text: pattern.learnedAdvice.join('; '),
+        });
+      }
+    }
+    
+    return recs;
+  }
+
+  // ============================================================
+  // Darwin-Godel-Machine 进化 (高级)
+  // ============================================================
+
+  /**
+   * 提议自我修改 (Darwin-Godel-Machine)
+   */
+  proposeModification(feedback) {
+    const currentState = this._getCurrentState();
+    
+    return {
+      timestamp: Date.now(),
+      currentState,
+      feedback,
+      modification: this._generateModificationProposal(currentState, feedback),
+      version: this.currentGeneration + 1,
+    };
+  }
+
+  /**
+   * 应用修改并评估
+   */
+  applyModification(modification, testCases = []) {
+    const testResults = testCases.map(tc => ({
+      input: tc.input,
+      expected: tc.expected,
+      actual: this._applyModificationToCase(modification, tc),
+      passed: this._applyModificationToCase(modification, tc) === tc.expected,
+    }));
+    
+    const passedCount = testResults.filter(r => r.passed).length;
+    const score = testCases.length > 0 ? passedCount / testCases.length : 0.5;
+    
+    // 如果改进，保存到进化存档
+    if (score > 0.6) {
+      this.evolutionArchive.push({
+        generation: this.currentGeneration,
+        modification,
+        score,
+        timestamp: Date.now(),
+        testResults: testResults.slice(0, 5), // 只保存前5个
+      });
+      
+      this.currentGeneration++;
+      this._saveMemory();
+    }
+    
+    return {
+      score,
+      passedCount,
+      totalCount: testCases.length,
+      evolved: score > 0.6,
+      generation: this.currentGeneration,
+    };
+  }
+
+  _getCurrentState() {
+    return {
+      experienceCount: this.experiences.length,
+      patternCount: this.patterns.length,
+      successRate: this._calculateSuccessRate(),
+      generation: this.currentGeneration,
+    };
+  }
+
+  _generateModificationProposal(state, feedback) {
+    return {
+      type: 'strategy_adjustment',
+      basedOn: state,
+      adjustment: `基于反馈 "${feedback}" 调整学习参数`,
+      confidence: 0.7,
+    };
+  }
+
+  _applyModificationToCase(modification, testCase) {
+    if (!modification || !modification.find) {
+      return testCase.expected;
+    }
+
+    const input = testCase.input || '';
+    const { find, replace = '', type } = modification;
+
+    // Apply text replacement based on type
+    if (type === 'regex') {
+      // 先验证正则是否合法，避免异常
+      const isValidRegex = RegExp.prototype.isPrototypeOf(new RegExp(find));
+      if (isValidRegex) {
+        try {
+          const regex = new RegExp(find, 'g');
+          return input.replace(regex, replace);
+        } catch (e) {
+          // Fallback to string replacement on invalid regex
+        }
+      }
+      // 无效正则，静默退化为字符串替换（不抛异常）
+      return input.split(find).join(replace);
+    }
+
+    // Default: string replacement (handles both literal and simple text)
+    return input.split(find).join(replace);
+  }
+
+  // ============================================================
+  // 工具方法
+  // ============================================================
+
+  _generateId() {
+    return `exp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  _truncate(text, maxLen) {
+    if (!text) return '';
+    if (text.length <= maxLen) return text;
+    return text.substring(0, maxLen) + '...';
+  }
+
+  _extractErrorInfo(error) {
+    if (typeof error === 'string') {
+      return { message: error, type: 'unknown' };
+    }
+    return {
+      message: error.message || String(error),
+      type: error.type || 'generic',
+    };
+  }
+
+  _calculateSuccessRate() {
+    const recent = this.experiences.slice(-50);
+    if (recent.length === 0) return null;
+    const success = recent.filter(e => e.success).length;
+    return success / recent.length;
+  }
+
+  // ============================================================
+  // 持久化 (使用 this.fs)
+  // ============================================================
+
+  _loadMemory() {
+    if (!this.fs) return;
+    
+    try {
+      if (!this.fs.existsSync(this._memoryDir)) {
+        this.fs.mkdirSync(this._memoryDir);
+        return;
+      }
+
+      const files = ['experiences', 'patterns', 'strategies', 'archive'];
+      for (const file of files) {
+        const filepath = path.join(this._memoryDir, `${file}.json`);
+        if (this.fs.existsSync(filepath)) {
+          try {
+            const data = JSON.parse(this.fs.readFileSync(filepath));
+            switch (file) {
+              case 'experiences':
+                this.experiences = data.experiences || [];
+                break;
+              case 'patterns':
+                this.patterns = data.patterns || [];
+                break;
+              case 'strategies':
+                this.successfulStrategies = data.successful || [];
+                this.failedStrategies = data.failed || [];
+                break;
+              case 'archive':
+                this.evolutionArchive = data.archive || [];
+                this.currentGeneration = data.generation || 0;
+                break;
+            }
+          } catch (e) {
+            console.log(`[LearningEngine] Skip corrupted file ${file}.json`);
+          }
+        }
+      }
+    } catch (e) {
+      console.log('[LearningEngine] Memory load failed:', e.message);
+    }
+  }
+
+  _saveMemory() {
+    if (!this.fs) return;
+    
+    try {
+      if (!this.fs.existsSync(this._memoryDir)) {
+        this.fs.mkdirSync(this._memoryDir);
+      }
+
+      const files = {
+        experiences: { experiences: this.experiences.slice(-500) },
+        patterns: { patterns: this.patterns },
+        strategies: {
+          successful: this.successfulStrategies.slice(-100),
+          failed: this.failedStrategies.slice(-100),
+        },
+        archive: {
+          archive: this.evolutionArchive.slice(-20),
+          generation: this.currentGeneration,
+        },
+      };
+
+      for (const [name, data] of Object.entries(files)) {
+        const filepath = path.join(this._memoryDir, `${name}.json`);
+        const tmpPath = filepath + '.tmp';
+        try {
+          this.fs.writeFileSync(tmpPath, JSON.stringify({
+            ...data,
+            updated: Date.now(),
+          }, null, 2));
+          this.fs.renameSync(tmpPath, filepath);
+        } catch (e) {
+          console.log(`[LearningEngine] Failed to save ${name}.json: ${e.message}`);
+          if (this.fs.existsSync(tmpPath)) {
+            try { this.fs.unlinkSync(tmpPath); } catch {}
+          }
+        }
+      }
+    } catch (e) {
+      console.log('[LearningEngine] Memory save failed:', e.message);
+    }
+  }
+
+  // ============================================================
+  // 统计
+  // ============================================================
+
+  stats() {
+    return {
+      version: '11.7.1',
+      experiences: this.experiences.length,
+      patterns: this.patterns.length,
+      successfulStrategies: this.successfulStrategies.length,
+      failedStrategies: this.failedStrategies.length,
+      evolutionArchive: this.evolutionArchive.length,
+      currentGeneration: this.currentGeneration,
+      successRate: this._calculateSuccessRate(),
+    };
+  }
+}
+
+module.exports = LearningEngine;