@yun520-1/heartflow 0.15.2

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

@@ -0,0 +1,344 @@
+/**
+ * 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

@@ -0,0 +1,219 @@
+"""
+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

@@ -0,0 +1,133 @@
+"""
+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")