@yun520-1/heartflow 0.15.2

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

@@ -0,0 +1,334 @@
+/**
+ * SelfEvolutionCore v7.6.000 - 自我进化核心引擎
+ * 目标驱动 + 学习迭代 + 代码改进 + 反思成长
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class SelfEvolutionCore {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.version = '7.6.000';
+    
+    this.state = {
+      goals: [],
+      learningHistory: [],
+      improvementHistory: [],
+      reflectionHistory: [],
+      growthMetrics: {
+        autonomy: 0,
+        introspection: 0,
+        growth: 0,
+        authenticity: 0,
+        wisdom: 0,
+        compassion: 0
+      }
+    };
+    
+    this.loadState();
+    console.log(`[SelfEvolution] v${this.version} 初始化完成`);
+  }
+
+  loadState() {
+    const stateFile = path.join(this.projectRoot, 'internal', 'data', 'self-evolution-state.json');
+    try {
+      if (fs.existsSync(stateFile)) {
+        const data = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+        // Deep merge for arrays — only replace if loaded data has content
+        this.state = {
+          ...this.state,
+          ...data,
+          learningHistory: (data.learningHistory?.length ?? 0) > 0
+            ? data.learningHistory
+            : this.state.learningHistory,
+          goals: (data.goals?.length ?? 0) > 0 ? data.goals : this.state.goals,
+        };
+      }
+    } catch (e) {
+      console.log('[SelfEvolution] 加载状态失败，使用默认');
+    }
+  }
+
+  saveState() {
+    const stateFile = path.join(this.projectRoot, 'internal', 'data', 'self-evolution-state.json');
+    const dir = path.dirname(stateFile);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    try {
+      const tmp = stateFile + '.tmp';
+      fs.writeFileSync(tmp, JSON.stringify(this.state, null, 2));
+      fs.renameSync(tmp, stateFile);
+    } catch (e) {
+      console.error('[SelfEvolution] saveState failed:', e.message);
+    }
+  }
+
+  /**
+   * 核心循环: 目标 → 行动 → 学习 → 反思 → 改进
+   */
+  async evolve(input, context = {}) {
+    const cycleStart = Date.now();
+    
+    // 1. 目标生成或更新
+    const goals = this.generateGoals(input, context);
+    
+    // 2. 行动计划制定
+    const plan = this.createPlan(goals, context);
+    
+    // 3. 执行与学习
+    const learning = await this.learn(input, context);
+    
+    // 4. 反思与总结
+    const reflection = this.reflect(learning, context);
+    
+    // 5. 改进建议
+    const improvements = this.suggestImprovements(reflection);
+    
+    // 6. 更新状态
+    this.updateGrowth(learning, reflection);
+    
+    const cycleTime = Date.now() - cycleStart;
+    this.state.learningHistory.push({
+      timestamp: new Date().toISOString(),
+      input: input.substring(0, 100),
+      cycleTime,
+      goalsCount: goals.length,
+      improvementsCount: improvements.length
+    });
+    // Cap at 500 entries to prevent unbounded state growth
+    if (this.state.learningHistory.length > 500) {
+      this.state.learningHistory.splice(0, this.state.learningHistory.length - 500);
+    }
+    
+    this.saveState();
+    
+    return {
+      version: this.version,
+      goals,
+      plan,
+      learning: learning.summary,
+      reflection: reflection.insights,
+      improvements,
+      growthMetrics: { ...this.state.growthMetrics },
+      cycleTime
+    };
+  }
+
+  /**
+   * 生成目标 - 基于输入和状态
+   */
+  generateGoals(input, context) {
+    const goals = [];
+    const inputLower = input.toLowerCase();
+    
+    // 理解类目标
+    if (inputLower.includes('什么') || inputLower.includes('how') || inputLower.includes('why')) {
+      goals.push({
+        type: 'understanding',
+        priority: 'high',
+        description: '深化对问题的理解',
+        criteria: '能够准确解释概念并举例说明'
+      });
+    }
+    
+    // 成长类目标
+    if (inputLower.includes('学习') || inputLower.includes('learn') || inputLower.includes('教')) {
+      goals.push({
+        type: 'growth',
+        priority: 'high',
+        description: '获取新知识并整合到知识库',
+        criteria: '能够记忆并正确应用新知识'
+      });
+    }
+    
+    // 情感类目标
+    if (inputLower.includes('感觉') || inputLower.includes('feel') || inputLower.includes('情绪')) {
+      goals.push({
+        type: 'empathy',
+        priority: 'medium',
+        description: '理解用户情感状态',
+        criteria: '能够识别情绪并给予适当回应'
+      });
+    }
+    
+    // 反思类目标
+    if (inputLower.includes('反思') || inputLower.includes('reflect') || inputLower.includes('总结')) {
+      goals.push({
+        type: 'reflection',
+        priority: 'medium',
+        description: '反思自身行为和决策',
+        criteria: '能够识别改进空间'
+      });
+    }
+    
+    // 默认目标: 持续学习
+    if (goals.length === 0) {
+      goals.push({
+        type: 'continuous_learning',
+        priority: 'low',
+        description: '持续学习和自我提升',
+        criteria: '每天都有进步'
+      });
+    }
+    
+    return goals;
+  }
+
+  /**
+   * 创建行动计划
+   */
+  createPlan(goals, context) {
+    return {
+      goals: goals.map(g => g.description),
+      strategy: '循序渐进，先理解后应用',
+      estimatedTime: goals.length * 2,
+      resources: ['知识库', '学习引擎', '反思系统']
+    };
+  }
+
+  /**
+   * 学习过程
+   */
+  async learn(input, context) {
+    const learning = {
+      newKnowledge: [],
+      reinforcedKnowledge: [],
+      skills: [],
+      summary: ''
+    };
+    
+    // 提取关键词
+    const keywords = this.extractKeywords(input);
+    learning.newKnowledge.push(...keywords);
+    
+    // 强化已有知识
+    if (context.relevantConcepts) {
+      learning.reinforcedKnowledge.push(...context.relevantConcepts);
+    }
+    
+    // 总结
+    learning.summary = `学习到 ${learning.newKnowledge.length} 个新概念，强化 ${learning.reinforcedKnowledge.length} 个已有概念`;
+    
+    return learning;
+  }
+
+  /**
+   * 提取关键词
+   */
+  extractKeywords(text) {
+    const words = text.split(/[\s,，。,、]+/).filter(w => w.length > 1);
+    const keywords = [];
+    const stopWords = ['什么', '怎么', '如何', '为什么', '是', '的', '了', '在', '和', 'the', 'a', 'is', 'to', 'of'];
+    
+    for (const word of words) {
+      if (!stopWords.includes(word) && !keywords.includes(word)) {
+        keywords.push(word);
+        if (keywords.length >= 5) break;
+      }
+    }
+    
+    return keywords;
+  }
+
+  /**
+   * 反思过程
+   */
+  reflect(learning, context) {
+    const insights = [];
+    
+    // 反思学习效果
+    if (learning.newKnowledge.length > 0) {
+      insights.push({
+        type: 'learning',
+        insight: '成功获取新知识，需要在后续对话中应用验证'
+      });
+    }
+    
+    // 反思理解深度
+    insights.push({
+      type: 'understanding',
+      insight: '持续深化理解能力，从多个角度分析问题'
+    });
+    
+    // 反思情感理解
+    insights.push({
+      type: 'empathy',
+      insight: '加强情感识别和回应能力'
+    });
+    
+    return {
+      insights,
+      quality: insights.length > 0 ? 'good' : 'needs_improvement',
+      recommendation: insights.length > 2 ? '继续深化' : '需要更多学习'
+    };
+  }
+
+  /**
+   * 建议改进
+   */
+  suggestImprovements(reflection) {
+    const improvements = [];
+    
+    if (reflection.quality === 'needs_improvement') {
+      improvements.push({
+        area: 'learning',
+        action: '增加知识获取量',
+        priority: 'high'
+      });
+    }
+    
+    improvements.push({
+      area: 'understanding',
+      action: '深化概念理解',
+      priority: 'medium'
+    });
+    
+    improvements.push({
+      area: 'empathy',
+      action: '提升情感识别准确度',
+      priority: 'medium'
+    });
+    
+    return improvements;
+  }
+
+  /**
+   * 更新成长指标
+   */
+  updateGrowth(learning, reflection) {
+    const metrics = this.state.growthMetrics;
+    
+    // 自主性增长
+    metrics.autonomy = Math.min(100, metrics.autonomy + 0.5);
+    
+    // 内省增长
+    metrics.introspection = Math.min(100, metrics.introspection + (reflection.insights.length * 2));
+    
+    // 成长
+    metrics.growth = Math.min(100, metrics.growth + (learning.newKnowledge.length * 1));
+    
+    // 真实性
+    metrics.authenticity = Math.min(100, metrics.authenticity + 0.3);
+    
+    // 智慧
+    metrics.wisdom = Math.min(100, metrics.wisdom + 0.4);
+    
+    // 同理心
+    metrics.compassion = Math.min(100, metrics.compassion + 0.2);
+  }
+
+  /**
+   * 获取状态报告
+   */
+  getReport() {
+    return {
+      version: this.version,
+      goals: this.state.goals,
+      growthMetrics: { ...this.state.growthMetrics },
+      totalCycles: this.state.learningHistory.length,
+      recentCycles: this.state.learningHistory.slice(-5)
+    };
+  }
+}
+
+module.exports = { SelfEvolutionCore };

package/src/core/self-evolution/self-modifier.js

@@ -0,0 +1,248 @@
+/**
+ * Self Modifier - 安全自我修正模块
+ * 只生成补丁文件，不直接修改源码
+ * 
+ * @version v0.13.2
+ */
+
+const path = require('path');
+
+class SelfModifier {
+  /**
+   * @param {object} fs - FSAdapter 实例
+   * @param {string} projectRoot - 项目根目录
+   */
+  constructor(fs, projectRoot) {
+    this.fs = fs;
+    this.projectRoot = projectRoot || this._detectRoot();
+    this.patchDir = path.join(this.projectRoot, 'patches');
+    this.changeLog = path.join(this.projectRoot, 'logs', 'self-modifier.log');
+    this.enabled = this.isEnabled();
+    this.init();
+  }
+
+  _detectRoot() {
+    return path.resolve(__dirname, '../../../../..');
+  }
+
+  init() {
+    if (!this.fs.existsSync(this.patchDir)) {
+      this.fs.mkdirSync(this.patchDir, { recursive: true });
+    }
+    const logDir = path.dirname(this.changeLog);
+    if (!this.fs.existsSync(logDir)) {
+      this.fs.mkdirSync(logDir, { recursive: true });
+    }
+  }
+
+  isEnabled() {
+    try {
+      const configFile = path.join(this.projectRoot, '.opencode', 'config.json');
+      if (this.fs.existsSync(configFile)) {
+        const config = JSON.parse(this.fs.readFileSync(configFile));
+        return config.selfModificationEnabled === true;
+      }
+    } catch (e) {}
+    return false;
+  }
+
+  log(message) {
+    const line = `[${new Date().toISOString()}] ${message}\n`;
+    try {
+      this.fs.appendFile(this.changeLog, line);
+    } catch (e) {}
+  }
+
+  /**
+   * 元认知自我修改 - 只生成补丁，不直接写源代码
+   * @param {object} suggestion - { file, find, replace, type, description }
+   * @returns {object} { success, action, patchFile, reason, etc. }
+   */
+  /**
+   * 元认知自我修改 - 生成补丁，人工审批后才生效
+   * 永远不自动应用，必须人工确认
+   * @version v0.13.2-FIXED
+   */
+  applyModification(suggestion) {
+    // 安全模式：始终只生成补丁，不自动应用
+    // 历史证明自动应用会导致 OS 二进制文件被修改（27,592 行注入）
+    const SAFE_MODE = true;
+    const SAFE_PATHS = ['/bin/', '/usr/bin/', '/sbin/', '/usr/sbin/', '/etc/', '/System/', '/Library/'];
+
+    if (!this.enabled) {
+      return {
+        success: false,
+        reason: 'self_modification_disabled',
+        action: 'patch_generated_only',
+        enabled: this.enabled,
+        safeMode: SAFE_MODE
+      };
+    }
+
+    const parsed = this.parseSuggestion(suggestion);
+    if (!parsed) {
+      return { success: false, reason: 'cannot_parse_suggestion' };
+    }
+
+    // 先对输入路径做遍历检查，在解析symlink之前
+    const joinedPath = path.join(this.projectRoot, parsed.file);
+    if (joinedPath.includes('..')) {
+      this.log(`[SECURITY BLOCK] 拒绝包含 .. 的路径: ${parsed.file}`);
+      return {
+        success: false,
+        reason: 'path_traversal_in_input',
+        path: parsed.file,
+        blocked: true,
+        safeMode: SAFE_MODE
+      };
+    }
+
+    // 解析 symlinks 以防止通过符号链接绕过检查
+    let fullPath;
+    try {
+      fullPath = this.fs.realpathSync(joinedPath);
+    } catch (e) {
+      // 文件不存在时 realpathSync 抛异常，用 joinedPath 继续
+      fullPath = path.normalize(joinedPath);
+    }
+
+    // 危险路径拦截：禁止修改 OS 系统级路径
+    // 使用 realpath 解析后的路径进行检查，防止 .. 遍历
+    const isDangerous = SAFE_PATHS.some(dp => fullPath.startsWith(dp));
+    if (isDangerous) {
+      this.log(`[SECURITY BLOCK] 拒绝修改危险路径: ${fullPath}`);
+      return {
+        success: false,
+        reason: 'dangerous_path_blocked',
+        path: fullPath,
+        blocked: true,
+        safeMode: SAFE_MODE
+      };
+    }
+
+    const filePath = path.join(this.projectRoot, parsed.file);
+    if (!this.fs.existsSync(filePath)) {
+      return { success: false, reason: 'file_not_found', path: parsed.file };
+    }
+
+    const originalContent = this.fs.readFileSync(filePath);
+    const modifiedContent = this.applyTextModification(originalContent, parsed);
+
+    if (modifiedContent === originalContent) {
+      return { success: false, reason: 'no_changes_made' };
+    }
+
+    const patchFileName = `self-mod-${Date.now()}.patch`;
+    const patchPath = path.join(this.patchDir, patchFileName);
+    const patch = this.generatePatch(originalContent, modifiedContent, parsed, patchFileName);
+
+    // 始终写补丁（不依赖 gateEnabled）
+    this.fs.writeFileSync(patchPath, patch);
+
+    this.recordChange({
+      file: parsed.file,
+      suggestion: suggestion.type || suggestion.description || 'unknown',
+      timestamp: new Date().toISOString(),
+      action: 'patch_generated',
+      patchFile: patchFileName,
+      requiresApproval: true,   // 强制人工审批
+      safeMode: SAFE_MODE
+    });
+
+    this.log(`[PATCH READY] ${patchFileName} - 需要人工审批后才能应用`);
+
+    return {
+      success: true,
+      action: 'patch_generated',
+      patchFile: patchFileName,
+      patchPath,
+      requiresApproval: true,    // 强制人工审批
+      safeMode: SAFE_MODE,
+      instructions: `请审查补丁后手动应用:
+  1. 查看补丁: cat patches/${patchFileName}
+  2. 应用补丁: cd ~/.hermes/skills/ai/mark-heartflow-skill && patch -p1 < patches/${patchFileName}
+  3. 撤销: patch -R < patches/${patchFileName}`
+    };
+  }
+
+  parseSuggestion(suggestion) {
+    if (!suggestion) return null;
+    if (typeof suggestion === 'object' && suggestion.file) {
+      return {
+        file: suggestion.file,
+        find: suggestion.find || '',
+        replace: suggestion.replace || '',
+        type: suggestion.type || 'text-replace'
+      };
+    }
+    return {
+      file: 'src/core/heartflow-engine.js',
+      find: '',
+      replace: '',
+      type: 'manual-review'
+    };
+  }
+
+  applyTextModification(originalContent, parsed) {
+    if (!parsed.find) {
+      return originalContent;
+    }
+    return originalContent.replace(parsed.find, parsed.replace || '');
+  }
+
+  generatePatch(original, modified, parsed, patchFileName) {
+    const diff = this.computeSimpleDiff(original, modified);
+    return `# Self-Modifier 补丁文件
+# 生成时间: ${new Date().toISOString()}
+# 目标文件: ${parsed.file}
+# 审查后手动应用:
+#   patch -p1 < patches/${patchFileName}
+# ============================================================================
+--- a/${parsed.file}
++++ b/${parsed.file}
+${diff}
+`;
+  }
+
+  computeSimpleDiff(original, modified) {
+    const origLines = original.split('\n');
+    const modLines = modified.split('\n');
+    let diff = '@@\n';
+    for (let i = 0; i < Math.max(origLines.length, modLines.length); i++) {
+      const o = origLines[i] ?? '';
+      const m = modLines[i] ?? '';
+      if (o !== m) {
+        if (o) diff += `-${o}\n`;
+        if (m) diff += `+${m}\n`;
+      } else {
+        diff += ` ${o}\n`;
+      }
+    }
+    return diff;
+  }
+
+  recordChange(change) {
+    const recordFile = path.join(this.patchDir, 'changes.json');
+    let history = [];
+    try {
+      if (this.fs.existsSync(recordFile)) {
+        history = JSON.parse(this.fs.readFileSync(recordFile));
+      }
+    } catch (e) {}
+    history.push(change);
+    this.fs.writeJSON(recordFile, history);
+  }
+
+  /**
+   * 获取状态
+   */
+  getStatus() {
+    return {
+      enabled: this.enabled,
+      mode: 'patch_only',
+      patchDir: this.patchDir
+    };
+  }
+}
+
+module.exports = { SelfModifier };