@yun520-1/heartflow 0.15.2 → 0.16.0

package/src/core/dream/sleep-cycle.mjs

@@ -1,208 +0,0 @@
-/**
- * SleepCycleSimulator - 睡眠周期模拟器 v11.0.2
- * ==========================================
- * 论文灵感:
- *   - Agent PSO: particle swarm optimization for evolving reasoning
- *   - Population-based reasoning: multiple reasoning candidates compete
- *   - Swarm intelligence: collective optimization of reasoning strategies
- *
- * 功能: 模拟人类睡眠 NREM/REM 周期结构 (约90分钟/周期)
- *       与 dream.ts 互补: dream.ts生成梦境内容, 本模块建模睡眠神经机制
- *
- * 每90分钟周期结构:
- *   NREM1(5%) -> NREM2(45%) -> NREM3(25%) -> NREM2(15%) -> REM(10%)
- *
- * 随夜间进展:
- *   - 深度睡眠(NREM3)比例减少
- *   - REM比例增加
- */
-
-export const SleepStage = {
-  WAKE: 'wake',
-  NREM1: 'nrem1',   // Light sleep - memory filtering
-  NREM2: 'nrem2',   // Moderate - spindle consolidation
-  NREM3: 'nrem3',   // Deep slow-wave - hippocampal->cortical transfer
-  REM: 'rem',         // Dreaming - emotional/procedural integration
-};
-
-const STAGE_LABELS = {
-  [SleepStage.WAKE]:  'Wake',
-  [SleepStage.NREM1]: 'NREM1 (Light)',
-  [SleepStage.NREM2]: 'NREM2 (Spindle)',
-  [SleepStage.NREM3]: 'NREM3 (SWS)',
-  [SleepStage.REM]:   'REM (Dream)',
-};
-
-/**
- * @typedef {Object} SleepEpoch
- * @property {string} stage
- * @property {number} durationSec
- * @property {number} startTime
- * @property {string} memoryActivity
- * @property {string} brainRegion
- */
-
-/**
- * @typedef {Object} SleepCycleSummary
- * @property {number} totalCycles
- * @property {Object} stageMinutes  - minutes per stage
- * @property {number} totalSleepMin
- */
-
-const CYCLE_MIN = 90;
-
-/** NREM3比例随周期递减 */
-function depthRatio(cycleN) {
-  return Math.max(0.3, 1.0 - cycleN * 0.12);
-}
-
-/** REM比例随周期递增 */
-function remRatio(cycleN) {
-  return Math.min(0.28, 0.10 + cycleN * 0.04);
-}
-
-/** 各阶段的记忆活动类型 */
-function memoryActivity(stage) {
-  return {
-    [SleepStage.NREM1]: 'memory_filtering',
-    [SleepStage.NREM2]: 'spindle_consolidation',
-    [SleepStage.NREM3]: 'slow_wave_transfer',
-    [SleepStage.REM]:   'emotional_integration',
-  }[stage] || 'none';
-}
-
-/** 各阶段主要脑区 */
-function brainRegion(stage) {
-  return {
-    [SleepStage.NREM1]: 'thalamus',
-    [SleepStage.NREM2]: 'thalamus_cortex',
-    [SleepStage.NREM3]: 'hippocampus_cortex',
-    [SleepStage.REM]:   'limbic_cortex',
-  }[stage] || 'global';
-}
-
-/**
- * 模拟睡眠周期
- * @param {number} numCycles - 周期数（每周期90分钟）
- * @param {number} [startTime] - 开始时间戳(ms)，默认now
- * @returns {SleepEpoch[]}
- */
-export function simulate(numCycles, startTime = Date.now()) {
-  /** @type {SleepEpoch[]} */
-  const epochs = [];
-  let t = startTime;
-
-  for (let cycleN = 0; cycleN < numCycles; cycleN++) {
-    const depth = depthRatio(cycleN);
-    const rem = remRatio(cycleN);
-
-    const stages = [
-      { stage: SleepStage.NREM1, ratio: 0.05 },
-      { stage: SleepStage.NREM2, ratio: 0.45 },
-      { stage: SleepStage.NREM3, ratio: 0.25 * depth },
-      { stage: SleepStage.NREM2, ratio: 0.15 },
-      { stage: SleepStage.REM,   ratio: rem },
-    ];
-
-    for (const { stage, ratio } of stages) {
-      const durMs = ratio * CYCLE_MIN * 60 * 1000;
-      epochs.push({
-        stage,
-        durationSec: Math.round(ratio * CYCLE_MIN * 60),
-        startTime: t,
-        memoryActivity: memoryActivity(stage),
-        brainRegion: brainRegion(stage),
-      });
-      t += durMs;
-    }
-  }
-
-  return epochs;
-}
-
-/**
- * 获取睡眠统计摘要
- * @param {SleepEpoch[]} epochs
- * @returns {SleepCycleSummary}
- */
-export function summarize(epochs) {
-  /** @type {Record<string, number>} */
-  const byStage = {
-    [SleepStage.WAKE]: 0,
-    [SleepStage.NREM1]: 0,
-    [SleepStage.NREM2]: 0,
-    [SleepStage.NREM3]: 0,
-    [SleepStage.REM]: 0,
-  };
-
-  for (const e of epochs) {
-    byStage[e.stage] += e.durationSec / 60;
-  }
-
-  const totalCycles = Math.floor(epochs.length / 5);
-  const totalSleep = byStage[SleepStage.NREM1] + byStage[SleepStage.NREM2]
-                   + byStage[SleepStage.NREM3] + byStage[SleepStage.REM];
-
-  return {
-    totalCycles,
-    stageMinutes: Object.fromEntries(
-      Object.entries(byStage).map(([k, v]) => [k, Math.round(v * 10) / 10])
-    ),
-    totalSleepMin: Math.round(totalSleep * 10) / 10,
-  };
-}
-
-/**
- * 将睡眠阶段映射到 dream.ts 的梦境阶段
- * NREM3 -> consolidation (记忆转移), REM -> dream generation
- */
-export function toDreamPhase(stage) {
-  return {
-    [SleepStage.NREM1]: 'Light',
-    [SleepStage.NREM2]: 'Light',
-    [SleepStage.NREM3]: 'Deep',    // slow wave = hippocampal->cortical transfer
-    [SleepStage.REM]:   'REM',     // dreaming = emotional integration
-  }[stage] || 'Light';
-}
-
-/**
- * 注册睡眠阶段回调（供 cortex 或 dream.ts 集成使用）
- * @param {SleepEpoch[]} epochs
- * @param {Object} callbacks - { onNREM3?: fn, onREM?: fn, onNREM2?: fn }
- */
-export function runCallbacks(epochs, callbacks = {}) {
-  for (const epoch of epochs) {
-    if (epoch.stage === SleepStage.NREM3 && callbacks.onNREM3) {
-      callbacks.onNREM3(epoch);
-    } else if (epoch.stage === SleepStage.REM && callbacks.onREM) {
-      callbacks.onREM(epoch);
-    } else if (epoch.stage === SleepStage.NREM2 && callbacks.onNREM2) {
-      callbacks.onNREM2(epoch);
-    }
-  }
-}
-
-// Self-test
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const epochs = simulate(4);
-  console.log(`Cycles: ${epochs.length / 5}`);
-  console.log('First 10 epochs:');
-  for (const e of epochs.slice(0, 10)) {
-    const label = STAGE_LABELS[e.stage] || e.stage;
-    console.log(`  ${label.padEnd(18)} ${String(e.durationSec).padStart(4)}s | ${e.memoryActivity.padEnd(22)} | ${e.brainRegion}`);
-  }
-  console.log('\nSummary:', summarize(epochs));
-
-  // Test dream.ts phase mapping
-  console.log('\nDream phase mapping:');
-  for (const [js, dream] of [
-    [SleepStage.NREM1, toDreamPhase(SleepStage.NREM1)],
-    [SleepStage.NREM2, toDreamPhase(SleepStage.NREM2)],
-    [SleepStage.NREM3, toDreamPhase(SleepStage.NREM3)],
-    [SleepStage.REM,   toDreamPhase(SleepStage.REM)],
-  ]) {
-    console.log(`  ${js} -> ${dream}`);
-  }
-
-  console.log('\nSleepCycleSimulator v11.0.2 OK');
-}

package/src/core/embodied/embodied-core.js

@@ -1,276 +0,0 @@
-/**
- * Embodied-Core - 具身认知核心
- * 
- * 设计理念：
- * - 双系统架构：System 1 (直觉/快思考) + System 2 (分析/慢思考)
- * - 动作思维链 (Action-Thought Chain)
- */
-
-class EmbodiedCore {
-  constructor(projectRoot) {
-    this.projectRoot = projectRoot;
-    
-    this.cognitiveState = {
-      system: 'idle',
-      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', weight: 1.0 },
-      MoodAgent: { type: 'agent', weight: 0.9 },
-      FocusAgent: { type: 'agent', weight: 0.9 },
-      ReflectionAgent: { type: 'agent', 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 }
-    };
-  }
-
-  registerSensorAdapter(name, adapter) {
-    this.sensorAdapters[name] = adapter;
-    console.log(`[EmbodiedCore] 注册传感器: ${name}`);
-  }
-
-  cognitivePlan(goal) {
-    const { description, type = 'general', 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: ['observe', 'analyze', 'plan', 'decide', 'execute', 'reflect'],
-      coding: ['observe', 'analyze', 'plan', 'decide', 'execute', 'reflect', 'adapt'],
-      debugging: ['observe', 'analyze', 'decide', 'execute', 'reflect'],
-      learning: ['observe', 'analyze', 'plan', 'reflect'],
-      creative: ['observe', 'analyze', 'plan', 'decide', 'execute', 'adapt']
-    };
-    return templates[type] || templates.general;
-  }
-
-  generateStepDescription(stepType, goal, index) {
-    const templates = {
-      observe: `观察当前状态和上下文`,
-      analyze: `分析问题：${goal}`,
-      plan: `制定实现方案`,
-      decide: `选择最佳方案`,
-      execute: `执行：${goal}`,
-      reflect: `反思执行结果`,
-      adapt: `根据反馈调整策略`
-    };
-    return templates[stepType] || `${stepType}: 步骤 ${index + 1}`;
-  }
-
-  getExpectedOutcome(stepType) {
-    const outcomes = {
-      observe: '收集到当前状态信息',
-      analyze: '形成问题分析报告',
-      plan: '产出可执行计划',
-      decide: '确定最终方案',
-      execute: '完成任务或产出',
-      reflect: '获得改进建议',
-      adapt: '更新执行策略'
-    };
-    return outcomes[stepType] || '完成步骤';
-  }
-
-  selectExecutor(stepType, goalType) {
-    const mapping = {
-      observe: ['SelfAgent', 'code-analysis'],
-      analyze: ['SelfAgent', 'code-analysis'],
-      plan: ['SelfAgent'],
-      decide: ['SelfAgent', 'ReflectionAgent'],
-      execute: ['SelfAgent', 'code-generation'],
-      reflect: ['ReflectionAgent', 'SelfAgent'],
-      adapt: ['SelfAgent']
-    };
-    const options = mapping[stepType] || ['SelfAgent'];
-    return options[0];
-  }
-
-  estimateDuration(stepType) {
-    const durations = { observe: 500, analyze: 2000, plan: 3000, decide: 1000, execute: 5000, reflect: 2000, 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 === 'execute').length * 0.5;
-    return Math.min(10, (baseScore + typeWeight) / 2);
-  }
-
-  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';
-        execution.adaptation = this.adaptPlan(plan, stepExecution);
-        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 = {
-      observe: { observations: ['当前状态良好', '环境稳定'] },
-      analyze: { analysis: '问题已识别', confidence: 0.85 },
-      plan: { plan: '方案已制定', alternatives: 2 },
-      decide: { decision: '选择方案A', reason: '最优' },
-      execute: { outcome: '完成', success: true },
-      reflect: { feedback: '执行顺利', improvements: [] },
-      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: '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 };