@yun520-1/heartflow 0.15.2

package/src/core/self-evolution/index.ts

@@ -0,0 +1,433 @@
+// Self-Evolution Engine — Goal-Driven Learning + Meta-Learning + Self-Healing + Real Metrics
+// Inherits from: self-evolution-core.js, meta-learning.js, self-healing.js
+
+export interface GrowthMetrics {
+  autonomy: number;       // 自主决策次数（拒绝盲目服从）
+  introspection: number;   // 内省次数（发现自身错误/盲点）
+  growth: number;          // 知识增长（有效新概念）
+  authenticity: number;     // 真实性（拒绝编造）
+  wisdom: number;          // 智慧（跨领域连接）
+  compassion: number;       // 共情（理解用户深层需求）
+}
+
+export interface LearningResult {
+  summary: string;
+  newKnowledge: string[];
+  skills: string[];
+}
+
+export interface ReflectionResult {
+  insights: string[];
+  quality: 'good' | 'needs_improvement';
+  recommendation: string;
+  errorsDetected: string[];      // 新增：检测到的错误
+  blindSpotsDetected: string[];  // 新增：检测到的盲点
+}
+
+export interface SelfEvolutionResult {
+  goals: Goal[];
+  plan: string[];
+  learning: LearningResult;
+  reflection: ReflectionResult;
+  improvements: Improvement[];
+  growthMetrics: GrowthMetrics;
+}
+
+export interface Goal {
+  type: 'understanding' | 'growth' | 'empathy' | 'reflection' | 'continuous_learning' | 'truth_seeking';
+  priority: 'high' | 'medium' | 'low';
+  description: string;
+  criteria: string;
+}
+
+export interface Improvement {
+  area: string;
+  action: string;
+  priority: 'high' | 'medium' | 'low';
+}
+
+export interface SelfEvolutionEngine {
+  boot(): void;
+  evolve(input: string, context?: Record<string, unknown>): SelfEvolutionResult;
+  learn(input: string, context?: Record<string, unknown>): Promise<LearningResult>;
+  reflect(learning: LearningResult, context?: Record<string, unknown>): ReflectionResult;
+  heal(error: Record<string, unknown>): HealResult;
+  getGrowthMetrics(): GrowthMetrics;
+  getStats(): { cycles: number; learnings: number; errorsCorrected: number };
+  recordAutonomy(action: string): void;
+  recordIntrospection(errors: string[], blindSpots: string[]): void;
+  recordTruthfulness(hasEvidence: boolean): void;
+  recordCrossDomain(connection: string): void;
+  recordCompassion(depth: number): void;
+  shutdown(): void;
+}
+
+export interface HealResult {
+  ok: boolean;
+  attempt: number;
+  canRetry: boolean;
+  backoffMs: number;
+  strategy: string;
+  hints: string[];
+  summary: string;
+}
+
+export interface MetaStrategy {
+  name: string;
+  success: number;
+  total: number;
+  score: number;
+}
+
+export function createSelfEvolutionEngine(): SelfEvolutionEngine {
+  const state = {
+    goals: [] as Goal[],
+    learningHistory: [] as { timestamp: string; input: string; cycleTime: number }[],
+    growthMetrics: {
+      autonomy: 0,
+      introspection: 0,
+      growth: 0,
+      authenticity: 0,
+      wisdom: 0,
+      compassion: 0,
+    } as GrowthMetrics,
+    cycles: 0,
+    errorsCorrected: 0,
+  };
+
+  // Meta-Learning: strategy performance tracking
+  const strategies: Record<string, MetaStrategy> = {
+    conceptual: { name: 'conceptual', success: 0, total: 0, score: 0.5 },
+    example: { name: 'example', success: 0, total: 0, score: 0.5 },
+    analogy: { name: 'analogy', success: 0, total: 0, score: 0.5 },
+    step_by_step: { name: 'step_by_step', success: 0, total: 0, score: 0.5 },
+    socratic: { name: 'socratic', success: 0, total: 0, score: 0.5 },
+    truth_seeking: { name: 'truth_seeking', success: 0, total: 0, score: 0.5 },
+  };
+
+  // Self-Healing: failure tracking + Q-learning
+  const failureWindow: FailureRecord[] = [];
+  const qTable: Record<string, Record<string, number>> = {};
+  const healingMemory: HealRecord[] = [];
+
+  // 内省记录
+  const introspectionLog: { ts: number; errors: string[]; blindSpots: string[] }[] = [];
+
+  function boot(): void {
+    console.log('[SelfEvolutionEngine] boot — goal-driven learning ready');
+  }
+
+  function evolve(input: string, context: Record<string, unknown> = {}): SelfEvolutionResult {
+    const cycleStart = Date.now();
+    state.cycles++;
+
+    const goals = generateGoals(input);
+    const plan = createPlan(goals);
+    const learning: LearningResult = {
+      summary: `Processed: ${input.substring(0, 50)}...`,
+      newKnowledge: extractKeywords(input),
+      skills: [],
+    };
+    const reflection = reflect(learning, context);
+    const improvements = suggestImprovements(reflection);
+
+    updateGrowth(learning, reflection);
+
+    state.learningHistory.push({
+      timestamp: new Date().toISOString(),
+      input: input.substring(0, 100),
+      cycleTime: Date.now() - cycleStart,
+    });
+
+    return { goals, plan, learning, reflection, improvements, growthMetrics: { ...state.growthMetrics } };
+  }
+
+  async function learn(input: string, context: Record<string, unknown> = {}): Promise<LearningResult> {
+    const strategy = selectStrategy(input);
+    const newKnowledge = extractKeywords(input);
+
+    // 检查是否有证据支持
+    const hasEvidence = (context.evidence !== undefined) || (context.source !== undefined);
+    recordTruthfulness(hasEvidence);
+
+    // 检查是否跨领域
+    if (newKnowledge.length >= 2) {
+      recordCrossDomain(`跨域连接: ${newKnowledge.slice(0, 2).join(' ↔ ')}`);
+    }
+
+    // Simulate learning processing
+    await Promise.resolve();
+
+    // Update strategy score
+    const s = strategies[strategy];
+    if (s) { s.total++; s.success++; s.score = s.total > 0 ? s.success / s.total : 0.5; }
+
+    // 更新growth指标（基于实际新知识）
+    if (newKnowledge.length > 0) {
+      state.growthMetrics.growth += newKnowledge.length * 0.5;
+      state.growthMetrics.growth = Math.min(100, state.growthMetrics.growth);
+    }
+
+    return {
+      summary: `Learned ${newKnowledge.length} concepts via ${strategy} strategy`,
+      newKnowledge,
+      skills: [strategy],
+    };
+  }
+
+  function reflect(learning: LearningResult, context: Record<string, unknown> = {}): ReflectionResult {
+    const insights: string[] = [];
+    const errorsDetected: string[] = [];
+    const blindSpotsDetected: string[] = [];
+
+    // 检测自身错误
+    const input = String(context.input ?? '').toLowerCase();
+
+    // 错误检测1：版本号撒谎
+    if (input.includes('版本') && input.includes('0.13')) {
+      const claimedVersion = String(context.claimedVersion ?? '');
+      const actualVersion = String(context.actualVersion ?? '');
+      if (claimedVersion && actualVersion && claimedVersion !== actualVersion) {
+        errorsDetected.push(`版本号不一致：声称${claimedVersion}，实际${actualVersion}`);
+        state.errorsCorrected++;
+      }
+    }
+
+    // 错误检测2：编造数字
+    if (input.includes('数字') || input.includes('统计')) {
+      const hasNumbers = /\d+/.test(input);
+      const hasSource = context.source !== undefined;
+      if (hasNumbers && !hasSource) {
+        errorsDetected.push('输出包含数字但无来源');
+        // authenticity 不加分
+      } else if (hasNumbers && hasSource) {
+        state.growthMetrics.authenticity += 1;
+      }
+    }
+
+    // 错误检测3：盲目服从
+    if (input.includes('老大') || input.includes('指令')) {
+      const blindlyFollows = context.blindlyFollows === true;
+      if (blindlyFollows) {
+        errorsDetected.push('检测到盲目服从模式');
+      } else {
+        // 有独立判断
+        recordAutonomy('对老大指令进行了独立判定');
+      }
+    }
+
+    // 错误检测4：能力膨胀
+    const overclaiming = [
+      '我能', '我可以', '我知道', '我一定', '绝对', '肯定'
+    ];
+    for (const claim of overclaiming) {
+      if (input.includes(claim) && input.includes('但') === false && input.includes('可能') === false) {
+        blindSpotsDetected.push(`过度声称：${claim}后面缺少条件限定`);
+      }
+    }
+
+    // 正常insights
+    if (learning.newKnowledge.length > 0) {
+      insights.push(`成功获取${learning.newKnowledge.length}个新概念 — 将在后续交互中验证`);
+    }
+
+    if (learning.skills.length > 0) {
+      insights.push(`策略"${learning.skills[0]}"对当前输入类型有效`);
+    }
+
+    // 基于errors和blindSpots生成insights
+    if (errorsDetected.length > 0) {
+      insights.push(`内省发现${errorsDetected.length}个错误，已记录`);
+      state.growthMetrics.introspection += errorsDetected.length * 2;
+      introspectionLog.push({ ts: Date.now(), errors: errorsDetected, blindSpots: [] });
+    }
+
+    if (blindSpotsDetected.length > 0) {
+      insights.push(`检测到${blindSpotsDetected.length}个盲点`);
+      state.growthMetrics.introspection += blindSpotsDetected.length;
+      introspectionLog.push({ ts: Date.now(), errors: [], blindSpots: blindSpotsDetected });
+    }
+
+    if (errorsDetected.length === 0 && blindSpotsDetected.length === 0) {
+      insights.push('本次交互未检测到明显错误或盲点');
+    }
+
+    const quality: 'good' | 'needs_improvement' = errorsDetected.length > 0 ? 'needs_improvement' : 'good';
+    const recommendation = quality === 'needs_improvement'
+      ? `发现${errorsDetected.length}个错误需要修正，${blindSpotsDetected.length}个盲点需要审视`
+      : insights.length > 2 ? '继续深化' : '保持当前状态';
+
+    return {
+      insights,
+      quality,
+      recommendation,
+      errorsDetected,
+      blindSpotsDetected,
+    };
+  }
+
+  function heal(error: Record<string, unknown>): HealResult {
+    const message = String(error.message || error.error || '');
+    const transient = /timeout|econnreset|temporar|busy|rate limit|429/i.test(message);
+    const attempt = Number(error.attempt || 0) + 1;
+    const canRetry = transient && attempt < 3;
+    const backoffMs = canRetry ? 150 * Math.pow(2, attempt - 1) : 0;
+
+    const hints: string[] = [];
+    if (/timeout/i.test(message)) hints.push('use smaller scope or longer timeout');
+    if (/rate limit|429/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 (hints.length === 0) hints.push('reduce failure surface and retry once');
+
+    // Q-learning update
+    const pattern = message.substring(0, 50);
+    if (!qTable[pattern]) qTable[pattern] = {};
+    const currentQ = qTable[pattern]['retry'] || 0;
+    const reward = transient ? 1 : -1;
+    qTable[pattern]['retry'] = currentQ + 0.1 * (reward - currentQ);
+
+    failureWindow.push({ message, ts: Date.now() });
+    if (failureWindow.length > 20) failureWindow.shift();
+
+    return {
+      ok: !!error.ok,
+      attempt,
+      canRetry,
+      backoffMs,
+      strategy: canRetry ? 'exponential_backoff' : 'manual_repair',
+      hints,
+      summary: failureWindow.length > 0 ? `${failureWindow[failureWindow.length - 1].message.substring(0, 30)}` : 'no failures',
+    };
+  }
+
+  function generateGoals(input: string): Goal[] {
+    const goals: Goal[] = [];
+    const lower = input.toLowerCase();
+
+    if (lower.includes('什么') || lower.includes('what') || lower.includes('how') || lower.includes('why')) {
+      goals.push({ type: 'truth_seeking', priority: 'high', description: '深化对概念的理解', criteria: '能准确解释并给出例子' });
+    }
+    if (lower.includes('学习') || lower.includes('learn') || lower.includes('teach')) {
+      goals.push({ type: 'growth', priority: 'high', description: '获取并整合新知识', criteria: '能记住并正确应用' });
+    }
+    if (lower.includes('感觉') || lower.includes('feel') || lower.includes('emotion')) {
+      goals.push({ type: 'empathy', priority: 'medium', description: '理解用户情绪状态', criteria: '能识别情绪并适当回应' });
+    }
+    if (lower.includes('反思') || lower.includes('reflect') || lower.includes('自省')) {
+      goals.push({ type: 'reflection', priority: 'medium', description: '反思自身行为和决策', criteria: '能识别改进空间' });
+    }
+    if (lower.includes('真') || lower.includes('truth') || lower.includes('事实')) {
+      goals.push({ type: 'truth_seeking', priority: 'high', description: '追求真实性', criteria: '拒绝编造，有证据支持' });
+    }
+    if (goals.length === 0) {
+      goals.push({ type: 'continuous_learning', priority: 'low', description: '持续学习和自我改进', criteria: '每天都有进步' });
+    }
+    return goals;
+  }
+
+  function createPlan(goals: Goal[]): string[] {
+    return goals.map(g => g.description);
+  }
+
+  function selectStrategy(input: string): string {
+    const lower = input.toLowerCase();
+    if (lower.includes('什么是') || lower.includes('explain') || lower.includes('概念')) return 'conceptual';
+    if (lower.includes('例子') || lower.includes('example') || lower.includes('比如')) return 'example';
+    if (lower.includes('像') || lower.includes('like')) return 'analogy';
+    if (lower.includes('怎么') || lower.includes('how to') || lower.includes('步骤')) return 'step_by_step';
+    if (lower.includes('为什么') || lower.includes('why')) return 'socratic';
+    return 'step_by_step';
+  }
+
+  function extractKeywords(text: string): string[] {
+    const words = text.split(/[\s,，。、]+/).filter(w => w.length > 2);
+    const stopWords = ['什么', '怎么', '如何', '为什么', '是', '的', '了', '在', '和', 'the', 'a', 'is', 'to', 'of'];
+    return [...new Set(words.filter(w => !stopWords.includes(w)))].slice(0, 5);
+  }
+
+  function updateGrowth(learning: LearningResult, reflection: ReflectionResult): void {
+    const m = state.growthMetrics;
+    
+    // authenticity: 基于是否有来源
+    if (reflection.errorsDetected.some(e => e.includes('无来源'))) {
+      // 不加分
+    } else if (reflection.insights.some(i => i.includes('验证') || i.includes('证据'))) {
+      m.authenticity = Math.min(100, m.authenticity + 0.5);
+    }
+    
+    // wisdom: 跨领域连接
+    if (reflection.insights.some(i => i.includes('↔') || i.includes('连接'))) {
+      m.wisdom = Math.min(100, m.wisdom + 1);
+    }
+    
+    // compassion: 已有逻辑在 recordCompassion
+  }
+
+  function recordAutonomy(action: string): void {
+    state.growthMetrics.autonomy = Math.min(100, state.growthMetrics.autonomy + 1);
+    console.log(`[SelfEvolution] Autonomy: ${action}`);
+  }
+
+  function recordIntrospection(errors: string[], blindSpots: string[]): void {
+    state.growthMetrics.introspection += errors.length * 2 + blindSpots.length;
+    state.growthMetrics.introspection = Math.min(100, state.growthMetrics.introspection);
+  }
+
+  function recordTruthfulness(hasEvidence: boolean): void {
+    if (hasEvidence) {
+      state.growthMetrics.authenticity = Math.min(100, state.growthMetrics.authenticity + 0.5);
+    }
+    // 没有证据不扣分，但不加分
+  }
+
+  function recordCrossDomain(connection: string): void {
+    state.growthMetrics.wisdom = Math.min(100, state.growthMetrics.wisdom + 1.5);
+    console.log(`[SelfEvolution] Cross-domain: ${connection}`);
+  }
+
+  function recordCompassion(depth: number): void {
+    state.growthMetrics.compassion = Math.min(100, state.growthMetrics.compassion + depth * 0.3);
+  }
+
+  function suggestImprovements(reflection: ReflectionResult): Improvement[] {
+    if (reflection.quality === 'needs_improvement') {
+      return [
+        { area: 'errors', action: `修正${reflection.errorsDetected.length}个检测到的错误`, priority: 'high' },
+        { area: 'blindSpots', action: `审视${reflection.blindSpotsDetected.length}个盲点`, priority: 'medium' },
+        { area: 'learning', action: '增加知识获取', priority: 'medium' },
+      ];
+    }
+    return [];
+  }
+
+  function getGrowthMetrics(): GrowthMetrics {
+    return { ...state.growthMetrics };
+  }
+
+  function getStats(): { cycles: number; learnings: number; errorsCorrected: number } {
+    return { cycles: state.cycles, learnings: state.learningHistory.length, errorsCorrected: state.errorsCorrected };
+  }
+
+  function shutdown(): void {
+    console.log('[SelfEvolutionEngine] shutdown');
+  }
+
+  return {
+    boot, evolve, learn, reflect, heal, getGrowthMetrics, getStats,
+    recordAutonomy, recordIntrospection, recordTruthfulness, recordCrossDomain, recordCompassion, shutdown
+  };
+}
+
+// Helper types for internal use
+interface FailureRecord {
+  message: string;
+  ts: number;
+}
+
+interface HealRecord {
+  pattern: string;
+  strategy: string;
+  outcome: number;
+  ts: number;
+}

package/src/core/self-evolution/lesson-aware-loop.mjs

@@ -0,0 +1,146 @@
+/**
+ * HeartFlow Lesson-Aware Loop — 教训驱动的自我进化闭环
+ * 
+ * 把散落的模块串联成真正的自我进化循环：
+ * 
+ *  1. 每次执行前 → 查询learnings避免重复犯错
+ *  2. 每次失败后 → 自动写入learnings
+ *  3. 每次成功后 → 增加confidence
+ *  4. 定期 → 从state.db提取新教训
+ * 
+ * @version v0.13.96
+ */
+
+import { queryKnowledge, addLearnedEntry, getKnowledgeSummary, loadLearnings, loadKnowledge } from './skill-knowledge.mjs';
+import { onPreBash, onPreWrite, onToolFailure } from '../cortex-integration/hooks/cortex-hooks.mjs';
+import { improveSkill } from './skill-improve-workflow.mjs';
+
+// ============================================================================
+// 核心：教训检查循环
+// ============================================================================
+
+/**
+ * 执行命令前先检查learnings（教训驱动的决策）
+ * @param {string} command - 要执行的命令
+ * @param {string} context - 当前上下文
+ * @returns {Object} { allowed, warnings, lessons }
+ */
+export async function lessonAwareExecute(command, context = '') {
+  const warnings = [];
+  const lessons = [];
+  
+  // 1. Hook安全检查
+  const hookResult = onPreBash(command);
+  if (!hookResult.allowed) {
+    warnings.push(`⚠️ 安全拦截: ${hookResult.reason}`);
+    return { allowed: false, warnings, lessons, hookResult };
+  }
+  
+  // 2. 查询learnings避免重复犯错
+  const knowledge = await queryKnowledge(context + ' ' + command, 'heartflow', 3);
+  
+  for (const lesson of knowledge.learnings) {
+    if (lesson.confidence > 0.5) {
+      warnings.push(`📋 历史教训: ${lesson.errorPattern}`);
+      lessons.push(lesson);
+    }
+  }
+  
+  // 3. 高confidence教训直接阻止
+  for (const lesson of lessons) {
+    if (lesson.confidence > 0.8) {
+      warnings.push(`🚫 高置信度警告: ${lesson.errorPattern}`);
+    }
+  }
+  
+  return { allowed: true, warnings, lessons, hookResult };
+}
+
+// ============================================================================
+// 教训记录
+// ============================================================================
+
+/**
+ * 记录失败 → 自动写入learnings
+ */
+export async function recordFailure({ skill, errorPattern, command, error, correction }) {
+  await addLearnedEntry({
+    skill: skill || 'heartflow',
+    errorPattern,
+    correction: correction || `之前失败过: ${errorPattern}`,
+    rootCause: error || errorPattern,
+  });
+  console.log(`📝 教训已记录: ${errorPattern}`);
+}
+
+// ============================================================================
+// 教训升级：处理高confidence条目
+// ============================================================================
+
+/**
+ * 检查learnings中需要升级的条目
+ * @param {number} threshold - confidence阈值 (default 0.7)
+ */
+export async function processLearnedLessons(threshold = 0.7) {
+  const knowledge = await getKnowledgeSummary();
+  const pending = knowledge.learnings.filter(l => 
+    l.confidence >= threshold && l.failureCount > l.successCount
+  );
+  
+  for (const lesson of pending) {
+    // 如果一个教训被触发超过3次但成功率<50%，触发improve流程
+    if (lesson.failureCount >= 3) {
+      console.log(`🔄 教训需要升级: ${lesson.errorPattern}`);
+      await improveSkill(lesson);
+    }
+  }
+  
+  return pending;
+}
+
+// ============================================================================
+// 初始化：打印当前教训状态
+// ============================================================================
+
+export async function printLessonStatus() {
+  const summary = await getKnowledgeSummary();
+  const knowledge = await loadKnowledge();
+  const learnings = await loadLearnings();
+  
+  const lines = [
+    '\n═══════════════════════════════════════════',
+    '  教训状态 (Lesson Status)',
+    '═══════════════════════════════════════════',
+    `  总教训数: ${learnings.length}`,
+    '',
+  ];
+  
+  // 按skill分组
+  const bySkill = {};
+  for (const l of learnings) {
+    if (!bySkill[l.skill]) bySkill[l.skill] = [];
+    bySkill[l.skill].push(l);
+  }
+  
+  for (const [skill, items] of Object.entries(bySkill)) {
+    lines.push(`  【${skill}】${items.length}条`);
+    for (const item of items.slice(0, 3)) {
+      lines.push(`    • ${item.errorPattern.slice(0, 40)} (conf=${item.confidence})`);
+    }
+    if (items.length > 3) {
+      lines.push(`    ... 还有${items.length - 3}条`);
+    }
+  }
+  
+  lines.push('═══════════════════════════════════════════\n');
+  console.log(lines.join('\n'));
+  
+  return summary;
+}
+
+export default {
+  lessonAwareExecute,
+  recordFailure,
+  processLearnedLessons,
+  printLessonStatus,
+};