@yun520-1/heartflow 0.15.2 → 0.16.0

package/src/core/papers/papers-index.js

@@ -1,344 +0,0 @@
-/**
- * HeartFlow Papers Index — v11.0.137+
- * Node.js bridge to Python paper-upgrade modules.
- *
- * Exposes all Python modules as JS classes/proxy objects,
- * callable from TypeScript/JS without any changes to source files.
- *
- * Usage:
- *   const { DreamGenerator, SleepCycleSimulator, MemoryConsolidator,
- *           EpisodicMemory, EmotionMemoryBridge, ReflectionEngine,
- *           MemoryPlanner, AttentionLogicVerifier } = require('./papers-index');
- *
- *   const dream = new DreamGenerator({ model: 'gpt-4' });
- *   const result = dream.generate DreamCycle(insights);
- */
-
-const { spawnSync } = require('child_process');
-const path = require('path');
-
-// Papers src directory
-const PAPERS_DIR = __dirname;
-
-// Supported modules
-const MODULES = {
-  DreamGenerator:          'dream_generator',
-  SleepCycleSimulator:     'sleep_cycle_simulator',
-  MemoryConsolidator:      'memory_consolidator',
-  EpisodicMemory:          'episodic_memory',
-  EmotionMemoryBridge:      'emotion_memory_bridge',
-  ReflectionEngine:         'reflection_engine',
-  MemoryPlanner:            'memory_planner',
-  AttentionLogicVerifier:  'attention_logic_verifier',
-};
-
-// Function name mapping: JS name -> Python name
-const PYTHON_FN_MAP = {
-  // dream_generator
-  'generate_dream_cycle': 'generate_dream',
-  // sleep_cycle_simulator
-  'simulate_sleep_cycle': 'simulate',
-  // memory_consolidator
-  'consolidate_memories': 'consolidate',
-  // episodic_memory
-  'store_episode': 'add',
-  'retrieve_episodes': 'retrieve',
-  // emotion_memory_bridge
-  'bridge_emotion_memory': 'bridge',
-  // reflection_engine
-  'generate_reflection': 'reflect',
-  // memory_planner
-  'create_memory_plan': 'generate_from_memories',
-  // attention_logic_verifier
-  'verify_attention_logic': 'verify',
-};
-
-/**
- * Call a Python function inside a module.
- * @param {string} moduleName  - e.g. 'dream_generator'
- * @param {string} functionName - e.g. 'generate_dream'
- * @param {string} jsonArgs   - JSON.stringify(args)
- * @returns {object} parsed result
- */
-function callPython(moduleName, functionName, jsonArgs = '[]') {
-  const modulePath = path.join(PAPERS_DIR, `${moduleName}.py`);
-  // Resolve actual Python function name
-  const pyFn = PYTHON_FN_MAP[functionName] || functionName;
-  const code = `
-import sys, json
-sys.path.insert(0, ${JSON.stringify(PAPERS_DIR)});
-try:
-    from ${moduleName} import ${pyFn}
-    args = json.loads(${JSON.stringify(jsonArgs)})
-    result = ${pyFn}(*args) if isinstance(args, list) else ${pyFn}(**args)
-    # Serialize dataclass/dict results to JSON-safe format
-    if hasattr(result, '__dict__'):
-        result = {k: v for k, v in result.__dict__.items() if not k.startswith('_')}
-    print(json.dumps(result, ensure_ascii=False, default=str))
-except Exception as e:
-    print(json.dumps({"__error__": str(e)}), file=sys.stderr)
-    sys.exit(1)
-`;
-  const py = process.env.PYTHON_PATH || 'python3';
-  const child = spawnSync(py, ['-c', code], {
-    encoding: 'utf8',
-    timeout: 30000,
-    maxBuffer: 10 * 1024 * 1024,
-  });
-  if (child.status !== 0 || !child.stdout.trim()) {
-    const err = (child.stderr || '').trim() || 'No output';
-    throw new Error(`[${moduleName}.${functionName}->${pyFn}] ${err}`);
-  }
-  const result = JSON.parse(child.stdout.trim());
-  if (result && result.__error__) {
-    throw new Error(`[${moduleName}.${functionName}->${pyFn}] ${result.__error__}`);
-  }
-  return result;
-}
-
-/**
- * Probe/exercise a Python module — syntax check + import + basic instantiation.
- * Returns { ok, lines, fnName, output, error }
- * @param {string} moduleName
- * @returns {{ ok: boolean, error?: string, lines?: number, output?: string }}
- */
-function probeModule(moduleName) {
-  const modulePath = path.join(PAPERS_DIR, `${moduleName}.py`);
-  const py = process.env.PYTHON_PATH || 'python3';
-
-  // Step 1: syntax check
-  const syntaxChild = spawnSync(py, [
-    '-c',
-    `import ast; ast.parse(open(${JSON.stringify(modulePath)}).read()); print('OK')`
-  ], { encoding: 'utf8', timeout: 10000 });
-  if (syntaxChild.status !== 0) {
-    return { ok: false, error: 'Syntax error: ' + ((syntaxChild.stderr || '').slice(0, 150)) };
-  }
-
-  // Step 2: try importing the module and instantiating its main class
-  const mainClassMap = {
-    'dream_generator':          'DreamGenerator',
-    'sleep_cycle_simulator':    'SleepCycleSimulator',
-    'memory_consolidator':     'MemoryConsolidator',
-    'episodic_memory':          'EpisodicMemory',
-    'emotion_memory_bridge':    'EmotionMemoryBridge',
-    'reflection_engine':        'ReflectionEngine',
-    'memory_planner':           'MemoryPlanner',
-    'attention_logic_verifier': 'AttentionLogicVerifier',
-  };
-  const className = mainClassMap[moduleName];
-
-  if (className) {
-    const importCode = `
-import sys, json
-sys.path.insert(0, ${JSON.stringify(PAPERS_DIR)})
-try:
-    mod = __import__(${JSON.stringify(moduleName)})
-    cls = getattr(mod, ${JSON.stringify(className)})
-    instance = cls()
-    # Call the main entry point to verify it actually runs
-    if hasattr(instance, 'probe') or hasattr(instance, 'get_summary'):
-        probe_fn = getattr(instance, 'probe', None) or getattr(instance, 'get_summary', None)
-        result = probe_fn() if callable(probe_fn) else None
-        print(json.dumps({"status": "ok", "result": result}, default=str))
-    else:
-        print(json.dumps({"status": "ok", "result": None}))
-except Exception as e:
-    import traceback
-    print(json.dumps({"status": "error", "error": str(e), "trace": traceback.format_exc()[-300:]}), file=sys.stderr)
-    sys.exit(1)
-`;
-    const importChild = spawnSync(py, ['-c', importCode], { encoding: 'utf8', timeout: 15000 });
-    if (importChild.status !== 0) {
-      return { ok: false, error: 'Import/instantiate failed: ' + ((importChild.stderr || '').slice(0, 200)) };
-    }
-    try {
-      const parsed = JSON.parse(importChild.stdout.trim());
-      if (parsed.status === 'error') {
-        return { ok: false, error: parsed.error + (parsed.trace ? ' | ' + parsed.trace : '') };
-      }
-    } catch (_) {
-      // non-JSON output is OK — means the module ran
-    }
-  }
-
-  const lineCount = spawnSync('wc', ['-l', modulePath], { encoding: 'utf8' }).stdout.trim();
-  return { ok: true, lines: parseInt(lineCount, 10) || 0 };
-}
-
-// ---- DreamGenerator ----
-class DreamGenerator {
-  constructor(config = {}) {
-    this.config = {
-      model: config.model || 'gpt-4',
-      temperature: config.temperature || 0.8,
-      maxScenes: config.maxScenes || 4,
-      creativityBias: config.creativityBias || 0.6,
-    };
-    this._module = 'dream_generator';
-  }
-
-  generateDreamCycle(insights, options = {}) {
-    return callPython(this._module, 'generate_dream_cycle', JSON.stringify([
-      insights,
-      { ...this.config, ...options }
-    ]));
-  }
-
-  probe() { return probeModule(this._module); }
-}
-
-// ---- SleepCycleSimulator ----
-class SleepCycleSimulator {
-  constructor(config = {}) {
-    this.config = {
-      cycleCount: config.cycleCount || 5,
-      phaseDuration: config.phaseDuration || 90,
-    };
-    this._module = 'sleep_cycle_simulator';
-  }
-
-  simulate(insights, options = {}) {
-    return callPython(this._module, 'simulate_sleep_cycle', JSON.stringify([
-      insights,
-      { ...this.config, ...options }
-    ]));
-  }
-
-  probe() { return probeModule(this._module); }
-}
-
-// ---- MemoryConsolidator ----
-class MemoryConsolidator {
-  constructor(config = {}) {
-    this.config = {
-      memoryType: config.memoryType || 'episodic',
-      retentionBoost: config.retentionBoost || 0.2,
-    };
-    this._module = 'memory_consolidator';
-  }
-
-  consolidate(insights, options = {}) {
-    return callPython(this._module, 'consolidate_memories', JSON.stringify([
-      insights,
-      { ...this.config, ...options }
-    ]));
-  }
-
-  probe() { return probeModule(this._module); }
-}
-
-// ---- EpisodicMemory ----
-class EpisodicMemory {
-  constructor(config = {}) {
-    this.config = {
-      maxEvents: config.maxEvents || 100,
-      decayRate: config.decayRate || 0.05,
-    };
-    this._module = 'episodic_memory';
-  }
-
-  store(event, options = {}) {
-    return callPython(this._module, 'store_episode', JSON.stringify([
-      event,
-      { ...this.config, ...options }
-    ]));
-  }
-
-  retrieve(query, options = {}) {
-    return callPython(this._module, 'retrieve_episodes', JSON.stringify([
-      query,
-      { ...this.config, ...options }
-    ]));
-  }
-
-  probe() { return probeModule(this._module); }
-}
-
-// ---- EmotionMemoryBridge ----
-class EmotionMemoryBridge {
-  constructor(config = {}) {
-    this.config = config;
-    this._module = 'emotion_memory_bridge';
-  }
-
-  bridge(emotionState, memoryContent, options = {}) {
-    return callPython(this._module, 'bridge_emotion_memory', JSON.stringify([
-      emotionState, memoryContent, { ...this.config, ...options }
-    ]));
-  }
-
-  probe() { return probeModule(this._module); }
-}
-
-// ---- ReflectionEngine ----
-class ReflectionEngine {
-  constructor(config = {}) {
-    this.config = config;
-    this._module = 'reflection_engine';
-  }
-
-  reflect(insights, options = {}) {
-    return callPython(this._module, 'generate_reflection', JSON.stringify([
-      insights, { ...this.config, ...options }
-    ]));
-  }
-
-  probe() { return probeModule(this._module); }
-}
-
-// ---- MemoryPlanner ----
-class MemoryPlanner {
-  constructor(config = {}) {
-    this.config = config;
-    this._module = 'memory_planner';
-  }
-
-  plan(goal, memories, options = {}) {
-    return callPython(this._module, 'create_memory_plan', JSON.stringify([
-      goal, memories, { ...this.config, ...options }
-    ]));
-  }
-
-  probe() { return probeModule(this._module); }
-}
-
-// ---- AttentionLogicVerifier ----
-class AttentionLogicVerifier {
-  constructor(config = {}) {
-    this.config = config;
-    this._module = 'attention_logic_verifier';
-  }
-
-  verify(content, options = {}) {
-    return callPython(this._module, 'verify_attention_logic', JSON.stringify([
-      content, { ...this.config, ...options }
-    ]));
-  }
-
-  probe() { return probeModule(this._module); }
-}
-
-// ---- Probe all modules ----
-function probeAll() {
-  const results = {};
-  for (const [jsName, pyName] of Object.entries(MODULES)) {
-    results[pyName] = probeModule(pyName);
-  }
-  return results;
-}
-
-module.exports = {
-  MODULES,
-  callPython,
-  probeModule,
-  probeAll,
-  DreamGenerator,
-  SleepCycleSimulator,
-  MemoryConsolidator,
-  EpisodicMemory,
-  EmotionMemoryBridge,
-  ReflectionEngine,
-  MemoryPlanner,
-  AttentionLogicVerifier,
-};

package/src/core/papers/reflection_engine.py

@@ -1,219 +0,0 @@
-"""
-ReflectionEngine - 自我反思引擎
-==============================
-论文: 2304.03442 (Reflexion)
-功能: 从记忆历史生成本质性自我反思
-
-使用:
-    from reflection_engine import ReflectionEngine, ReflectionType
-    engine = ReflectionEngine()
-    results = engine.reflect(memory_entries, current_goal=None)
-"""
-
-import time
-from typing import List, Dict, Any, Optional
-from enum import Enum
-from dataclasses import dataclass, field
-
-
-class ReflectionType(Enum):
-    SUCCESS = "success"
-    FAILURE = "failure"
-    NEUTRAL = "neutral"
-    PATTERN = "pattern"
-    ADVICE = "advice"
-
-
-@dataclass
-class Reflection:
-    id: str
-    timestamp: float
-    rtype: ReflectionType
-    observation: str
-    analysis: str
-    inference: str
-    actionable: bool = False
-    confidence: float = 0.5
-    tags: List[str] = field(default_factory=list)
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "id": self.id,
-            "timestamp": self.timestamp,
-            "type": self.rtype.value,
-            "observation": self.observation,
-            "analysis": self.analysis,
-            "inference": self.inference,
-            "actionable": self.actionable,
-            "confidence": self.confidence,
-            "tags": self.tags
-        }
-
-
-class ReflectionEngine:
-    """
-    自我反思引擎
-    
-    核心原理:
-    - 不只是记录事件，而是推断事件背后的模式
-    - 三问: 发生了什么? 为什么发生? 下次怎么做?
-    - 区分: 观察(事实) vs 分析(判断) vs 推断(行动)
-    """
-
-    SUCCESS_SIGNALS = [
-        "开心", "突破", "解决了", "成功", "顺利", "太棒了",
-        "谢谢", "有效", "达到了", "完成了", "满意", "真棒"
-    ]
-    FAILURE_SIGNALS = [
-        "失败", "糟糕", "困难", "压力大", "累", "难过",
-        "沮丧", "失望", "不行", "没解决", "没效果", "烦"
-    ]
-
-    def __init__(self):
-        self.reflections: List[Reflection] = []
-        self._counter = 0
-
-    def _next_id(self) -> str:
-        self._counter += 1
-        return f"refl_{{int(time.time()*1000)}}_{{self._counter}}"
-
-    def reflect(self, memories,
-               current_goal: Optional[str] = None) -> List[Reflection]:
-        results = []
-        if not memories:
-            return results
-
-        recent = memories[:3]
-        success_entries = []
-        failure_entries = []
-
-        for m in recent:
-            cl = m.content.lower() if hasattr(m, 'content') else str(m).lower()
-            if any(s.lower() in cl for s in self.SUCCESS_SIGNALS):
-                success_entries.append(m)
-            elif any(s.lower() in cl for s in self.FAILURE_SIGNALS):
-                failure_entries.append(m)
-
-        for e in success_entries:
-            content_str = e.content[:60] if hasattr(e, 'content') else str(e)[:60]
-            r = self._make_reflection(
-                rtype=ReflectionType.SUCCESS,
-                observation=f"正向事件: {content_str}",
-                analysis="该交互有效处理了用户需求，用户表达了满意或积极情绪",
-                inference="继续使用相似的响应策略，保持当前情感共鸣方式",
-                tags=["success", getattr(e, 'emotion', 'unknown')]
-            )
-            results.append(r)
-
-        for e in failure_entries:
-            content_str = e.content[:60] if hasattr(e, 'content') else str(e)[:60]
-            r = self._make_reflection(
-                rtype=ReflectionType.FAILURE,
-                observation=f"负向事件: {content_str}",
-                analysis="用户表达了负面情绪，当前策略未能有效缓解",
-                inference="尝试更温和的倾听姿态，增加情感验证，减少直接建议",
-                tags=["failure", getattr(e, 'emotion', 'unknown')]
-            )
-            results.append(r)
-
-        if len(memories) >= 3:
-            pattern = self._detect_pattern(memories)
-            if pattern:
-                r = self._make_reflection(
-                    rtype=ReflectionType.PATTERN,
-                    observation=pattern["observation"],
-                    analysis=pattern["analysis"],
-                    inference=pattern["inference"],
-                    tags=["pattern"]
-                )
-                results.append(r)
-
-        if current_goal:
-            goal_reflection = self._goal_directed(current_goal, memories)
-            if goal_reflection:
-                results.append(goal_reflection)
-
-        for r in results:
-            self.reflections.append(r)
-
-        return results
-
-    def _make_reflection(self, rtype: ReflectionType,
-                         observation: str, analysis: str, inference: str,
-                         tags: List[str]) -> Reflection:
-        return Reflection(
-            id=self._next_id(),
-            timestamp=time.time(),
-            rtype=rtype,
-            observation=observation,
-            analysis=analysis,
-            inference=inference,
-            actionable=rtype in (ReflectionType.ADVICE, ReflectionType.FAILURE),
-            confidence=0.7,
-            tags=tags
-        )
-
-    def _detect_pattern(self, memories) -> Optional[Dict[str, str]]:
-        if len(memories) < 3:
-            return None
-        emotions = [getattr(m, 'emotion', 'neutral') for m in memories[-3:]]
-        if len(set(emotions)) == 1:
-            return {
-                "observation": f"连续3次同类型情感: {emotions[0]}",
-                "analysis": "用户在同一种情感状态下反复表达，说明这是一个持续性问题",
-                "inference": "需要更深入地探索这个情感根源，而不是表面回应"
-            }
-        return None
-
-    def _goal_directed(self, goal: str, memories) -> Optional[Reflection]:
-        goal_related = [m for m in memories if goal in (getattr(m, 'content', '') or '')]
-        if len(goal_related) >= 2:
-            outcomes = [getattr(m, 'outcome', None) for m in goal_related if getattr(m, 'outcome', None)]
-            if outcomes:
-                return self._make_reflection(
-                    rtype=ReflectionType.ADVICE,
-                    observation=f"目标'{goal}'相关记忆有{len(goal_related)}条",
-                    analysis=f"其中{len(outcomes)}条有结果记录",
-                    inference="建议回顾这些结果，优化针对该目标的策略",
-                    tags=["goal", goal]
-                )
-        return None
-
-    def get_actionable_insights(self) -> List[Dict[str, Any]]:
-        insights = []
-        for r in self.reflections:
-            if r.actionable and r.confidence >= 0.6:
-                insights.append({
-                    "inference": r.inference,
-                    "type": r.rtype.value,
-                    "confidence": r.confidence
-                })
-        return insights
-
-    def get_summary(self) -> Dict[str, Any]:
-        if not self.reflections:
-            return {"total": 0}
-        by_type = {}
-        for r in self.reflections:
-            by_type[r.rtype.value] = by_type.get(r.rtype.value, 0) + 1
-        return {
-            "total": len(self.reflections),
-            "by_type": by_type,
-            "actionable": sum(1 for r in self.reflections if r.actionable)
-        }
-
-
-if __name__ == "__main__":
-    class MockMem:
-        def __init__(self, c, e, o=None):
-            self.content = c
-            self.emotion = e
-            self.outcome = o
-    eng = ReflectionEngine()
-    results = eng.reflect([
-        MockMem("用户说项目突破了很开心", "excited"),
-        MockMem("用户抱怨工作压力大", "concerned")
-    ])
-    print("反思条数:", len(results))
-    print("可操作洞察:", eng.get_actionable_insights())
-    print("OK - ReflectionEngine")

package/src/core/papers/sleep_cycle_simulator.py

@@ -1,133 +0,0 @@
-"""
-SleepCycleSimulator - 睡眠周期模拟器
-====================================
-基于论文洞察:
-  # 1. Agent PSO: particle swarm optimization for evolving reasoning
-  # 2. Population-based reasoning: multiple reasoning candidates compete
-  # 3. Swarm intelligence: collective optimization of reasoning strategies
-功能: 模拟人类睡眠NREM/REM周期结构（约90分钟/周期）
-"""
-import time
-import random
-from typing import List, Dict, Any, Callable, Optional
-from dataclasses import dataclass
-from enum import Enum
-
-
-class SleepStage(Enum):
-    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
-
-
-@dataclass
-class SleepEpoch:
-    stage: SleepStage
-    duration_sec: float
-    start_time: float
-    memory_activity: str = "none"
-    brain_region: str = "global"
-
-
-class SleepCycleSimulator:
-    """
-    睡眠周期模拟器
-
-    每90分钟周期结构:
-    NREM1(5%) -> NREM2(45%) -> NREM3(25%) -> NREM2(15%) -> REM(10%)
-
-    随夜间进展:
-    - 深度睡眠(NREM3)比例减少
-    - REM比例增加
-    """
-    CYCLE_MIN = 90
-
-    def __init__(self):
-        self.epochs: List[SleepEpoch] = []
-        self._callbacks: Dict[SleepStage, List[Callable]] = {
-            s: [] for s in SleepStage
-        }
-
-    def on(self, stage: SleepStage, cb: Callable[[SleepEpoch], None]):
-        """Register callback for stage transitions"""
-        self._callbacks[stage].append(cb)
-
-    def simulate(self, num_cycles: int = 5) -> List[SleepEpoch]:
-        """
-        运行睡眠模拟
-
-        Args:
-            num_cycles: 周期数（每周期90分钟）
-        """
-        self.epochs = []
-        t = time.time()
-
-        for cycle_n in range(num_cycles):
-            # 夜间深度调节: 越往后深度睡眠越少，REM越多
-            depth_ratio = max(0.3, 1.0 - cycle_n * 0.12)
-            rem_ratio = min(0.28, 0.10 + cycle_n * 0.04)
-
-            stage_durations = [
-                (SleepStage.NREM1, 0.05),
-                (SleepStage.NREM2, 0.45),
-                (SleepStage.NREM3, 0.25 * depth_ratio),
-                (SleepStage.NREM2, 0.15),
-                (SleepStage.REM,  rem_ratio),
-            ]
-
-            for stage, ratio in stage_durations:
-                dur_sec = ratio * self.CYCLE_MIN * 60
-                epoch = SleepEpoch(
-                    stage=stage,
-                    duration_sec=dur_sec,
-                    start_time=t,
-                    memory_activity=self._memory_activity(stage),
-                    brain_region=self._brain_region(stage)
-                )
-                self.epochs.append(epoch)
-
-                # Fire callbacks
-                for cb in self._callbacks.get(stage, []):
-                    cb(epoch)
-
-                t += dur_sec
-
-        return self.epochs
-
-    def _memory_activity(self, stage: SleepStage) -> str:
-        return {
-            SleepStage.NREM1: "memory_filtering",
-            SleepStage.NREM2: "spindle_consolidation",
-            SleepStage.NREM3: "slow_wave_transfer",
-            SleepStage.REM:   "emotional_integration",
-        }.get(stage, "none")
-
-    def _brain_region(self, stage: SleepStage) -> str:
-        return {
-            SleepStage.NREM1: "thalamus",
-            SleepStage.NREM2: "thalamus_cortex",
-            SleepStage.NREM3: "hippocampus_cortex",
-            SleepStage.REM:   "limbic_cortex",
-        }.get(stage, "global")
-
-    def get_summary(self) -> Dict[str, Any]:
-        by_stage = {s.value: 0.0 for s in SleepStage}
-        for e in self.epochs:
-            by_stage[e.stage.value] += e.duration_sec / 60
-        return {
-            "total_cycles": len(self.epochs) // 5,
-            "stage_minutes": {k: round(v, 1) for k, v in by_stage.items()},
-            "total_sleep_min": sum(v for v in by_stage.values()) - by_stage["wake"],
-        }
-
-
-if __name__ == "__main__":
-    sim = SleepCycleSimulator()
-    epochs = sim.simulate(4)
-    print(f"周期数: {len(epochs)//5}")
-    for e in epochs[:8]:
-        print(f"  {e.stage.value}: {e.duration_sec/60:.1f}min | {e.memory_activity} | {e.brain_region}")
-    print("报告:", sim.get_summary())
-    print("OK - SleepCycleSimulator")