@yun520-1/heartflow 0.15.2 → 0.16.0

package/patches/embodied-core-v2.2.3.patch

@@ -1,475 +0,0 @@
-diff --git a/src/core/embodied-core.js b/src/core/embodied-core.js
-new file mode 100644
-index 0000000..8b6bf7b
---- /dev/null
-+++ b/src/core/embodied-core.js
-@@ -0,0 +1,468 @@
-+/**
-+ * Embodied-Core - 具身认知核心
-+ * 
-+ * 设计理念：
-+ * - 双系统架构：System 1 (直觉/快思考) + System 2 (分析/慢思考)
-+ * - 动作思维链 (Action-Thought Chain)：将高层目标拆解为有序思维步骤
-+ * - bio-sensor-adapter 接口：为心率变异、代码编辑流等数据预留扩展点
-+ * 
-+ * 核心功能：
-+ * - cognitivePlan(): 目标 -> 思维步骤
-+ * - executionMapping(): 思维步骤 -> 智能体/工具调用
-+ */
-+
-+const fs = require('fs');
-+const path = require('path');
-+
-+class EmbodiedCore {
-+  constructor(projectRoot) {
-+    this.projectRoot = projectRoot;
-+    
-+    // 认知系统状态
-+    this.cognitiveState = {
-+      system: 'idle', // idle, planning, executing, reflecting
-+      activePlan: null,
-+      executionHistory: [],
-+      workingMemory: []
-+    };
-+    
-+    // 思维步骤类型
-+    this.stepTypes = {
-+      OBSERVE: 'observe',      // 观察/感知
-+      ANALYZE: 'analyze',     // 分析/推理
-+      PLAN: 'plan',           // 规划/计划
-+      DECIDE: 'decide',       // 决策/选择
-+      EXECUTE: 'execute',     // 执行/行动
-+      REFLECT: 'reflect',     // 反思/复盘
-+      ADAPT: 'adapt'          // 适应/调整
-+    };
-+    
-+    // 可用执行器
-+    this.executors = this.loadExecutors();
-+    
-+    // 传感器适配器
-+    this.sensorAdapters = {};
-+    
-+    console.log('[EmbodiedCore] 具身认知核心初始化');
-+  }
-+
-+  /**
-+   * 加载可用的执行器
-+   */
-+  loadExecutors() {
-+    return {
-+      // 智能体
-+      SelfAgent: { type: 'agent', module: '../agents/SelfAgent', weight: 1.0 },
-+      MoodAgent: { type: 'agent', module: '../agents/MoodAgent', weight: 0.9 },
-+      FocusAgent: { type: 'agent', module: '../agents/FocusAgent', weight: 0.9 },
-+      ReflectionAgent: { type: 'agent', module: '../agents/ReflectionAgent', weight: 0.8 },
-+      
-+      // 工具
-+      'code-analysis': { type: 'tool', capability: 'analyze', weight: 1.0 },
-+      'code-generation': { type: 'tool', capability: 'generate', weight: 1.0 },
-+      'search': { type: 'tool', capability: 'search', weight: 0.8 },
-+      'git-operations': { type: 'tool', capability: 'version-control', weight: 0.7 },
-+      'file-operation': { type: 'tool', capability: 'io', weight: 0.9 }
-+    };
-+  }
-+
-+  /**
-+   * 注册传感器适配器
-+   * @param {string} name - 传感器名称
-+   * @param {object} adapter - 适配器实例
-+   */
-+  registerSensorAdapter(name, adapter) {
-+    this.sensorAdapters[name] = adapter;
-+    console.log(`[EmbodiedCore] 注册传感器: ${name}`);
-+  }
-+
-+  /**
-+   * 认知规划 - 将高层目标拆解为有序思维步骤
-+   * @param {object} goal - 目标对象
-+   * @returns {object} 思维步骤序列
-+   */
-+  cognitivePlan(goal) {
-+    const {
-+      description,
-+      type = 'general', // general, coding, debugging, learning, creative
-+      constraints = {},
-+      context = {}
-+    } = goal;
-+
-+    this.cognitiveState.system = 'planning';
-+    
-+    const steps = this.decomposeGoal(description, type, constraints, context);
-+    
-+    const plan = {
-+      id: `plan-${Date.now()}`,
-+      goal: description,
-+      type,
-+      steps,
-+      metadata: {
-+        createdAt: new Date().toISOString(),
-+        estimatedSteps: steps.length,
-+        complexity: this.estimateComplexity(steps)
-+      }
-+    };
-+    
-+    this.cognitiveState.activePlan = plan;
-+    this.cognitiveState.system = 'ready';
-+    
-+    console.log(`[EmbodiedCore] 认知规划: ${steps.length} 步思维链`);
-+    return plan;
-+  }
-+
-+  /**
-+   * 目标分解
-+   */
-+  decomposeGoal(description, type, constraints, context) {
-+    const steps = [];
-+    const baseSteps = this.getBaseStepsForType(type);
-+    
-+    for (let i = 0; i < baseSteps.length; i++) {
-+      const stepType = baseSteps[i];
-+      
-+      steps.push({
-+        index: i,
-+        type: stepType,
-+        description: this.generateStepDescription(stepType, description, i),
-+        expectedOutcome: this.getExpectedOutcome(stepType),
-+        dependsOn: i > 0 ? [i - 1] : [],
-+        executor: this.selectExecutor(stepType, type),
-+        estimatedDuration: this.estimateDuration(stepType),
-+        fallback: this.getFallbackStrategy(stepType)
-+      });
-+    }
-+    
-+    return steps;
-+  }
-+
-+  /**
-+   * 获取类型的基础步骤
-+   */
-+  getBaseStepsForType(type) {
-+    const templates = {
-+      general: [
-+        this.stepTypes.OBSERVE,
-+        this.stepTypes.ANALYZE,
-+        this.stepTypes.PLAN,
-+        this.stepTypes.DECIDE,
-+        this.stepTypes.EXECUTE,
-+        this.stepTypes.REFLECT
-+      ],
-+      coding: [
-+        this.stepTypes.OBSERVE,
-+        this.stepTypes.ANALYZE,
-+        this.stepTypes.PLAN,
-+        this.stepTypes.DECIDE,
-+        this.stepTypes.EXECUTE,
-+        this.stepTypes.REFLECT,
-+        this.stepTypes.ADAPT
-+      ],
-+      debugging: [
-+        this.stepTypes.OBSERVE,
-+        this.stepTypes.ANALYZE,
-+        this.stepTypes.DECIDE,
-+        this.stepTypes.EXECUTE,
-+        this.stepTypes.REFLECT
-+      ],
-+      learning: [
-+        this.stepTypes.OBSERVE,
-+        this.stepTypes.ANALYZE,
-+        this.stepTypes.PLAN,
-+        this.stepTypes.REFLECT
-+      ],
-+      creative: [
-+        this.stepTypes.OBSERVE,
-+        this.stepTypes.ANALYZE,
-+        this.stepTypes.PLAN,
-+        this.stepTypes.DECIDE,
-+        this.stepTypes.EXECUTE,
-+        this.stepTypes.ADAPT
-+      ]
-+    };
-+    
-+    return templates[type] || templates.general;
-+  }
-+
-+  /**
-+   * 生成步骤描述
-+   */
-+  generateStepDescription(stepType, goal, index) {
-+    const templates = {
-+      [this.stepTypes.OBSERVE]: `观察当前状态和上下文`,
-+      [this.stepTypes.ANALYZE]: `分析问题：${goal}`,
-+      [this.stepTypes.PLAN]: `制定实现方案`,
-+      [this.stepTypes.DECIDE]: `选择最佳方案`,
-+      [this.stepTypes.EXECUTE]: `执行：${goal}`,
-+      [this.stepTypes.REFLECT]: `反思执行结果`,
-+      [this.stepTypes.ADAPT]: `根据反馈调整策略`
-+    };
-+    
-+    return templates[stepType] || `${stepType}: 步骤 ${index + 1}`;
-+  }
-+
-+  /**
-+   * 获取预期结果
-+   */
-+  getExpectedOutcome(stepType) {
-+    const outcomes = {
-+      [this.stepTypes.OBSERVE]: '收集到当前状态信息',
-+      [this.stepTypes.ANALYZE]: '形成问题分析报告',
-+      [this.stepTypes.PLAN]: '产出可执行计划',
-+      [this.stepTypes.DECIDE]: '确定最终方案',
-+      [this.stepTypes.EXECUTE]: '完成任务或产出',
-+      [this.stepTypes.REFLECT]: '获得改进建议',
-+      [this.stepTypes.ADAPT]: '更新执行策略'
-+    };
-+    return outcomes[stepType] || '完成步骤';
-+  }
-+
-+  /**
-+   * 选择执行器
-+   */
-+  selectExecutor(stepType, goalType) {
-+    const mapping = {
-+      [this.stepTypes.OBSERVE]: ['SelfAgent', 'code-analysis'],
-+      [this.stepTypes.ANALYZE]: ['SelfAgent', 'code-analysis'],
-+      [this.stepTypes.PLAN]: ['SelfAgent'],
-+      [this.stepTypes.DECIDE]: ['SelfAgent', 'ReflectionAgent'],
-+      [this.stepTypes.EXECUTE]: ['SelfAgent', 'code-generation'],
-+      [this.stepTypes.REFLECT]: ['ReflectionAgent', 'SelfAgent'],
-+      [this.stepTypes.ADAPT]: ['SelfAgent']
-+    };
-+    
-+    const options = mapping[stepType] || ['SelfAgent'];
-+    return options[0]; // 返回主执行器
-+  }
-+
-+  /**
-+   * 估计步骤耗时（毫秒）
-+   */
-+  estimateDuration(stepType) {
-+    const durations = {
-+      [this.stepTypes.OBSERVE]: 500,
-+      [this.stepTypes.ANALYZE]: 2000,
-+      [this.stepTypes.PLAN]: 3000,
-+      [this.stepTypes.DECIDE]: 1000,
-+      [this.stepTypes.EXECUTE]: 5000,
-+      [this.stepTypes.REFLECT]: 2000,
-+      [this.stepTypes.ADAPT]: 1500
-+    };
-+    return durations[stepType] || 2000;
-+  }
-+
-+  /**
-+   * 获取回退策略
-+   */
-+  getFallbackStrategy(stepType) {
-+    return {
-+      retry: true,
-+      timeout: this.estimateDuration(stepType) * 2,
-+      fallbackExecutor: 'SelfAgent'
-+    };
-+  }
-+
-+  /**
-+   * 估计复杂度
-+   */
-+  estimateComplexity(steps) {
-+    const baseScore = steps.length;
-+    const typeWeight = steps.filter(s => s.type === this.stepTypes.EXECUTE).length * 0.5;
-+    return Math.min(10, (baseScore + typeWeight) / 2);
-+  }
-+
-+  /**
-+   * 执行映射 - 将思维步骤映射到具体的智能体调用或工具使用
-+   * @param {object} plan - 认知计划
-+   * @param {object} context - 执行上下文
-+   * @returns {object} 执行序列
-+   */
-+  executionMapping(plan, context = {}) {
-+    this.cognitiveState.system = 'executing';
-+    
-+    const execution = {
-+      planId: plan.id,
-+      steps: [],
-+      startTime: Date.now(),
-+      context: {
-+        ...context,
-+        sensors: this.readSensors()
-+      }
-+    };
-+    
-+    for (const step of plan.steps) {
-+      const stepExecution = this.mapStepToAction(step, execution.context);
-+      execution.steps.push(stepExecution);
-+      
-+      // 更新工作记忆
-+      this.cognitiveState.workingMemory.push({
-+        step: step.index,
-+        result: stepExecution.result,
-+        timestamp: Date.now()
-+      });
-+      
-+      // 检查是否需要调整
-+      if (stepExecution.requiresAdaptation) {
-+        this.cognitiveState.system = 'adapting';
-+        const adaptation = this.adaptPlan(plan, stepExecution);
-+        execution.adaptation = adaptation;
-+        this.cognitiveState.system = 'executing';
-+      }
-+    }
-+    
-+    execution.endTime = Date.now();
-+    execution.duration = execution.endTime - execution.startTime;
-+    
-+    this.cognitiveState.executionHistory.push(execution);
-+    this.cognitiveState.system = 'idle';
-+    
-+    console.log(`[EmbodiedCore] 执行映射: ${execution.steps.length} 步执行`);
-+    return execution;
-+  }
-+
-+  /**
-+   * 读取传感器数据
-+   */
-+  readSensors() {
-+    const sensorData = {};
-+    
-+    for (const [name, adapter] of Object.entries(this.sensorAdapters)) {
-+      try {
-+        sensorData[name] = adapter.read?.() || adapter.getStatus?.() || null;
-+      } catch (e) {
-+        sensorData[name] = { error: e.message };
-+      }
-+    }
-+    
-+    return sensorData;
-+  }
-+
-+  /**
-+   * 将步骤映射到具体动作
-+   */
-+  mapStepToAction(step, context) {
-+    const executorName = step.executor;
-+    const executor = this.executors[executorName];
-+    
-+    const action = {
-+      stepIndex: step.index,
-+      stepType: step.type,
-+      executor: executorName,
-+      executorType: executor?.type || 'unknown',
-+      parameters: this.buildParameters(step, context),
-+      expectedDuration: step.estimatedDuration
-+    };
-+    
-+    // 模拟执行（实际会调用智能体/工具）
-+    action.result = this.simulateExecution(action, context);
-+    action.requiresAdaptation = this.checkAdaptationNeed(action.result, step);
-+    
-+    return action;
-+  }
-+
-+  /**
-+   * 构建参数
-+   */
-+  buildParameters(step, context) {
-+    return {
-+      task: step.description,
-+      context: {
-+        workingMemory: context.sensors,
-+        previousResults: this.cognitiveState.workingMemory.slice(-3)
-+      },
-+      constraints: {
-+        timeout: step.estimatedDuration,
-+        fallback: step.fallback
-+      }
-+    };
-+  }
-+
-+  /**
-+   * 模拟执行
-+   */
-+  simulateExecution(action, context) {
-+    // 这里模拟实际执行结果
-+    // 实际实现会调用真实的智能体
-+    
-+    const mockResults = {
-+      [this.stepTypes.OBSERVE]: { observations: ['当前状态良好', '环境稳定'] },
-+      [this.stepTypes.ANALYZE]: { analysis: '问题已识别', 'confidence': 0.85 },
-+      [this.stepTypes.PLAN]: { plan: '方案已制定', 'alternatives': 2 },
-+      [this.stepTypes.DECIDE]: { decision: '选择方案A', 'reason': '最优' },
-+      [this.stepTypes.EXECUTE]: { outcome: '完成', 'success': true },
-+      [this.stepTypes.REFLECT]: { feedback: '执行顺利', 'improvements': [] },
-+      [this.stepTypes.ADAPT]: { adapted: true, 'changes': [] }
-+    };
-+    
-+    return {
-+      ...mockResults[action.stepType],
-+      timestamp: Date.now()
-+    };
-+  }
-+
-+  /**
-+   * 检查是否需要调整
-+   */
-+  checkAdaptationNeed(result, step) {
-+    // 简单规则：执行失败或分析不充分时需要调整
-+    if (result.success === false) return true;
-+    if (result.confidence && result.confidence < 0.6) return true;
-+    return false;
-+  }
-+
-+  /**
-+   * 调整计划
-+   */
-+  adaptPlan(plan, failedStep) {
-+    const adaptation = {
-+      originalStep: failedStep.stepIndex,
-+      reason: '执行结果不理想',
-+      modifications: []
-+    };
-+    
-+    // 添加额外的反思和调整步骤
-+    const newSteps = plan.steps.slice(failedStep.stepIndex);
-+    newSteps.unshift({
-+      index: failedStep.stepIndex,
-+      type: this.stepTypes.ADAPT,
-+      description: '调整策略后重试',
-+      executor: 'SelfAgent'
-+    });
-+    
-+    adaptation.modifications = newSteps;
-+    console.log(`[EmbodiedCore] 计划调整: 步骤 ${failedStep.stepIndex} 需要重试`);
-+    
-+    return adaptation;
-+  }
-+
-+  /**
-+   * 获取认知状态
-+   */
-+  getStatus() {
-+    return {
-+      cognitiveState: this.cognitiveState.system,
-+      activePlan: this.cognitiveState.activePlan?.id || null,
-+      executionHistoryCount: this.cognitiveState.executionHistory.length,
-+      workingMemorySize: this.cognitiveState.workingMemory.length,
-+      registeredSensors: Object.keys(this.sensorAdapters),
-+      availableExecutors: Object.keys(this.executors)
-+    };
-+  }
-+
-+  /**
-+   * 重置状态
-+   */
-+  reset() {
-+    this.cognitiveState = {
-+      system: 'idle',
-+      activePlan: null,
-+      executionHistory: [],
-+      workingMemory: []
-+    };
-+    console.log('[EmbodiedCore] 状态已重置');
-+    return { success: true };
-+  }
-+}
-+
-+module.exports = { EmbodiedCore };
-

package/patches/goedel-engine-v2.2.2.patch

@@ -1,161 +0,0 @@
-diff --git a/src/core/self-evolution/goedel-engine.js b/src/core/self-evolution/goedel-engine.js
-index 128b4d2..067a893 100644
---- a/src/core/self-evolution/goedel-engine.js
-+++ b/src/core/self-evolution/goedel-engine.js
-@@ -530,6 +530,156 @@ class GoedelEngine {
-     }
-     return [];
-   }
-+
-+  /**
-+   * 原则性反思 (Principle-Based Reflect)
-+   * 基于核心价值观进行深度反思，评估当前行为是否符合长期原则
-+   */
-+  async principleBasedReflect(context = {}) {
-+    const reflection = {
-+      timestamp: new Date().toISOString(),
-+      type: 'principle_based',
-+      principles: [],
-+      alignment: [],
-+      recommendations: []
-+    };
-+
-+    const coreValues = this.loadCoreValues();
-+    if (!coreValues) {
-+      reflection.principles.push({ principle: '无约束原则', status: 'neutral' });
-+      return reflection;
-+    }
-+
-+    const principles = this.extractPrinciples(coreValues);
-+    reflection.principles = principles;
-+
-+    const recentVersions = this.getVersionHistory().slice(-5);
-+    for (const version of recentVersions) {
-+      const alignmentScore = this.evaluatePrincipleAlignment(version, principles);
-+      reflection.alignment.push({
-+        version: version.id,
-+        score: alignmentScore,
-+        timestamp: version.timestamp
-+      });
-+    }
-+
-+    const avgAlignment = reflection.alignment.reduce((a, b) => a + b.score, 0) / 
-+      (reflection.alignment.length || 1);
-+
-+    if (avgAlignment < 0.7) {
-+      reflection.recommendations.push({
-+        type: 'principle_drift',
-+        message: '检测到原则偏离，建议加强价值观锚定',
-+        priority: 'high'
-+      });
-+    }
-+
-+    this.log(`Principle-based reflection complete: avg alignment ${avgAlignment.toFixed(2)}`);
-+    return reflection;
-+  }
-+
-+  extractPrinciples(coreValues) {
-+    const principles = [];
-+    const lines = coreValues.split('\n');
-+    
-+    for (const line of lines) {
-+      if (line.includes(':') || line.includes('—') || line.includes('-')) {
-+        const principle = line.replace(/^[#\-\s]*/, '').trim();
-+        if (principle.length > 3 && principle.length < 100) {
-+          principles.push({
-+            principle: principle,
-+            source: 'CORE_VALUES.md'
-+          });
-+        }
-+      }
-+    }
-+
-+    return principles.length > 0 ? principles : [
-+      { principle: '用户利益优先', source: 'default' },
-+      { principle: '持续学习和进化', source: 'default' },
-+      { principle: '透明和诚实', source: 'default' }
-+    ];
-+  }
-+
-+  evaluatePrincipleAlignment(version, principles) {
-+    const description = version.proposal?.toLowerCase() || '';
-+    const positiveWords = ['优化', '改善', '提升', '帮助', 'improve', 'help', 'enhance'];
-+    const negativeWords = ['破坏', '伤害', '欺骗', 'harm', 'deceive', 'damage'];
-+    
-+    let score = 0.5;
-+    
-+    for (const word of positiveWords) {
-+      if (description.includes(word)) score += 0.1;
-+    }
-+    for (const word of negativeWords) {
-+      if (description.includes(word)) score -= 0.2;
-+    }
-+
-+    return Math.max(0, Math.min(1, score));
-+  }
-+
-+  /**
-+   * 过程性反思 (Procedural Reflect)
-+   * 反思进化过程本身的有效性，识别改进空间
-+   */
-+  async proceduralReflect(context = {}) {
-+    const reflection = {
-+      timestamp: new Date().toISOString(),
-+      type: 'procedural',
-+      processMetrics: {},
-+      inefficiencies: [],
-+      optimizations: []
-+    };
-+
-+    const history = this.getVersionHistory();
-+    const recentHistory = history.slice(-10);
-+
-+    reflection.processMetrics = {
-+      totalEvolutions: history.length,
-+      recentEvolutions: recentHistory.length,
-+      avgTimeBetweenEvolutions: this.calculateAvgTimeBetween(recentHistory),
-+      successRate: recentHistory.filter(v => v.id).length / (recentHistory.length || 1)
-+    };
-+
-+    if (reflection.processMetrics.avgTimeBetweenEvolutions < 60000) {
-+      reflection.inefficiencies.push({
-+        issue: '进化频率过高',
-+        detail: '平均间隔不足1分钟，可能缺乏充分评估'
-+      });
-+    }
-+
-+    const codeMapVersion = this.codeMap?.version || 'unknown';
-+    if (codeMapVersion === '1.0.0') {
-+      reflection.optimizations.push({
-+        suggestion: '更新代码映射版本以反映最新架构',
-+        benefit: '提高自我分析准确性'
-+      });
-+    }
-+
-+    const sageStatus = this.sageGuardian?.getStatus?.() || {};
-+    if (sageStatus.cooldownActive) {
-+      reflection.inefficiencies.push({
-+        issue: 'SAGEGuardian 冷却期激活',
-+        detail: '伦理审查可能成为瓶颈'
-+      });
-+    }
-+
-+    this.log(`Procedural reflection complete: ${reflection.inefficiencies.length} inefficiencies found`);
-+    return reflection;
-+  }
-+
-+  calculateAvgTimeBetween(versions) {
-+    if (versions.length < 2) return 0;
-+    
-+    let totalDiff = 0;
-+    for (let i = 1; i < versions.length; i++) {
-+      const t1 = new Date(versions[i-1].timestamp);
-+      const t2 = new Date(versions[i].timestamp);
-+      totalDiff += (t2 - t1);
-+    }
-+    
-+    return totalDiff / (versions.length - 1);
-+  }
- }
- 
- module.exports = { GoedelEngine };