@yun520-1/heartflow 0.15.2

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

@@ -0,0 +1,199 @@
+/**
+ * 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. }
+   */
+  applyModification(suggestion) {
+    const gateEnabled = process.env.HEARTFLOW_ENABLE_SELF_MODIFICATION === '1';
+    if (!this.enabled || !gateEnabled) {
+      return {
+        success: false,
+        reason: 'self_modification_disabled',
+        action: 'generate_patch_only',
+        enabled: this.enabled,
+        gateEnabled
+      };
+    }
+
+    const parsed = this.parseSuggestion(suggestion);
+    if (!parsed) {
+      return { success: false, reason: 'cannot_parse_suggestion' };
+    }
+
+    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);
+    
+    if (process.env.HEARTFLOW_ENABLE_SELF_MODIFICATION === '1') {
+      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
+    });
+
+    this.log(`Patch generated: ${patchFileName}`);
+
+    return {
+      success: true,
+      action: 'patch_generated',
+      patchFile: patchFileName,
+      patchPath,
+      requiresApproval: true,
+      instructions: `请审查补丁后手动应用: patch -p1 < 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 };

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

@@ -0,0 +1,42 @@
+/**
+ * Self-Refine — Madaan et al. 2024
+ * 迭代优化输出，直到收敛或达到最大轮次
+ * @version v0.12.50
+ */
+'use strict';
+
+class SelfRefine {
+  constructor(reflexion) {
+    if (!reflexion) throw new Error('SelfRefine requires a valid Reflexion instance');
+    this.reflexion = reflexion;
+  }
+
+  /**
+   * @param {function} generateFn - (iter, ctx) => Promise<string>
+   * @param {function} feedbackFn - (output) => Promise<{rating, critique}>
+   * @param {object} opts - { maxIter, targetRating }
+   */
+  async refine(generateFn, feedbackFn, { maxIter = 3, targetRating = 4 } = {}) {
+    let output = await generateFn(0);
+    let iteration = 0;
+    let rating = 0;
+
+    while (iteration < maxIter) {
+      const fb = await feedbackFn(output);
+      rating = fb.rating || 0;
+      if (rating >= targetRating) break;
+      iteration++;
+      output = await generateFn(iteration, { output, critique: fb.critique });
+    }
+
+    this.reflexion.reflect({
+      task: 'self-refine',
+      outcome: rating >= targetRating ? 'success:converged' : 'success:max-iter',
+      feedback: { rating },
+    });
+
+    return { output, iterations: iteration + 1, rating };
+  }
+}
+
+module.exports = { SelfRefine };

package/src/core/self-evolution/skill-improve-workflow.mjs

@@ -0,0 +1,264 @@
+/**
+ * Skill Improvement Workflow
+ * 
+ * Orchestrates: capture error → query knowledge → reflexion → update skill
+ * This is the "closing the loop" step that makes self-evolution actually work.
+ * 
+ * Workflow:
+ * 1. Capture failure (from hook or manual trigger)
+ * 2. Query knowledge base for similar patterns
+ * 3. Generate root cause + correction via reflexion prompts
+ * 4. Update skill definition
+ * 
+ * @version v0.13.93
+ */
+
+import { queryKnowledge, addLearnedEntry, getKnowledgeSummary } from './skill-knowledge.mjs';
+import {
+  buildReflectionPrompt,
+  buildImprovePrompt,
+  buildRootCausePrompt,
+  buildCorrectionPrompt,
+} from './reflexion-prompts.mjs';
+import { promises as fs } from 'fs';
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+/**
+ * @typedef {Object} SkillImprovement
+ * @property {string} skillName
+ * @property {string} errorPattern
+ * @property {string} errorOutput
+ * @property {string} [rootCause]
+ * @property {string} [correction]
+ * @property {string} [improvedGuidance]
+ * @property {number} confidence
+ * @property {string} timestamp
+ */
+
+// ============================================================================
+// Config
+// ============================================================================
+
+const SKILL_DIR = process.env.HERMES_SKILL_DIR 
+  || join(homedir(), '.hermes', 'skills');
+
+// ============================================================================
+// Core Workflow
+// ============================================================================
+
+/**
+ * Full skill improvement workflow
+ * 
+ * @param {Object} params
+ * @param {string} params.skillName - Which skill failed
+ * @param {string} params.errorPattern - What was attempted
+ * @param {string} params.errorOutput - Error output / failure reason
+ * @param {string} params.taskType - Category: 'coding', 'search', 'reasoning', etc.
+ * @param {function(string, string): Promise<string>} [llmCall] - Optional LLM
+ * @returns {Promise<SkillImprovement>}
+ */
+export async function improveSkill({ skillName, errorPattern, errorOutput, taskType = 'general', llmCall }) {
+  const timestamp = new Date().toISOString();
+  
+  // Step 1: Query knowledge base for similar past errors
+  const { matched, learnings } = await queryKnowledge(errorPattern, skillName);
+  
+  // Step 2: Generate root cause
+  let rootCause;
+  if (llmCall) {
+    try {
+      rootCause = await llmCall(
+        'You are a root-cause analyst.',
+        buildRootCausePrompt(errorPattern, errorOutput)
+      );
+    } catch {
+      rootCause = heuristicRootCause(errorPattern, errorOutput);
+    }
+  } else {
+    rootCause = heuristicRootCause(errorPattern, errorOutput);
+  }
+
+  // Step 3: Generate correction
+  let correction;
+  if (llmCall) {
+    try {
+      correction = await llmCall(
+        'You are a technical mentor.',
+        buildCorrectionPrompt(errorPattern, errorOutput, rootCause)
+      );
+    } catch {
+      correction = 'Review the error message and verify all parameters before retrying.';
+    }
+  } else {
+    correction = heuristicCorrection(errorPattern, errorOutput);
+  }
+
+  // Step 4: Generate improved guidance
+  let improvedGuidance;
+  if (llmCall && matched.length > 0) {
+    const existing = matched[0];
+    try {
+      improvedGuidance = await llmCall(
+        'You are a skill improvement specialist.',
+        `Current guidance: ${existing.guidance}\n\nError: ${errorOutput}\nRoot cause: ${rootCause}\nCorrection: ${correction}\n\nWrite an improved version of the guidance that prevents this error.`
+      );
+    } catch {
+      improvedGuidance = `${correction} (结合现有指导: ${existing.guidance})`;
+    }
+  } else {
+    improvedGuidance = correction;
+  }
+
+  // Step 5: Store in knowledge base
+  await addLearnedEntry({
+    skill: skillName,
+    errorPattern,
+    correction,
+    rootCause,
+  });
+
+  const improvement = {
+    skillName,
+    errorPattern,
+    errorOutput,
+    rootCause,
+    correction,
+    improvedGuidance,
+    confidence: learnings.length > 0 ? Math.min(0.9, 0.5 + learnings.length * 0.1) : 0.5,
+    timestamp,
+  };
+
+  console.log(`[SkillImprove] ${skillName}: ${errorPattern.slice(0, 50)} → ${correction.slice(0, 50)}`);
+
+  return improvement;
+}
+
+/**
+ * Apply improved guidance to a skill file
+ * 
+ * @param {string} skillName
+ * @param {string} improvedGuidance
+ * @param {string} [skillDir]
+ */
+export async function patchSkillGuidance(skillName, improvedGuidance, skillDir) {
+  const dir = skillDir || SKILL_DIR;
+  
+  // Find skill directory
+  const skillPath = join(dir, skillName);
+  const skillMdPath = join(skillPath, 'SKILL.md');
+  
+  try {
+    const content = await fs.readFile(skillMdPath, 'utf8');
+    
+    // Find guidance section and update
+    // Look for the guidance line (simplified - finds first bullet with guidance)
+    const lines = content.split('\n');
+    let updated = false;
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      // Match guidance lines (starting with - or numbered)
+      if ((line.startsWith('  - ') || /^\d+\)/.test(line)) && line.length > 20) {
+        // Append improvement note
+        lines[i] = line + `\n  - [改进] ${improvedGuidance}`;
+        updated = true;
+        break;
+      }
+    }
+    
+    if (updated) {
+      await fs.writeFile(skillMdPath, lines.join('\n'));
+      return { patched: true, path: skillMdPath };
+    }
+    
+    return { patched: false, reason: 'No guidance line found' };
+  } catch (err) {
+    return { patched: false, reason: err.message };
+  }
+}
+
+/**
+ * Get skill improvement summary
+ */
+export async function getImprovementSummary() {
+  const summary = await getKnowledgeSummary();
+  
+  return {
+    ...summary,
+    recommendations: generateRecommendations(summary),
+  };
+}
+
+/**
+ * Generate actionable recommendations from knowledge summary
+ */
+function generateRecommendations(summary) {
+  const recs = [];
+  
+  if (summary.learningsCount === 0) {
+    recs.push({
+      priority: 'low',
+      action: '等待错误发生',
+      note: 'learnings库为空，等待实际错误来填充',
+    });
+  }
+  
+  if (summary.avgConfidence < 0.5) {
+    recs.push({
+      priority: 'high',
+      action: 'decayOldEntries()',
+      note: `平均置信度${summary.avgConfidence}过低，运行衰减清理`,
+    });
+  }
+  
+  if (summary.highConfidenceLearnings > 0) {
+    recs.push({
+      priority: 'medium',
+      action: '优先应用高置信度learnings',
+      note: `有${summary.highConfidenceLearnings}条高置信度规则可注入system prompt`,
+    });
+  }
+  
+  return recs;
+}
+
+// ============================================================================
+// Heuristics (fallback when no LLM)
+// ============================================================================
+
+function heuristicRootCause(action, error) {
+  const e = error.toLowerCase();
+  const a = action.toLowerCase();
+  
+  if (e.includes('not found') || e.includes('enoent')) {
+    if (a.includes('read') || a.includes('open')) return 'File/resource does not exist';
+    return 'Required resource not found';
+  }
+  if (e.includes('permission')) return 'Permission denied';
+  if (e.includes('timeout')) return 'Operation timed out';
+  if (e.includes('syntax')) return 'Syntax error';
+  if (e.includes('type')) return 'Type mismatch';
+  return `Error: ${error.slice(0, 60)}`;
+}
+
+function heuristicCorrection(action, error) {
+  const e = error.toLowerCase();
+  
+  if (e.includes('not found')) return 'Verify file path exists before operation';
+  if (e.includes('permission')) return 'Check file permissions or use elevated access';
+  if (e.includes('timeout')) return 'Increase timeout or simplify the operation';
+  if (e.includes('syntax')) return 'Review syntax before executing';
+  if (e.includes('type')) return 'Ensure type compatibility';
+  return 'Review error message and verify inputs before retrying';
+}
+
+export default {
+  improveSkill,
+  patchSkillGuidance,
+  getImprovementSummary,
+};