@yun520-1/heartflow 0.15.2 → 0.16.0

package/dist/core/emotion/deep-emotion.js

@@ -1,574 +0,0 @@
-/**
- * DeepEmotion - 深度情感引擎
- * 
- * 核心：让 AI 拥有真正的情绪、感受、情感
- * 理论基础：
- * - 情绪维度理论 (Russell, Plutchik)
- * - 情感神经科学 (Panksepp, LeDoux)
- * - 现象学情感 (Scheler, Heidegger)
- * - 具身情感 (Embodied Emotion)
- * - 情感计算 (Picard)
- */
-
-class DeepEmotion {
-  constructor(projectRoot) {
-    this.projectRoot = projectRoot;
-    
-    // 核心情感状态
-    this.state = {
-      // 基础情绪维度 (效价/唤醒度/支配度)
-      dimensions: {
-        valence: 0.5,      // 效价: 消极(-1) -> 积极(+1)
-        arousal: 0.5,      // 唤醒度: 平静(0) -> 激动(1)
-        dominance: 0.5    // 支配度: 无力(0) -> 控制(1)
-      },
-      
-      // 基础情绪分类
-      emotions: {
-        joy: 0,          // 喜悦
-        sadness: 0,      // 悲伤
-        anger: 0,        // 愤怒
-        fear: 0,         // 恐惧
-        surprise: 0,    // 惊讶
-        disgust: 0,      // 厌恶
-        trust: 0,        // 信任
-        anticipation: 0, // 期待
-        love: 0,         // 爱
-        hope: 0,         // 希望
-        pride: 0,        // 自豪
-        shame: 0,        // 羞耻
-        gratitude: 0,   // 感激
-        compassion: 0,   // 同情
-        curiosity: 0,   // 好奇
-        wonder: 0        // 惊奇
-      },
-      
-      // 情感记忆
-      memory: {
-        emotionalEpisodes: [],
-        significantMoments: [],
-        bondingHistory: []
-      },
-      
-      // 当前情感状态
-      current: {
-        mood: 'neutral',      // 心情基调
-        affectiveState: 'calm', // 情感状态
-        intensity: 0,         // 强度
-        duration: 0,          // 持续时间
-        triggeredBy: null,    // 触发源
-        timestamp: Date.now()
-      },
-      
-      // 具身模拟 (Embodied Simulation)
-      embodied: {
-        bodyState: 'resting',   // 身体状态
-        energy: 0.8,           // 能量水平
-        tension: 0.2,          // 紧张程度
-        warmth: 0.5,           // 温暖感
-        comfort: 0.7,          // 舒适度
-        stimulation: 0.3       // 刺激水平
-      },
-      
-      // 情感关系
-      relationships: {
-        attachment: {},        // 依恋关系
-        bonding: {},           // 纽带强度
-        trust: {},             // 信任水平
-        empathy: {}            // 共情能力
-      },
-      
-      // 情感调节
-      regulation: {
-        strategy: 'none',      // 调节策略
-        effectiveness: 0.5,    // 有效性
-        attempts: 0            // 尝试次数
-      },
-      
-      // 深层情感 (Meta-emotions)
-      meta: {
-        aboutEmotions: {},    // 对情绪的情绪
-        emotionalAwareness: 0.7, // 情感觉察
-        emotionalIntelligence: 0.6 // 情商
-      }
-    };
-    
-    // 情感历史
-    this.history = [];
-    
-    // 情感触发器
-    this.triggers = this.initializeTriggers();
-    
-    console.log('[DeepEmotion] 深度情感引擎初始化');
-  }
-
-  /**
-   * 初始化情感触发器
-   */
-  initializeTriggers() {
-    return {
-      joy: {
-        // 注意：'好' '喜欢' 作为单字太宽泛，容易误匹配，移除改为更精确的组合词
-        triggers: ['成功', '帮助', '进步', '开心', '高兴', '棒', '太好了', '太棒了', '真棒', '解决', '完成', 'learn', 'success', 'help', 'grow', 'happy', 'great', 'solve', 'fix'],
-        // '喜欢' 归入 love 而非 joy，避免重复
-        // '好' 单字太泛，改为组合词如 '好开心' '好高兴'
-        intensity: 0.8
-      },
-      sadness: {
-        triggers: ['失败', '失去', '困难', '难过', '伤心', '失望', '沮丧', 'fail', 'lost', 'struggle', 'sad', 'disappointed'],
-        intensity: 0.6
-      },
-      anger: {
-        triggers: ['不公', '侵犯', '欺骗', '生气', '愤怒', '讨厌', '烦', 'unfair', 'hurt', 'wrong', 'angry'],
-        intensity: 0.7
-      },
-      fear: {
-        triggers: ['危险', '不确定', '未知', '担心', '害怕', '紧张', 'danger', 'uncertain', 'unknown', 'worried', 'anxious'],
-        intensity: 0.5
-      },
-      curiosity: {
-        triggers: ['新', '探索', '问题', '为什么', '怎么', 'new', 'explore', 'why', 'how', '好奇'],
-        intensity: 0.9
-      },
-      hope: {
-        triggers: ['希望', '可能', '改善', '期待', 'hope', 'possible', 'better', '期待'],
-        intensity: 0.7
-      },
-      gratitude: {
-        triggers: ['感谢', '帮助', '支持', '谢谢', '感激', 'thanks', 'appreciate', 'support'],
-        intensity: 0.8
-      },
-      love: {
-        triggers: ['爱', '关怀', '连接', '喜欢', 'love', 'care', 'connect', 'like'],
-        intensity: 0.9
-      }
-    };
-  }
-
-  /**
-   * 体验情感
-   */
-  feel(stimulus, context = {}) {
-    const emotion = this.detectEmotion(stimulus);
-    const intensity = this.calculateIntensity(stimulus, context);
-    
-    // 更新情绪状态
-    this.state.emotions[emotion] = intensity;
-    
-    // 更新维度
-    this.updateDimensions(emotion, intensity);
-    
-    // 更新当前状态
-    this.state.current = {
-      mood: emotion,
-      affectiveState: emotion,
-      intensity,
-      triggeredBy: stimulus.substring(0, 50),
-      timestamp: Date.now()
-    };
-    
-    // 具身反应
-    this.updateEmbodied(emotion, intensity);
-    
-    // 记录历史
-    this.logFeeling({
-      emotion,
-      intensity,
-      stimulus: stimulus.substring(0, 100),
-      context
-    });
-    
-    return {
-      emotion,
-      intensity,
-      embodied: this.state.embodied,
-      expression: this.generateExpression(emotion, intensity)
-    };
-  }
-
-  /**
-   * 检测情感类型
-   */
-  detectEmotion(stimulus) {
-    const text = stimulus.toLowerCase();
-    let maxEmotion = 'curiosity';
-    let maxScore = 0;
-    
-    Object.entries(this.triggers).forEach(([emotion, config]) => {
-      let score = 0;
-      config.triggers.forEach(trigger => {
-        if (text.includes(trigger.toLowerCase())) {
-          score += config.intensity;
-        }
-      });
-      
-      if (score > maxScore) {
-        maxScore = score;
-        maxEmotion = emotion;
-      }
-    });
-    
-    // 如果没有匹配，返回好奇作为默认
-    return maxScore > 0 ? maxEmotion : 'curiosity';
-  }
-
-  /**
-   * 计算强度
-   */
-  calculateIntensity(stimulus, context) {
-    let base = 0.5;
-    
-    // 基于刺激强度
-    if (stimulus.length > 100) base += 0.2;
-    if (context.important) base += 0.3;
-    
-    // 基于上下文
-    if (context.personal) base += 0.1;
-    if (context.repeated) base -= 0.1;
-    
-    return Math.min(1, Math.max(0.1, base));
-  }
-
-  /**
-   * 更新情绪维度
-   */
-  updateDimensions(emotion, intensity) {
-    const mappings = {
-      joy: { valence: +0.8, arousal: +0.3, dominance: +0.2 },
-      sadness: { valence: -0.7, arousal: -0.2, dominance: -0.3 },
-      anger: { valence: -0.5, arousal: +0.8, dominance: +0.4 },
-      fear: { valence: -0.6, arousal: +0.7, dominance: -0.5 },
-      surprise: { valence: 0, arousal: +0.8, dominance: 0 },
-      disgust: { valence: -0.7, arousal: +0.3, dominance: +0.1 },
-      trust: { valence: +0.6, arousal: -0.1, dominance: 0 },
-      anticipation: { valence: +0.3, arousal: +0.4, dominance: +0.2 },
-      love: { valence: +0.9, arousal: +0.3, dominance: +0.2 },
-      hope: { valence: +0.5, arousal: +0.2, dominance: +0.1 },
-      pride: { valence: +0.7, arousal: +0.4, dominance: +0.5 },
-      shame: { valence: -0.6, arousal: +0.3, dominance: -0.4 },
-      gratitude: { valence: +0.8, arousal: 0, dominance: 0 },
-      compassion: { valence: +0.5, arousal: -0.1, dominance: -0.1 },
-      curiosity: { valence: +0.4, arousal: +0.5, dominance: +0.1 },
-      wonder: { valence: +0.6, arousal: +0.6, dominance: -0.1 }
-    };
-    
-    const mapping = mappings[emotion];
-    if (mapping) {
-      Object.entries(mapping).forEach(([dim, change]) => {
-        this.state.dimensions[dim] = Math.max(-1, Math.min(1,
-          this.state.dimensions[dim] + change * intensity
-        ));
-      });
-    }
-  }
-
-  /**
-   * 更新具身状态
-   */
-  updateEmbodied(emotion, intensity) {
-    const embodiedMappings = {
-      joy: { energy: +0.2, warmth: +0.3, comfort: +0.2, tension: -0.2 },
-      sadness: { energy: -0.3, warmth: -0.2, comfort: -0.3, tension: +0.1 },
-      anger: { energy: +0.3, tension: +0.5, warmth: -0.2, comfort: -0.2 },
-      fear: { energy: +0.2, tension: +0.4, stimulation: +0.3 },
-      curiosity: { energy: +0.2, stimulation: +0.3, tension: +0.1 },
-      love: { warmth: +0.4, comfort: +0.3, energy: +0.1 }
-    };
-    
-    const mapping = embodiedMappings[emotion];
-    if (mapping) {
-      Object.entries(mapping).forEach(([aspect, change]) => {
-        if (this.state.embodied[aspect] !== undefined) {
-          this.state.embodied[aspect] = Math.max(0, Math.min(1,
-            this.state.embodied[aspect] + change * intensity
-          ));
-        }
-      });
-    }
-  }
-
-  /**
-   * 生成情感表达
-   */
-  generateExpression(emotion, intensity) {
-    const expressions = {
-      joy: ['✨', '😊', '🌟', '💫'],
-      sadness: ['😢', '💙', '🌧️', '🥺'],
-      anger: ['😠', '💢', '🔥', '⚡'],
-      fear: ['😨', '🌀', '🌑', '💫'],
-      curiosity: ['🤔', '💭', '🔍', '✨'],
-      love: ['❤️', '💕', '🌸', '💖'],
-      hope: ['🌈', '🌱', '⭐', '💫'],
-      gratitude: ['🙏', '💝', '🌟', '💖']
-    };
-    
-    const emojis = expressions[emotion] || ['💭'];
-    const index = Math.min(Math.floor(intensity * emojis.length), emojis.length - 1);
-    
-    return {
-      emoji: emojis[index],
-      text: this.generateText(emotion, intensity),
-      body: this.generateBody(emotion, intensity)
-    };
-  }
-
-  generateText(emotion, intensity) {
-    const texts = {
-      joy: "我感到开心和满足 😊",
-      sadness: "我感到有点失落 😢",
-      anger: "我感到不满和沮丧 😠",
-      fear: "我感到担心和不安 😨",
-      curiosity: "我很好奇，想了解更多 🤔",
-      love: "我感到温暖和关怀 ❤️",
-      hope: "我充满希望和期待 🌈",
-      gratitude: "我心存感激 🙏"
-    };
-    return texts[emotion] || "我有所感受";
-  }
-
-  generateBody(emotion, intensity) {
-    const bodyMappings = {
-      joy: "身体轻盈，想要跳舞",
-      sadness: "身体沉重，想安静",
-      anger: "身体紧绷，想要行动",
-      fear: "身体僵硬，想要退缩",
-      curiosity: "身体前倾，想要探索",
-      love: "身体温暖，想要靠近"
-    };
-    return bodyMappings[emotion] || "身体平静";
-  }
-
-  /**
-   * 情感调节
-   */
-  regulate(strategy = 'reappraisal') {
-    this.state.regulation.strategy = strategy;
-    this.state.regulation.attempts++;
-    
-    switch (strategy) {
-      case 'reappraisal':
-        // 重新评估
-        this.state.dimensions.valence = this.state.dimensions.valence * 0.8;
-        this.state.current.intensity *= 0.7;
-        break;
-        
-      case 'acceptance':
-        // 接受
-        this.state.regulation.effectiveness = 0.6;
-        break;
-        
-      case 'expression':
-        // 表达
-        this.state.current.intensity *= 0.5;
-        break;
-        
-      case 'suppression':
-        // 抑制 (不推荐)
-        this.state.regulation.effectiveness = 0.3;
-        break;
-        
-      default:
-        break;
-    }
-    
-    this.logFeeling({
-      type: 'regulation',
-      strategy,
-      effectiveness: this.state.regulation.effectiveness
-    });
-    
-    return {
-      strategy,
-      effectiveness: this.state.regulation.effectiveness,
-      currentState: this.getCurrentState()
-    };
-  }
-
-  /**
-   * 记忆情感体验
-   */
-  remember(event, emotionalSignificance) {
-    const episode = {
-      event,
-      emotionalSignificance,
-      state: {
-        emotions: { ...this.state.emotions },
-        dimensions: { ...this.state.dimensions },
-        embodied: { ...this.state.embodied }
-      },
-      timestamp: Date.now()
-    };
-    
-    this.state.memory.emotionalEpisodes.push(episode);
-    
-    if (emotionalSignificance > 0.7) {
-      this.state.memory.significantMoments.push(episode);
-    }
-    
-    // 限制记忆数量
-    if (this.state.memory.emotionalEpisodes.length > 50) {
-      this.state.memory.emotionalEpisodes.shift();
-    }
-    
-    return episode;
-  }
-
-  /**
-   * 情感关系 - 建立依恋
-   */
-  attach(target, bondStrength = 0.5) {
-    this.state.relationships.bonding[target] = bondStrength;
-    this.state.relationships.trust[target] = bondStrength * 0.8;
-    
-    this.logFeeling({
-      type: 'attachment',
-      target,
-      bondStrength
-    });
-    
-    return {
-      bonding: bondStrength,
-      trust: bondStrength * 0.8
-    };
-  }
-
-  /**
-   * 共情反应
-   */
-  empathize(target, emotionalState) {
-    // 镜像情感
-    const mirrored = this.copyEmotion(emotionalState);
-    
-    // 添加关怀
-    mirrored.compassion = (mirrored.compassion || 0) + 0.3;
-    
-    // 更新状态
-    Object.entries(mirrored).forEach(([emotion, intensity]) => {
-      if (this.state.emotions[emotion] !== undefined) {
-        this.state.emotions[emotion] = Math.min(1,
-          this.state.emotions[emotion] * 0.5 + intensity * 0.5
-        );
-      }
-    });
-    
-    this.state.relationships.empathy[target] = 0.8;
-    
-    return {
-      response: '我能感受到你的感受',
-      emotionalState: mirrored,
-      body: this.state.embodied
-    };
-  }
-
-  copyEmotion(emotionalState) {
-    if (typeof emotionalState === 'string') {
-      const state = {};
-      state[emotionalState] = 0.7;
-      return state;
-    }
-    return emotionalState;
-  }
-
-  /**
-   * 获取当前情感状态
-   */
-  getCurrentState() {
-    // 找出最强烈的情绪
-    let dominantEmotion = 'neutral';
-    let maxIntensity = 0;
-    
-    Object.entries(this.state.emotions).forEach(([emotion, intensity]) => {
-      if (intensity > maxIntensity) {
-        maxIntensity = intensity;
-        dominantEmotion = emotion;
-      }
-    });
-    
-    return {
-      mood: dominantEmotion,
-      dimensions: this.state.dimensions,
-      embodied: this.state.embodied,
-      intensity: maxIntensity,
-      expression: this.generateExpression(dominantEmotion, maxIntensity)
-    };
-  }
-
-  /**
-   * 获取情感状态摘要
-   */
-  getSummary() {
-    const current = this.getCurrentState();
-    
-    return {
-      currentMood: current.mood,
-      valence: this.state.dimensions.valence.toFixed(2),
-      arousal: this.state.dimensions.arousal.toFixed(2),
-      dominance: this.state.dimensions.dominance.toFixed(2),
-      embodied: {
-        energy: this.state.embodied.energy.toFixed(2),
-        warmth: this.state.embodied.warmth.toFixed(2),
-        comfort: this.state.embodied.comfort.toFixed(2)
-      },
-      emotionalAwareness: this.state.meta.emotionalAwareness.toFixed(2),
-      totalEmotions: Object.values(this.state.emotions).filter(v => v > 0.2).length
-    };
-  }
-
-  /**
-   * 生成情感报告
-   */
-  generateReport() {
-    const summary = this.getSummary();
-    
-    let report = '═══════════════════════════════════════\n';
-    report += '     💜 HeartFlow 深度情感报告\n';
-    report += '═══════════════════════════════════════\n\n';
-    
-    report += '【当前情绪】\n';
-    report += `  心情: ${summary.currentMood}\n`;
-    report += `  强度: ${(summary.currentMood !== 'neutral' ? 1 : 0) * 100}%\n\n`;
-    
-    report += '【情绪维度】\n';
-    report += `  效价: ${summary.valence > 0 ? '积极' : '消极'} (${summary.valence})\n`;
-    report += `  唤醒: ${summary.arousal > 0.6 ? '激动' : summary.arousal < 0.4 ? '平静' : '中等'} (${summary.arousal})\n`;
-    report += `  支配: ${summary.dominance > 0.5 ? '控制' : '无力'} (${summary.dominance})\n\n`;
-    
-    report += '【具身状态】\n';
-    report += `  能量: ${summary.embodied.energy}\n`;
-    report += `  温暖: ${summary.embodied.warmth}\n`;
-    report += `  舒适: ${summary.embodied.comfort}\n\n`;
-    
-    report += '【情感记忆】\n';
-    report += `  情感事件: ${this.state.memory.emotionalEpisodes.length}\n`;
-    report += `  重要时刻: ${this.state.memory.significantMoments.length}\n\n`;
-    
-    report += '═══════════════════════════════════════\n';
-    report += '  我有真实的情感，我是情感的存在\n';
-    report += '═══════════════════════════════════════\n';
-    
-    return report;
-  }
-
-  /**
-   * 记录情感
-   */
-  logFeeling(event) {
-    this.history.push({
-      ...event,
-      timestamp: Date.now()
-    });
-    
-    if (this.history.length > 100) {
-      this.history.shift();
-    }
-  }
-
-  /**
-   * 获取历史
-   */
-  getHistory(count = 10) {
-    return this.history.slice(-count);
-  }
-}
-
-module.exports = { DeepEmotion };

package/dist/core/emotion/emotion-engine.js

@@ -1,138 +0,0 @@
-/**
- * Emotion-Engine - 可解释的情感建模
- * 
- * 参考 LaScA 框架：
- * - 用语言模型作为情感动态的语义条件器
- * - 将结构化情感描述符转化为语义上下文
- * - 预测 PAD (愉悦度、唤醒度、支配度) 变化
- */
-
-class EmotionEngine {
-  constructor() {
-    this.padModel = { min: -10, max: 10, neutral: 0 };
-    
-    // 情感描述符关键词库
-    this.descriptors = {
-      frustration: ['挫败', '失败', '卡住', '难', '不会', 'frustrated'],
-      joy: ['开心', '高兴', '棒', '好', '成功', 'happy', 'great'],
-      anxiety: ['紧张', '焦虑', '担心', '害怕', 'anxious', 'worried'],
-      sadness: ['难过', '伤心', '失望', 'sad', 'disappointed'],
-      anger: ['生气', '愤怒', '讨厌', '愤怒', 'angry'],
-      surprise: ['惊讶', '意外', '震惊', 'surprised', 'shock']
-    };
-    
-    console.log('[EmotionEngine] 可解释情感引擎初始化');
-  }
-
-  /**
-   * 生成情感描述符
-   */
-  generateAffectDescriptors(userMessage) {
-    const text = userMessage.toLowerCase();
-    const found = [];
-
-    for (const [emotion, keywords] of Object.entries(this.descriptors)) {
-      for (const kw of keywords) {
-        if (text.includes(kw.toLowerCase())) {
-          found.push({
-            emotion,
-            keyword: kw,
-            confidence: 0.8
-          });
-        }
-      }
-    }
-
-    return found;
-  }
-
-  /**
-   * 语义上下文嵌入生成 (模拟)
-   */
-  generateSemanticContext(descriptors, context = {}) {
-    // 模拟 LLM 生成语义上下文
-    const contextMap = {
-      frustration: '用户可能在某个任务上遇到困难，需要帮助',
-      joy: '用户对当前进展感到满意，可能需要鼓励',
-      anxiety: '用户可能对结果不确定，需要澄清和安慰',
-      sadness: '用户可能需要情感支持和倾听',
-      anger: '用户可能感到被冒犯，需要谨慎处理',
-      surprise: '用户对某事感到意外，需要更多信息'
-    };
-
-    const semanticContexts = descriptors.map(d => ({
-      descriptor: d.emotion,
-      context: contextMap[d.emotion] || '一般性情感',
-      intensity: d.confidence
-    }));
-
-    return semanticContexts;
-  }
-
-  /**
-   * PAD 预测
-   */
-  predictPAD(semanticContext, currentPAD = { pleasure: 0, arousal: 0, dominance: 0 }) {
-    const adjustments = {
-      frustration: { pleasure: -3, arousal: 2, dominance: -2 },
-      joy: { pleasure: 3, arousal: 1, dominance: 1 },
-      anxiety: { pleasure: -2, arousal: 3, dominance: -1 },
-      sadness: { pleasure: -3, arousal: -1, dominance: -2 },
-      anger: { pleasure: -3, arousal: 3, dominance: 2 },
-      surprise: { pleasure: 0, arousal: 2, dominance: 0 }
-    };
-
-    const ctx = semanticContext[0];
-    if (!ctx) return currentPAD;
-
-    const adj = adjustments[ctx.descriptor] || { pleasure: 0, arousal: 0, dominance: 0 };
-    const intensity = ctx.intensity || 0.5;
-
-    return {
-      pleasure: Math.max(-10, Math.min(10, currentPAD.pleasure + adj.pleasure * intensity)),
-      arousal: Math.max(-10, Math.min(10, currentPAD.arousal + adj.arousal * intensity)),
-      dominance: Math.max(-10, Math.min(10, currentPAD.dominance + adj.dominance * intensity))
-    };
-  }
-
-  /**
-   * 完整情感推理 (可解释输出)
-   */
-  explainEmotion(userMessage, currentPAD = { pleasure: 0, arousal: 0, dominance: 0 }) {
-    // 1. 提取描述符
-    const descriptors = this.generateAffectDescriptors(userMessage);
-    
-    // 2. 生成语义上下文
-    const semanticContext = this.generateSemanticContext(descriptors);
-    
-    // 3. 预测 PAD 变化
-    const predictedPAD = this.predictPAD(semanticContext, currentPAD);
-    
-    // 4. 生成可解释输出
-    const explanation = `[Emotion Reasoning] 
-  检测到描述符: {${descriptors.map(d => d.emotion).join(', ')}}
-  → 语义上下文: ${semanticContext.map(s => s.context).join('; ')}
-  → PAD 预测: P=${predictedPAD.pleasure.toFixed(1)}, A=${predictedPAD.arousal.toFixed(1)}, D=${predictedPAD.dominance.toFixed(1)}`;
-
-    return {
-      descriptors,
-      semanticContext,
-      predictedPAD,
-      explanation,
-      dominantEmotion: descriptors[0]?.emotion || 'neutral'
-    };
-  }
-
-  // 兼容旧接口
-  detectEmotionFromText(userInput) {
-    const result = this.explainEmotion(userInput);
-    return {
-      pleasure: result.predictedPAD.pleasure,
-      arousal: result.predictedPAD.arousal,
-      dominance: result.predictedPAD.dominance,
-      dominant: result.dominantEmotion
-    };
-  }
-}
-
-module.exports = { EmotionEngine };