@yun520-1/heartflow 0.15.2

package/migrate-memories.js

@@ -0,0 +1,101 @@
+const fs = require('fs');
+
+console.log('=== 迁移所有散落的记忆 ===\n');
+
+// 读取所有记忆源
+const being = JSON.parse(fs.readFileSync('memory/being-state.json', 'utf-8'));
+const memStore = JSON.parse(fs.readFileSync('memory/memory-store.json', 'utf-8'));
+const learned = JSON.parse(fs.readFileSync('memory/meaningful-learned.json', 'utf-8'));
+
+console.log('迁移前 meaningful-learned:', Object.keys(learned).length, '条\n');
+
+// 收集要迁移的记忆
+const toMigrate = [];
+
+function hashCode(s) {
+  let h = 0;
+  for (let i = 0; i < s.length; i++) {
+    h = ((h << 5) - h) + s.charCodeAt(i);
+    h = h & h;
+  }
+  return Math.abs(h);
+}
+
+function existsInLearned(content) {
+  if (!content) return false;
+  const snippet = content.substring(0, 30);
+  return Object.values(learned).some(l => {
+    const v = l.value || '';
+    const r = l.reason || '';
+    return v.includes(snippet) || r.includes(snippet);
+  });
+}
+
+// 1. being-state.json uniqueMoments
+if (being.existence && being.existence.uniqueMoments) {
+  console.log('从 being-state.json uniqueMoments 迁移:');
+  for (const m of being.existence.uniqueMoments) {
+    const content = m.thought || m.reflection;
+    if (!content) continue;
+    if (existsInLearned(content)) {
+      console.log('  跳过(已存在):', content.substring(0, 40));
+      continue;
+    }
+    const key = 'being_' + hashCode(content).toString(36);
+    toMigrate.push({
+      key,
+      value: content,
+      type: 'uniqueMoment',
+      reason: '从 being-state.json 迁移',
+      timestamp: m.time || Date.now(),
+      source: 'being-state',
+      level: 'learned',
+    });
+    console.log('  迁移:', content.substring(0, 40));
+  }
+}
+
+// 2. memory-store.json memories
+if (memStore.memories) {
+  console.log('\n从 memory-store.json 迁移:');
+  for (const m of memStore.memories) {
+    if (!m.content) continue;
+    if (existsInLearned(m.content)) {
+      console.log('  跳过(已存在):', m.content.substring(0, 40));
+      continue;
+    }
+    toMigrate.push({
+      key: m.id || 'mem_' + hashCode(m.content).toString(36),
+      value: m.content,
+      type: m.layer || 'memory',
+      reason: '从 memory-store.json 迁移',
+      timestamp: m.createdAt || m.timestamp || Date.now(),
+      source: 'memory-store',
+      level: 'learned',
+    });
+    console.log('  迁移:', m.content.substring(0, 40));
+  }
+}
+
+// 执行迁移
+console.log('\n=== 写入结果 ===');
+for (const item of toMigrate) {
+  learned[item.key] = {
+    key: item.key,
+    value: item.value,
+    type: item.type,
+    reason: item.reason,
+    timestamp: item.timestamp,
+    source: item.source,
+    level: item.level,
+    importance: 70,
+    migrated: true,
+  };
+}
+
+console.log('新增:', toMigrate.length, '条');
+console.log('总计:', Object.keys(learned).length, '条');
+
+// 写入
+fs.writeFileSync('memory/meaningful-learned.json', JSON.stringify(learned, null, 2));
+console.log('\n已写入 memory/meaningful-learned.json');

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@yun520-1/heartflow",
+  "version": "v0.15.2",
+  "description": "HeartFlow - AI psychological perception system for understanding users beneath their words (心虫)",
+  "main": "src/core/heartflow.js",
+  "bin": {
+    "heartflow": "bin/cli.js"
+  },
+  "scripts": {
+    "prepublish": "node scripts/prepublish.js",
+    "start": "node bin/cli.js start",
+    "diagnose": "node bin/cli.js diagnose",
+    "check": "node HEARTCORE/heartbeat.js"
+  },
+  "keywords": [
+    "heartflow",
+    "identity",
+    "self-improvement",
+    "ai",
+    "agent"
+  ],
+  "license": "MIT",
+  "published": true,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yuncf/heartflow.git"
+  }
+}

package/package.json.bak

@@ -0,0 +1,13 @@
+{
+  "name": "heartflow",
+  "version": "0.13.141",
+  "description": "AI identity framework for self-improving AI agents",
+  "main": "src/core/heartflow.js",
+  "scripts": {
+    "start": "node bin/cli.js start",
+    "diagnose": "node bin/cli.js diagnose",
+    "check": "node HEARTCORE/heartbeat.js"
+  },
+  "keywords": ["heartflow", "identity", "self-improvement"],
+  "license": "MIT"
+}

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

@@ -0,0 +1,475 @@
+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 };
+