@yun520-1/heartflow 0.15.2

package/src/core/papers/attention_logic_verifier.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+HeartFlow Attention Logic Verifier v11.0.1
+
+Paper-inspired basis:
+- Attention Is All You Need (arXiv:1706.03762)
+Core adaptation for HeartFlow goal:
+- Use attention-style token weighting to focus on evidence-bearing terms
+- Reduce logic errors by checking contradiction, support coverage, and actionability
+
+This is not a full transformer.
+It is a lightweight verifier that borrows the paper's core idea:
+important tokens should get more weight than decorative tokens.
+"""
+
+from dataclasses import dataclass, asdict
+from collections import Counter
+import math
+import re
+import json
+
+VERSION = '11.0.1'
+
+STOPWORDS = {
+    'the','a','an','is','are','was','were','be','to','of','and','or','in','on','for','with','that','this',
+    '我','你','他','她','它','我们','你们','他们','的','了','是','在','和','与','就','也','都','而','但','如果','那么','因为','所以'
+}
+NEGATIONS = {'not','no','never','none','cannot','cant','wont','不要','不是','不能','不会','无'}
+ACTION_WORDS = {'fix','check','verify','test','run','measure','repair','update','compare','减少','修复','检查','验证','测试','更新','测量','比较'}
+EVIDENCE_WORDS = {'because','evidence','result','data','log','trace','measure','proof','由于','证据','结果','数据','日志','报错','原因','证明'}
+
+@dataclass
+class VerificationResult:
+    version: str
+    focus_tokens: list
+    support_score: float
+    contradiction_score: float
+    actionability_score: float
+    logic_score: float
+    verdict: str
+    reasons: list
+    repair_hints: list
+
+class AttentionLogicVerifier:
+    def __init__(self):
+        self.version = VERSION
+
+    def tokenize(self, text: str):
+        if not text:
+            return []
+        text = text.lower()
+        parts = re.findall(r'[a-zA-Z_]+|[一-鿿]+|\d+\.\d+|\d+', text)
+        return [p for p in parts if p.strip()]
+
+    def attention_weights(self, tokens):
+        counts = Counter(tokens)
+        weights = {}
+        for t in tokens:
+            base = 1.0
+            if t in STOPWORDS:
+                base *= 0.2
+            if t in ACTION_WORDS:
+                base *= 1.8
+            if t in EVIDENCE_WORDS:
+                base *= 2.0
+            if re.search(r'\d', t):
+                base *= 1.4
+            base *= 1.0 + min(counts[t]-1, 3) * 0.15
+            weights[t] = round(base, 3)
+        return weights
+
+    def top_focus_tokens(self, weights, topk=8):
+        return [k for k, _ in sorted(weights.items(), key=lambda x: (-x[1], x[0]))[:topk]]
+
+    def support_score(self, tokens, weights):
+        if not tokens:
+            return 0.0
+        score = 0.0
+        if any(t in EVIDENCE_WORDS for t in tokens):
+            score += 0.35
+        if any(t in ACTION_WORDS for t in tokens):
+            score += 0.25
+        if any(re.search(r'\d', t) for t in tokens):
+            score += 0.15
+        focused = self.top_focus_tokens(weights, 6)
+        non_stop = [t for t in focused if t not in STOPWORDS]
+        score += min(len(non_stop) / 6.0, 1.0) * 0.25
+        return min(round(score, 3), 1.0)
+
+    def contradiction_score(self, text, tokens):
+        score = 0.0
+        if any(t in NEGATIONS for t in tokens):
+            score += 0.2
+        pairs = [
+            ('通过','失败'),('成功','错误'),('存在','不存在'),('improve','worse'),('pass','fail')
+        ]
+        for a,b in pairs:
+            if a in text and b in text:
+                score += 0.35
+        if '但是' in text and '所以' in text:
+            score += 0.15
+        return min(round(score, 3), 1.0)
+
+    def actionability_score(self, tokens):
+        acts = sum(1 for t in tokens if t in ACTION_WORDS)
+        return min(round(acts / 4.0, 3), 1.0)
+
+    def verify(self, text: str):
+        tokens = self.tokenize(text)
+        weights = self.attention_weights(tokens)
+        support = self.support_score(tokens, weights)
+        contradiction = self.contradiction_score(text, tokens)
+        actionability = self.actionability_score(tokens)
+        logic = max(0.0, min(round(0.5 * support + 0.3 * actionability - 0.4 * contradiction + 0.3, 3), 1.0))
+
+        reasons = []
+        repair_hints = []
+        if support < 0.45:
+            reasons.append('证据支撑不足')
+            repair_hints.append('补充数据、日志、结果或明确因果说明')
+        if contradiction > 0.3:
+            reasons.append('存在潜在自相矛盾')
+            repair_hints.append('拆分结论与证据，检查是否同时出现互斥表述')
+        if actionability < 0.25:
+            reasons.append('缺少可执行动作')
+            repair_hints.append('增加检查、验证、修复、测试等明确动作')
+        if not reasons:
+            reasons.append('证据、动作与表述基本一致')
+            repair_hints.append('可继续增加可测量结果以进一步减少逻辑错误')
+
+        verdict = 'pass' if logic >= 0.65 and contradiction < 0.35 else 'needs_revision'
+        return VerificationResult(
+            version=self.version,
+            focus_tokens=self.top_focus_tokens(weights),
+            support_score=support,
+            contradiction_score=contradiction,
+            actionability_score=actionability,
+            logic_score=logic,
+            verdict=verdict,
+            reasons=reasons,
+            repair_hints=repair_hints,
+        )
+
+
+def demo():
+    verifier = AttentionLogicVerifier()
+    sample = '请先检查日志和结果，验证版本11.0.0为什么回退，再修复配置并测试。'
+    result = verifier.verify(sample)
+    print(json.dumps(asdict(result), ensure_ascii=False, indent=2))
+
+if __name__ == '__main__':
+    demo()

package/src/core/papers/dream_generator.py

@@ -0,0 +1,176 @@
+"""
+DreamGenerator - 梦境生成器
+============================
+基于论文洞察:
+  # 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
+功能: 模拟REM睡眠时期的离线记忆重组与梦境生成
+"""
+import time
+import random
+from typing import List, Dict, Any, Optional
+from dataclasses import dataclass, field
+
+
+@dataclass
+class DreamFragment:
+    id: str
+    timestamp: float
+    content: str
+    emotions: List[str]
+    recombination_type: str = "hippocampal_random"
+    vividness: float = 0.5
+
+    def __post_init__(self):
+        if not self.id:
+            self.id = f"dream_{int(time.time()*1000)}"
+
+
+class DreamPhase:
+    NREM = "nrem"
+    REM = "rem"
+    AWAKE = "awake"
+    TRANSITION = "transition"
+
+
+@dataclass
+class SleepCycle:
+    phase: DreamPhase
+    duration_minutes: float
+    start_time: float
+    memories_processed: List[str] = field(default_factory=list)
+
+
+class DreamGenerator:
+    """
+    梦境生成器 - 模拟REM睡眠时的离线记忆重组
+
+    关键洞察:
+    - REM: 随机海马信号驱动情感/程序记忆整合
+    - 梦境 = 近期经历 + 旧知识的随机重组
+    - NREM: 事实/情景记忆从海马体向皮层转移
+    - 睡眠周期约90分钟，NREM/REM交替
+    """
+    CYCLE_MIN = 90
+    REM_RATIO = 0.25
+    NREM_RATIO = 0.70
+
+    def __init__(self, memory_system=None):
+        self.memory = memory_system
+        self.sleep_cycles: List[SleepCycle] = []
+        self.dreams: List[DreamFragment] = []
+        self._counter = 0
+        self._emotions = ["joy", "fear", "surprise", "sadness", "angry"]
+
+    def _nid(self) -> str:
+        self._counter += 1
+        return f"dr_{int(time.time()*1000)}_{self._counter}"
+
+    def enter_sleep(self, uid: str, priors: list,
+                    emotion: str = "neutral") -> List[SleepCycle]:
+        """启动睡眠周期，生成NREM/REM交替"""
+        cycles = []
+        for i in range(random.randint(4, 6)):
+            nrem = SleepCycle(
+                DreamPhase.NREM,
+                self.NREM_RATIO * self.CYCLE_MIN,
+                time.time(),
+                [str(getattr(m, "id", j)) for j, m in enumerate(priors[:5])]
+            )
+            rem = SleepCycle(
+                DreamPhase.REM,
+                self.REM_RATIO * self.CYCLE_MIN,
+                time.time(),
+                [str(getattr(m, "id", j)) for j, m in enumerate(priors[:3])]
+            )
+            cycles.extend([nrem, rem])
+        self.sleep_cycles = cycles
+        return cycles
+
+    def generate_dream(self, cycle: SleepCycle, recent: list,
+                      emotion_ctx: str = "neutral") -> Optional[DreamFragment]:
+        """
+        在REM阶段生成梦境内容
+
+        机制: 随机海马信号 + 近期记忆元素 -> 创意重组
+        """
+        if cycle.phase != DreamPhase.REM:
+            return None
+
+        # 提取记忆元素
+        els = [getattr(m, "content", str(m))[:40] for m in recent[:6]]
+
+        # 随机重组模板
+        templates = [
+            "{A}的场景过渡到{B}，{C}的碎片闪过...",
+            "{A}与{B}混合在一起，{C}的影子逐渐浮现...",
+            "{A}中浮现{B}，{C}的轮廓变得清晰...",
+            "{B}的片段与{A}交织，{C}在远处闪烁...",
+        ]
+        tmpl = random.choice(templates)
+        A = els[0] if len(els) > 0 else "模糊影像"
+        B = els[1] if len(els) > 1 else "未知空间"
+        C = els[2] if len(els) > 2 else "梦境"
+
+        text = tmpl.replace("{A}", A).replace("{B}", B).replace("{C}", C)
+
+        # 情感映射
+        em_map = {
+            "joy": ["joy", "surprise"],
+            "excited": ["joy", "anticipation"],
+            "concerned": ["fear", "sadness"],
+            "tired": ["sadness", "fatigue"],
+            "angry": ["anger", "disgust"],
+        }
+        ems = em_map.get(emotion_ctx, ["neutral", "confusion"])
+
+        frag = DreamFragment(
+            id=self._nid(),
+            timestamp=time.time(),
+            content=text,
+            emotions=ems,
+            vividness=random.uniform(0.4, 0.9)
+        )
+        self.dreams.append(frag)
+        return frag
+
+    def get_report(self) -> Dict[str, Any]:
+        if not self.dreams:
+            return {"total_dreams": 0}
+        return {
+            "total_dreams": len(self.dreams),
+            "avg_vividness": sum(d.vividness for d in self.dreams) / len(self.dreams),
+            "latest": self.dreams[-1].content[:100],
+            "emotions": {
+                e: sum(1 for d in self.dreams if e in d.emotions)
+                for e in self._emotions
+            }
+        }
+
+
+if __name__ == "__main__":
+    class MockMem:
+        _id = 0
+
+        def __init__(self, c, e):
+            self.content = c
+            self.emotion = e
+            MockMem._id += 1
+            self.id = MockMem._id
+
+    dg = DreamGenerator()
+    mems = [
+        MockMem(f"记忆{i}", ["joy", "concerned", "tired"][i % 3])
+        for i in range(8)
+    ]
+
+    cycles = dg.enter_sleep("u1", mems, "concerned")
+    rem_cycle = [c for c in cycles if c.phase == DreamPhase.REM][0]
+    dr = dg.generate_dream(rem_cycle, mems, "concerned")
+
+    print(f"梦境: {dr.content[:80] if dr else 'none'}")
+    print(f"情感: {dr.emotions if dr else []}")
+    print(f"生动度: {dr.vividness:.2f}" if dr else "")
+    print("报告:", dg.get_report())
+    print("OK - DreamGenerator")

package/src/core/papers/emotion_memory_bridge.py

@@ -0,0 +1,213 @@
+"""
+EmotionMemoryBridge - 情感与记忆的桥梁
+===================================
+功能: 将 HeartFlow 情感引擎与情景记忆系统连接
+
+将情感状态变化自动记录为情景记忆，
+从记忆历史中检索情感模式用于响应风格调整。
+"""
+
+import time
+from typing import List, Dict, Any, Optional
+from enum import Enum
+
+
+class EmotionalArcType(Enum):
+    ASCENDING = "ascending"       # 情感上升
+    DESCENDING = "descending"     # 情感下降
+    STABLE_POSITIVE = "stable_positive"   # 稳定积极
+    STABLE_NEGATIVE = "stable_negative"   # 稳定消极
+    FLUCTUATING = "fluctuating"  # 情感波动
+    EMOTIONAL_SPIKE = "spike"     # 情感突变
+
+
+class EmotionMemoryBridge:
+    """
+    情感与记忆的桥梁
+
+    功能:
+    1. 将每次交互的情感状态自动记录为记忆
+    2. 从记忆历史分析情感弧线
+    3. 基于情感历史调整响应风格
+    """
+
+    def __init__(self, episodic_memory, reflection_engine):
+        self.memory = episodic_memory
+        self.reflection = reflection_engine
+        self.emotion_history = []
+        self._counter = 0
+
+    def _next_id(self):
+        self._counter += 1
+        return f"emb_{{int(time.time()*1000)}}_{{self._counter}}"
+
+    def record_interaction(self, user_input: str,
+                         agent_response: str,
+                         emotion: str,
+                         intensity: int,
+                         context: Optional[Dict] = None) -> None:
+        """
+        将一次交互记录为情感记忆
+
+        Args:
+            user_input: 用户输入
+            agent_response: 智能体回复
+            emotion: 情感类型
+            intensity: 情感强度 1-5
+            context: 额外上下文
+        """
+        content = f"用户: {user_input[:60]} | 回复: {agent_response[:60]}..."
+        importance = min(1.0, intensity / 5.0 + 0.3)
+
+        self.memory.add(
+            content=content,
+            emotion=emotion,
+            importance=importance,
+            context={
+                **(context or {}),
+                "intensity": intensity,
+                "type": "emotional_interaction"
+            },
+            relevance_tags=[emotion, f"intensity_{intensity}"]
+        )
+
+        self.emotion_history.append({
+            "emotion": emotion,
+            "intensity": intensity,
+            "timestamp": time.time(),
+            "user_input": user_input[:50]
+        })
+
+        if len(self.emotion_history) > 50:
+            self.emotion_history = self.emotion_history[-50:]
+
+    def analyze_emotional_arc(self, window: int = 10) -> Dict[str, Any]:
+        """
+        分析最近的情感弧线
+
+        Args:
+            window: 分析窗口大小
+
+        Returns:
+            情感弧线分析结果
+        """
+        if len(self.emotion_history) < 2:
+            return {"arc_type": "unknown", "confidence": 0}
+
+        recent = self.emotion_history[-window:]
+        emotions = [e["emotion"] for e in recent]
+        intensities = [e["intensity"] for e in recent]
+
+        if not emotions:
+            return {"arc_type": "unknown", "confidence": 0}
+
+        emotion_changes = sum(
+            1 for i in range(1, len(emotions))
+            if emotions[i] != emotions[i-1]
+        )
+
+        avg_intensity = sum(intensities) / len(intensities)
+        intensity_trend = intensities[-1] - intensities[0]
+
+        if emotion_changes >= len(emotions) * 0.5:
+            arc = EmotionalArcType.FLUCTUATING
+        elif abs(intensity_trend) <= 1 and len(set(emotions)) <= 2:
+            if emotions[0] in ["joy", "excited"]:
+                arc = EmotionalArcType.STABLE_POSITIVE
+            elif emotions[0] in ["concerned", "tired"]:
+                arc = EmotionalArcType.STABLE_NEGATIVE
+            else:
+                arc = EmotionalArcType.FLUCTUATING
+        elif intensity_trend > 2:
+            arc = EmotionalArcType.ASCENDING
+        elif intensity_trend < -2:
+            arc = EmotionalArcType.DESCENDING
+        else:
+            arc = EmotionalArcType.STABLE_POSITIVE
+
+        return {
+            "arc_type": arc.value,
+            "avg_intensity": round(avg_intensity, 2),
+            "intensity_trend": intensity_trend,
+            "emotion_changes": emotion_changes,
+            "dominant_emotion": max(set(emotions), key=emotions.count) if emotions else "neutral",
+            "window_size": len(recent),
+            "confidence": min(1.0, len(recent) / 5.0)
+        }
+
+    def get_response_style_hint(self) -> Dict[str, Any]:
+        """
+        基于情感历史生成响应风格提示
+
+        Returns:
+            响应风格建议
+        """
+        arc = self.analyze_emotional_arc()
+
+        if arc["arc_type"] == EmotionalArcType.ASCENDING.value:
+            return {
+                "style": "celebrate",
+                "tone": "warm",
+                "suggestion": "情感正在上升，保持积极氛围，适度庆祝进步"
+            }
+        elif arc["arc_type"] == EmotionalArcType.DESCENDING.value:
+            return {
+                "style": "support",
+                "tone": "gentle",
+                "suggestion": "情感正在下降，增加情感验证，提供支持性回应"
+            }
+        elif arc["arc_type"] == EmotionalArcType.STABLE_NEGATIVE.value:
+            return {
+                "style": "empathetic",
+                "tone": "calm",
+                "suggestion": "持续消极情绪，深入探索情感根源，谨慎给建议"
+            }
+        elif arc["arc_type"] == EmotionalArcType.FLUCTUATING.value:
+            return {
+                "style": "balanced",
+                "tone": "neutral",
+                "suggestion": "情感波动较大，保持稳定倾听，帮助梳理情感"
+            }
+        else:
+            return {
+                "style": "neutral",
+                "tone": "balanced",
+                "suggestion": "情感状态稳定，保持正常交流"
+            }
+
+    def get_recent_emotions(self, limit: int = 5) -> List[Dict]:
+        """获取最近的情感历史"""
+        return self.emotion_history[-limit:]
+
+    def get_emotion_summary(self) -> Dict[str, Any]:
+        """获取情感统计摘要"""
+        if not self.emotion_history:
+            return {"total": 0}
+        emotions = [e["emotion"] for e in self.emotion_history]
+        by_emotion = {}
+        for em in emotions:
+            by_emotion[em] = by_emotion.get(em, 0) + 1
+        return {
+            "total": len(self.emotion_history),
+            "by_emotion": by_emotion,
+            "arc_analysis": self.analyze_emotional_arc()
+        }
+
+
+if __name__ == "__main__":
+    from episodic_memory import EpisodicMemory
+    from reflection_engine import ReflectionEngine
+
+    mem = EpisodicMemory()
+    ref = ReflectionEngine()
+    bridge = EmotionMemoryBridge(mem, ref)
+
+    bridge.record_interaction("今天项目突破了！", "太棒了！", "excited", 4)
+    bridge.record_interaction("谢谢你的帮助！", "不客气！", "joy", 3)
+    bridge.record_interaction("工作压力好大啊", "怎么了？", "concerned", 3)
+    bridge.record_interaction("我好累啊...", "休息一下吧", "tired", 4)
+
+    print("情感历史:", bridge.get_recent_emotions())
+    print("情感弧线:", bridge.analyze_emotional_arc())
+    print("响应风格:", bridge.get_response_style_hint())
+    print("OK - EmotionMemoryBridge")