@yun520-1/heartflow 0.15.2

package/src/core/papers/episodic_memory.py

@@ -0,0 +1,140 @@
+"""
+EpisodicMemory - 情景记忆模块
+============================
+基于论文: 2304.03442 Reflexion
+功能: 自然语言情景记忆存储与检索
+"""
+import time, math, json, os
+from typing import List, Dict, Any, Optional
+from dataclasses import dataclass, field, asdict
+from enum import Enum
+
+
+class RelevanceType(Enum):
+    TOPICAL = "topical"
+    EMOTIONAL = "emotional"
+    GOAL = "goal"
+    CONSEQUENTIAL = "consequential"
+
+
+@dataclass
+class MemoryEntry:
+    id: str
+    timestamp: float
+    content: str
+    emotion: str = "neutral"
+    importance: float = 0.5
+    reflection: Optional[str] = None
+    outcome: Optional[str] = None
+    access_count: int = 0
+    last_accessed: Optional[float] = None
+    relevance_tags: List[str] = field(default_factory=list)
+    context: Dict[str, Any] = field(default_factory=dict)
+
+    def recency_score(self, now: float, decay: float = 0.01) -> float:
+        age_hours = (now - self.timestamp) / 3600
+        return math.exp(-decay * age_hours)
+
+    def familiarity_score(self) -> float:
+        return math.log(1 + self.access_count)
+
+    def relevance_score(self, query: str, rtype=RelevanceType.TOPICAL) -> float:
+        if rtype == RelevanceType.TOPICAL:
+            qw = set(query.lower().split())
+            cw = set(self.content.lower().split())
+            return len(qw & cw) / len(qw) if qw else 0.0
+        elif rtype == RelevanceType.EMOTIONAL:
+            return 1.0 if query.lower() in self.emotion.lower() else 0.0
+        elif rtype == RelevanceType.GOAL:
+            return 0.5 if self.outcome and query.lower() in self.outcome.lower() else 0.0
+        elif rtype == RelevanceType.CONSEQUENTIAL:
+            if self.outcome:
+                t = self.outcome.lower()
+                if any(k in t for k in ["成功", "完成", "达到"]): return 0.8
+                if any(k in t for k in ["失败", "挫折"]): return 0.6
+        return 0.0
+
+    def composite_score(self, query: str, now: float,
+                       rtype=RelevanceType.TOPICAL,
+                       w=(0.3, 0.2, 0.3, 0.2)) -> float:
+        rw, fw, relw, iw = w
+        return (rw * self.recency_score(now)
+                + fw * min(self.familiarity_score() / 3.0, 1.0)
+                + iw * self.importance
+                + relw * self.relevance_score(query, rtype))
+
+    def touch(self, now: float) -> None:
+        self.access_count += 1
+        self.last_accessed = now
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = asdict(self)
+        d.pop("id", None)
+        return d
+
+
+class EpisodicMemory:
+    DEFAULT_WEIGHTS = (0.3, 0.2, 0.3, 0.2)
+    MAX_ENTRIES = 10000
+
+    def __init__(self, storage_path=None):
+        self.entries: List[MemoryEntry] = []
+        self.storage_path = storage_path
+        self._counter = 0
+        if storage_path and os.path.exists(storage_path):
+            self._load()
+
+    def _next_id(self):
+        self._counter += 1
+        return f"mem_{int(time.time()*1000)}_{self._counter}"
+
+    def add(self, content, emotion="neutral", importance=0.5,
+            reflection=None, outcome=None, context=None, relevance_tags=None):
+        e = MemoryEntry(
+            id=self._next_id(), timestamp=time.time(), content=content,
+            emotion=emotion, importance=importance,
+            reflection=reflection, outcome=outcome,
+            context=context or {}, relevance_tags=relevance_tags or [])
+        self.entries.append(e)
+        if len(self.entries) > self.MAX_ENTRIES:
+            self.entries = self.entries[-self.MAX_ENTRIES:]
+        self._maybe_save()
+        return e
+
+    def retrieve(self, query, limit=5, rtype=RelevanceType.TOPICAL,
+                 emotion=None, min_score=0.05, weights=None):
+        now = time.time()
+        scored = []
+        w = weights or self.DEFAULT_WEIGHTS
+        for e in self.entries:
+            if emotion and e.emotion != emotion:
+                continue
+            s = e.composite_score(query, now, rtype, w)
+            if s >= min_score:
+                scored.append((s, e))
+        scored.sort(key=lambda x: x[0], reverse=True)
+        results = [e for _, e in scored[:limit]]
+        for e in results:
+            e.touch(now)
+        return results
+
+    def get_summary(self):
+        if not self.entries:
+            return {"total": 0}
+        by_e = {}
+        for e in self.entries:
+            by_e[e.emotion] = by_e.get(e.emotion, 0) + 1
+        return {
+            "total": len(self.entries),
+            "by_emotion": by_e,
+            "avg_importance": sum(e.importance for e in self.entries) / len(self.entries),
+        }
+
+
+if __name__ == "__main__":
+    mem = EpisodicMemory()
+    mem.add("用户说项目突破了很开心", emotion="excited", importance=0.9)
+    mem.add("工作压力大", emotion="concerned", importance=0.8)
+    r = mem.retrieve("工作")
+    print("检索:", [(x.emotion, x.content[:30]) for x in r])
+    print("OK")

package/src/core/papers/memory_consolidator.py

@@ -0,0 +1,144 @@
+"""
+MemoryConsolidator - 记忆巩固器
+================================
+基于论文洞察:
+  # 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
+功能: 模拟睡眠期间的记忆转移与整合（海马体->皮层）
+"""
+import time
+import random
+import math
+from typing import List, Dict, Any, Optional
+from dataclasses import dataclass, field
+
+
+@dataclass
+class MemoryTrace:
+    id: str
+    content: str
+    timestamp: float
+    memory_type: str  # episodic, semantic, emotional, procedural
+    strength: float   # 0.0-1.0
+    transferred: bool = False
+    transfer_target: str = "cortical"
+
+
+class MemoryConsolidator:
+    """
+    记忆巩固器 - 模拟睡眠时的记忆转移机制
+
+    海马-皮层记忆转移:
+    - NREM慢波睡眠(SWS): 事实/情景记忆从海马体向皮层长期存储转移
+    - REM睡眠: 情感/程序记忆优先处理与整合
+    - 尖锐波涟漪(sharp-wave ripples): 海马->皮层信息传递载体
+    - 转移后记忆强度增加
+
+    关键洞察:
+    - 睡眠时海马自发活动触发记忆重播
+    - 重播次数越多，记忆越巩固
+    - 情感记忆在REM阶段优先整合
+    """
+    def __init__(self):
+        self.hippocampal: List[MemoryTrace] = []
+        self.cortical: List[MemoryTrace] = []
+        self.transfer_log: List[Dict] = []
+
+    def store(self, content: str, mtype: str = "episodic",
+              strength: float = 0.7) -> MemoryTrace:
+        """存储新的记忆痕迹到海马体"""
+        t = MemoryTrace(
+            id=f"mem_{int(time.time()*1000)}",
+            content=content,
+            timestamp=time.time(),
+            memory_type=mtype,
+            strength=strength,
+            transferred=False,
+            transfer_target="cortical"
+        )
+        self.hippocampal.append(t)
+        return t
+
+    def consolidate(self, stage: str = "nrem3") -> List[MemoryTrace]:
+        """
+        执行记忆巩固
+
+        Args:
+            stage: nrem1/nrem2/nrem3/rem
+                - nrem3 (SWS): hippocampal->cortical transfer
+                - rem: emotional/procedural integration
+                - nrem1/2: memory reinforcement
+        """
+        transferred = []
+
+        if stage == "nrem3":
+            candidates = [m for m in self.hippocampal if not m.transferred]
+            for m in candidates:
+                m.transferred = True
+                m.strength = min(1.0, m.strength * (1.0 + random.uniform(0.1, 0.3)))
+                self.cortical.append(m)
+                self.transfer_log.append({
+                    "from": "hippocampal",
+                    "to": "cortical",
+                    "id": m.id,
+                    "content": m.content[:30],
+                    "stage": stage,
+                    "time": time.time()
+                })
+                transferred.append(m)
+
+        elif stage == "rem":
+            emotional = [m for m in self.hippocampal
+                       if m.memory_type in ("emotional", "procedural")]
+            for m in emotional:
+                m.strength = min(1.0, m.strength * (1.0 + random.uniform(0.05, 0.15)))
+                self.transfer_log.append({
+                    "from": "hippocampal",
+                    "to": "integrated",
+                    "id": m.id,
+                    "stage": stage,
+                    "time": time.time()
+                })
+
+        return transferred
+
+    def replay(self, memory_id: str) -> Optional[str]:
+        """模拟睡眠期间的记忆重播"""
+        for m in self.hippocampal + self.cortical:
+            if m.id == memory_id:
+                clarity = "清晰" if m.strength > 0.6 else "模糊"
+                return f"[重播] {m.content[:50]}... {clarity}"
+        return None
+
+    def get_summary(self) -> Dict[str, Any]:
+        return {
+            "hippocampal": len(self.hippocampal),
+            "cortical": len(self.cortical),
+            "total_transfers": len(self.transfer_log),
+            "avg_cortical_strength": (
+                sum(m.strength for m in self.cortical) / max(1, len(self.cortical))
+            ),
+            "by_type": self._count_by_type(),
+        }
+
+    def _count_by_type(self) -> Dict[str, int]:
+        counts = {}
+        for m in self.hippocampal + self.cortical:
+            counts[m.memory_type] = counts.get(m.memory_type, 0) + 1
+        return counts
+
+
+if __name__ == "__main__":
+    mc = MemoryConsolidator()
+    for i in range(5):
+        mc.store(f"记忆{i}: 工作经验{'正面' if i % 2 == 0 else '挑战'}", "episodic")
+    mc.store("项目突破的喜悦", "emotional")
+    mc.store("新算法的使用步骤", "procedural")
+
+    print("巩固前:", {k: v for k, v in mc._count_by_type().items()})
+    transferred = mc.consolidate("nrem3")
+    mc.consolidate("rem")
+    print(f"转移了 {len(transferred)} 条记忆")
+    print("摘要:", mc.get_summary())
+    print("OK - MemoryConsolidator")

package/src/core/papers/memory_planner.py

@@ -0,0 +1,198 @@
+"""
+MemoryPlanner - 从记忆生成行动计划的引擎
+====================================
+论文: 2304.03442 (Reflexion)
+功能: 基于 Reflexion 三组件: Memory / Reflection / Planning
+
+使用:
+    from memory_planner import MemoryPlanner
+    planner = MemoryPlanner()
+    plans = planner.generate_from_memories(memories, reflection_engine)
+"""
+
+import time
+from typing import List, Dict, Any, Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class PlanStep:
+    id: str
+    description: str
+    priority: int
+    completed: bool
+    reason: str = ""
+    created_at: float = 0.0
+
+    def __post_init__(self):
+        if self.created_at == 0.0:
+            self.created_at = time.time()
+
+
+class MemoryPlanner:
+    """
+    从记忆历史生成行动计划的引擎
+    基于 Reflexion 三组件: Memory / Reflection / Planning
+
+    工作流程:
+    1. 收集记忆条目
+    2. 通过 ReflectionEngine 生成反思
+    3. 从可操作的反思生成计划步骤
+    4. 管理计划的执行状态
+    """
+
+    MAX_ACTIVE_PLANS = 10
+
+    def __init__(self):
+        self.plans: List[PlanStep] = []
+        self._counter = 0
+
+    def _next_id(self) -> str:
+        self._counter += 1
+        return f"plan_{{int(time.time()*1000)}}_{{self._counter}}"
+
+    def generate_from_memories(self, memories,
+                              reflection_engine) -> List[PlanStep]:
+        """
+        从记忆和反思引擎生成计划步骤
+
+        Args:
+            memories: MemoryEntry 列表
+            reflection_engine: ReflectionEngine 实例
+
+        Returns:
+            新生成的 PlanStep 列表
+        """
+        plans = []
+        actionable = reflection_engine.get_actionable_insights()
+
+        for i, insight in enumerate(actionable[:5]):
+            priority = 5 - i
+            step = PlanStep(
+                id=self._next_id(),
+                description=insight["inference"],
+                priority=priority,
+                completed=False,
+                reason=f"来源: {insight['type']} (置信度: {insight['confidence']:.2f})",
+                created_at=time.time()
+            )
+            plans.append(step)
+
+        self.plans.extend(plans)
+        self._trim_plans()
+        return plans
+
+    def generate_from_goal(self, goal: str,
+                         memories) -> List[PlanStep]:
+        """
+        从特定目标生成计划步骤
+
+        Args:
+            goal: 目标关键词
+            memories: 相关记忆列表
+
+        Returns:
+            生成的计划步骤
+        """
+        goal_memories = [m for m in memories if goal in (getattr(m, 'content', '') or '')]
+
+        if not goal_memories:
+            return []
+
+        plan = PlanStep(
+            id=self._next_id(),
+            description=f"针对目标 '{goal}' 的专门行动计划",
+            priority=8,
+            completed=False,
+            reason=f"基于 {len(goal_memories)} 条相关记忆生成",
+            created_at=time.time()
+        )
+        self.plans.append(plan)
+        self._trim_plans()
+        return [plan]
+
+    def get_active_plans(self) -> List[PlanStep]:
+        """获取未完成的计划"""
+        active = [p for p in self.plans if not p.completed]
+        active.sort(key=lambda p: (p.priority, p.created_at), reverse=True)
+        return active[:self.MAX_ACTIVE_PLANS]
+
+    def get_completed_plans(self, limit: int = 10) -> List[PlanStep]:
+        """获取已完成的计划"""
+        completed = [p for p in self.plans if p.completed]
+        completed.sort(key=lambda p: p.created_at, reverse=True)
+        return completed[:limit]
+
+    def complete(self, plan_id: str) -> bool:
+        """标记计划为完成"""
+        for p in self.plans:
+            if p.id == plan_id:
+                p.completed = True
+                return True
+        return False
+
+    def cancel(self, plan_id: str) -> bool:
+        """取消/删除计划"""
+        for i, p in enumerate(self.plans):
+            if p.id == plan_id:
+                self.plans.pop(i)
+                return True
+        return False
+
+    def update_priority(self, plan_id: str, new_priority: int) -> bool:
+        """更新计划优先级"""
+        for p in self.plans:
+            if p.id == plan_id:
+                p.priority = max(1, min(10, new_priority))
+                return True
+        return False
+
+    def get_summary(self) -> Dict[str, Any]:
+        """获取计划统计"""
+        active = [p for p in self.plans if not p.completed]
+        completed = [p for p in self.plans if p.completed]
+        return {
+            "total": len(self.plans),
+            "active": len(active),
+            "completed": len(completed),
+            "avg_priority": sum(p.priority for p in active) / len(active) if active else 0
+        }
+
+    def _trim_plans(self) -> None:
+        """修剪活跃计划数量"""
+        active = self.get_active_plans()
+        if len(active) > self.MAX_ACTIVE_PLANS:
+            to_remove = active[self.MAX_ACTIVE_PLANS:]
+            for p in to_remove:
+                self.plans.remove(p)
+
+
+if __name__ == "__main__":
+    from reflection_engine import ReflectionEngine, ReflectionType, Reflection
+
+    class MockMem:
+        def __init__(self, c, e, o=None):
+            self.content = c
+            self.emotion = e
+            self.outcome = o
+
+    eng = ReflectionEngine()
+    eng.reflections = [
+        Reflection(
+            id="r1", timestamp=time.time(),
+            rtype=ReflectionType.FAILURE,
+            observation="test", analysis="test",
+            inference="增加情感验证，减少直接建议",
+            actionable=True, confidence=0.8, tags=["failure"]
+        )
+    ]
+
+    planner = MemoryPlanner()
+    plans = planner.generate_from_memories(
+        [MockMem("用户抱怨工作", "concerned")],
+        eng
+    )
+    print("生成计划:", [(p.description[:30], p.priority) for p in plans])
+    print("活跃计划:", len(planner.get_active_plans()))
+    print("统计:", planner.get_summary())
+    print("OK - MemoryPlanner")