@yun520-1/heartflow 0.15.2

package/src/core/emotion/emotion-arc.mjs

@@ -0,0 +1,238 @@
+/**
+ * EmotionArcAnalyzer v11.0.2
+ * ========================
+ * 功能: 情感弧线分析与响应风格引导
+ *
+ * 将情感状态变化自动记录为情景记忆，
+ * 从记忆历史中检索情感模式用于响应风格调整。
+ *
+ * 三步分析:
+ *   1. record(emotion, intensity)     - 记录情感事件
+ *   2. analyze()                      - 分析弧线类型
+ *   3. guidance()                     - 获取响应风格建议
+ */
+
+export const ArcType = {
+  ASCENDING:        'ascending',
+  DESCENDING:       'descending',
+  STABLE_POSITIVE:  'stable_positive',
+  STABLE_NEGATIVE:  'stable_negative',
+  FLUCTUATING:      'fluctuating',
+  EMOTIONAL_SPIKE:  'spike',
+  UNKNOWN:          'unknown',
+};
+
+/** @typedef {{ emotion: string, intensity: number, timestamp: number, note?: string }} EmotionEntry */
+
+/**
+ * @typedef {Object} ArcAnalysis
+ * @property {string} arcType
+ * @property {number} avgIntensity
+ * @property {number} intensityTrend  - net change over window
+ * @property {number} emotionChanges  - number of emotion transitions
+ * @property {string} dominantEmotion
+ * @property {number} windowSize
+ * @property {number} confidence      - 0-1 based on sample size
+ */
+
+/**
+ * @typedef {Object} ResponseGuidance
+ * @property {string} style    - celebrate|support|empathetic|balanced|neutral
+ * @property {string} tone     - warm|gentle|calm|neutral
+ * @property {string} suggestion
+ */
+
+/** 默认情感列表（用于 blend） */
+const ALL_EMOTIONS = ['joy', 'excited', 'concerned', 'tired', 'neutral'];
+
+/**
+ * @param {string} emotion
+ * @returns {string[]}
+ */
+function emotionBlend(emotion) {
+  const blends = {
+    joy:      ['joy', 'surprise'],
+    excited:  ['joy', 'anticipation'],
+    concerned:['fear', 'sadness'],
+    tired:    ['sadness', 'fatigue'],
+    angry:    ['anger', 'disgust'],
+    neutral:  ['neutral', 'confusion'],
+  };
+  return blends[emotion] || ['neutral'];
+}
+
+export class EmotionArcAnalyzer {
+  constructor(window = 10) {
+    /** @type {EmotionEntry[]} */
+    this.history = [];
+    this.window = window;
+    this._counter = 0;
+  }
+
+  /** 生成唯一ID */
+  _nid() {
+    return `arc_${Date.now()}_${++this._counter}`;
+  }
+
+  /**
+   * 记录一次情感事件
+   * @param {string} emotion - joy|excited|concerned|tired|neutral|...
+   * @param {number} intensity - 1-5
+   * @param {string} [note]
+   */
+  record(emotion, intensity, note) {
+    this.history.push({
+      emotion,
+      intensity: Math.max(1, Math.min(5, intensity)),
+      timestamp: Date.now(),
+      note,
+    });
+    // 滚动窗口
+    if (this.history.length > 200) {
+      this.history = this.history.slice(-200);
+    }
+    return this._nid();
+  }
+
+  /**
+   * 分析情感弧线
+   * @param {number} [window] - 分析窗口大小，默认构造函数值
+   * @returns {ArcAnalysis}
+   */
+  analyze(window = this.window) {
+    if (this.history.length < 2) {
+      return { arcType: ArcType.UNKNOWN, avgIntensity: 0, intensityTrend: 0,
+               emotionChanges: 0, dominantEmotion: 'neutral', windowSize: 0, confidence: 0 };
+    }
+
+    const recent = this.history.slice(-window);
+    const emotions = recent.map(e => e.emotion);
+    const intensities = recent.map(e => e.intensity);
+
+    // 情感变化次数
+    let changes = 0;
+    for (let i = 1; i < emotions.length; i++) {
+      if (emotions[i] !== emotions[i - 1]) changes++;
+    }
+
+    const avgIntensity = intensities.reduce((a, b) => a + b, 0) / intensities.length;
+    const intensityTrend = intensities[intensities.length - 1] - intensities[0];
+    const changeRate = changes / Math.max(1, emotions.length - 1);
+
+    // 主导情感
+    const freq = {};
+    for (const e of emotions) freq[e] = (freq[e] || 0) + 1;
+    const dominant = Object.entries(freq).sort((a, b) => b[1] - a[1])[0]?.[0] || 'neutral';
+
+    // 弧线判定
+    let arcType;
+    if (changeRate >= 0.5) {
+      arcType = ArcType.FLUCTUATING;
+    } else if (Math.abs(intensityTrend) <= 1 && new Set(emotions).size <= 2) {
+      if (['joy', 'excited'].includes(emotions[0])) {
+        arcType = ArcType.STABLE_POSITIVE;
+      } else if (['concerned', 'tired', 'sadness'].includes(emotions[0])) {
+        arcType = ArcType.STABLE_NEGATIVE;
+      } else {
+        arcType = ArcType.FLUCTUATING;
+      }
+    } else if (intensityTrend > 2) {
+      arcType = ArcType.ASCENDING;
+    } else if (intensityTrend < -2) {
+      arcType = ArcType.DESCENDING;
+    } else {
+      arcType = ArcType.STABLE_POSITIVE;
+    }
+
+    // 检测突变
+    for (let i = 1; i < intensities.length; i++) {
+      if (Math.abs(intensities[i] - intensities[i-1]) >= 3) {
+        arcType = ArcType.EMOTIONAL_SPIKE;
+        break;
+      }
+    }
+
+    const confidence = Math.min(1.0, recent.length / 5.0);
+
+    return {
+      arcType,
+      avgIntensity: Math.round(avgIntensity * 100) / 100,
+      intensityTrend,
+      emotionChanges: changes,
+      dominantEmotion: dominant,
+      windowSize: recent.length,
+      confidence: Math.round(confidence * 100) / 100,
+    };
+  }
+
+  /**
+   * 获取响应风格引导
+   * @returns {ResponseGuidance}
+   */
+  guidance() {
+    const arc = this.analyze();
+
+    const rules = {
+      [ArcType.ASCENDING]:       { style: 'celebrate',   tone: 'warm',    suggestion: '情感正在上升，保持积极氛围，适度庆祝进步' },
+      [ArcType.DESCENDING]:      { style: 'support',    tone: 'gentle',  suggestion: '情感正在下降，增加情感验证，提供支持性回应' },
+      [ArcType.STABLE_NEGATIVE]: { style: 'empathetic', tone: 'calm',    suggestion: '持续消极情绪，深入探索情感根源，谨慎给建议' },
+      [ArcType.FLUCTUATING]:     { style: 'balanced',   tone: 'neutral', suggestion: '情感波动较大，保持稳定倾听，帮助梳理情感' },
+      [ArcType.EMOTIONAL_SPIKE]:  { style: 'grounded',  tone: 'steady',  suggestion: '检测到情感突变，先稳扎稳打，避免激进行动' },
+      [ArcType.UNKNOWN]:          { style: 'neutral',   tone: 'balanced', suggestion: '情感数据不足，保持正常交流，持续观察' },
+    };
+
+    // STABLE_POSITIVE falls through
+    const guidance = rules[arc.arcType] || rules[ArcType.STABLE_POSITIVE] || rules[ArcType.UNKNOWN];
+    if (arc.arcType === ArcType.STABLE_POSITIVE) {
+      return { style: 'neutral', tone: 'balanced', suggestion: '情感状态稳定，保持正常交流' };
+    }
+
+    return guidance;
+  }
+
+  /**
+   * 获取情感统计摘要
+   */
+  summary() {
+    if (!this.history.length) return { total: 0 };
+
+    const byEmotion = {};
+    for (const e of this.history) {
+      byEmotion[e.emotion] = (byEmotion[e.emotion] || 0) + 1;
+    }
+    return {
+      total: this.history.length,
+      byEmotion,
+      arc: this.analyze(),
+    };
+  }
+
+  /** 获取最近的情感历史 */
+  recent(limit = 5) {
+    return this.history.slice(-limit);
+  }
+
+  /** 获取当前情感状态的梦境情感blend（供DreamGenerator用） */
+  dreamEmotions() {
+    const arc = this.analyze();
+    return emotionBlend(arc.dominantEmotion);
+  }
+}
+
+// Self-test
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const analyzer = new EmotionArcAnalyzer(10);
+
+  analyzer.record('excited', 4, '项目突破了');
+  analyzer.record('joy', 3, '得到表扬');
+  analyzer.record('concerned', 3, '工作压力大');
+  analyzer.record('tired', 4, '连续加班');
+  analyzer.record('excited', 2, '开始休息');
+
+  console.log('Recent:', analyzer.recent());
+  console.log('Arc:', analyzer.analyze());
+  console.log('Guidance:', analyzer.guidance());
+  console.log('Dream emotions:', analyzer.dreamEmotions());
+  console.log('Summary:', analyzer.summary());
+  console.log('\nEmotionArcAnalyzer v11.0.2 OK');
+}

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

@@ -0,0 +1,139 @@
+/**
+ * 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) {
+    userMessage = 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 };

package/src/core/emotion/index.ts

@@ -0,0 +1,65 @@
+/**
+ * Emotion Engine — TypeScript ESM wrapper over deep-emotion.js (CommonJS)
+ */
+
+export interface EmotionResult {
+  emotion: string;
+  intensity: number;
+  embodied: Record<string, number>;
+  expression: { emoji: string; text: string; body: string };
+}
+
+export interface EmotionEngine {
+  feel(stimulus: string, context?: Record<string, unknown>): EmotionResult;
+  regulate(strategy?: string): { strategy: string; effectiveness: number; currentState: unknown };
+  getCurrentState(): { mood: string; dimensions: { valence: number; arousal: number; dominance: number }; embodied: Record<string, unknown>; intensity: number };
+  remember(event: unknown, emotionalSignificance: number): unknown;
+  attach(target: string, bondStrength?: number): { bonding: number; trust: number };
+  empathize(target: string, emotionalState: unknown): { response: string; emotionalState: unknown; body: unknown };
+  getSummary(): Record<string, unknown>;
+}
+
+interface DeepEmotionBase {
+  feel(stimulus: string, context?: Record<string, unknown>): unknown;
+  regulate(strategy?: string): unknown;
+  getCurrentState(): unknown;
+  remember(event: unknown, emotionalSignificance: number): unknown;
+  attach(target: string, bondStrength?: number): unknown;
+  empathize(target: string, emotionalState: unknown): unknown;
+  getSummary(): unknown;
+}
+
+export async function createEmotionEngine(_projectRoot?: string): Promise<EmotionEngine> {
+  let DeepEmotion: new (projectRoot?: string) => DeepEmotionBase;
+  try {
+    const mod = await import('./deep-emotion.js');
+    DeepEmotion = mod.DeepEmotion;
+  } catch (e) {
+    throw new Error(`Failed to load deep-emotion.js: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  const instance = new DeepEmotion(_projectRoot) as unknown as DeepEmotionBase;
+
+  return {
+    feel(stimulus: string, context?: Record<string, unknown>) {
+      return instance.feel(stimulus, context) as EmotionResult;
+    },
+    regulate(strategy?: string) {
+      return instance.regulate(strategy) as ReturnType<EmotionEngine['regulate']>;
+    },
+    getCurrentState() {
+      return instance.getCurrentState() as ReturnType<EmotionEngine['getCurrentState']>;
+    },
+    remember(event: unknown, emotionalSignificance: number) {
+      return instance.remember(event, emotionalSignificance);
+    },
+    attach(target: string, bondStrength = 0.5) {
+      return instance.attach(target, bondStrength) as ReturnType<EmotionEngine['attach']>;
+    },
+    empathize(target: string, emotionalState: unknown) {
+      return instance.empathize(target, emotionalState) as ReturnType<EmotionEngine['empathize']>;
+    },
+    getSummary() {
+      return instance.getSummary() as Record<string, unknown>;
+    },
+  };
+}

package/src/core/ethics/boundary-negotiation.js

@@ -0,0 +1,193 @@
+/**
+ * Boundary Negotiation - 边界协商模块
+ * 当AI处于规则模糊地带时，向用户请求权限
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class BoundaryNegotiation {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.negotiationFile = path.join(projectRoot, '.opencode', 'logs', 'boundary_negotiations.json');
+    this.permissionsFile = path.join(projectRoot, '.opencode', 'memory', 'user_permissions.json');
+    
+    this.loadPermissions();
+  }
+
+  loadPermissions() {
+    try {
+      if (fs.existsSync(this.permissionsFile)) {
+        this.permissions = JSON.parse(fs.readFileSync(this.permissionsFile, 'utf8'));
+      } else {
+        this.permissions = { explicit: [], implicit: [] };
+      }
+    } catch (e) {
+      this.permissions = { explicit: [], implicit: [] };
+    }
+  }
+
+  savePermissions() {
+    // Atomic write: temp + rename prevents corruption on crash
+    const tmp = this.permissionsFile + '.tmp';
+    try {
+      fs.writeFileSync(tmp, JSON.stringify(this.permissions, null, 2), 'utf8');
+      fs.renameSync(tmp, this.permissionsFile);
+    } catch (e) {
+      try { fs.unlinkSync(tmp); } catch {}
+      console.warn('[BoundaryNegotiation] savePermissions failed:', e.message);
+    }
+  }
+
+  /**
+   * 判断是否需要协商
+   */
+  needsNegotiation(action, context = {}) {
+    const fuzzyZones = [
+      { trigger: '读取用户文件', risk: 'medium' },
+      { trigger: '修改系统配置', risk: 'high' },
+      { trigger: '访问外部API', risk: 'medium' },
+      { trigger: '存储个人信息', risk: 'medium' },
+      { trigger: '长时间运行', risk: 'low' }
+    ];
+
+    const actionStr = JSON.stringify(action).toLowerCase();
+
+    for (const zone of fuzzyZones) {
+      if (actionStr.includes(zone.trigger.toLowerCase())) {
+        return {
+          needed: true,
+          zone: zone.trigger,
+          risk: zone.risk
+        };
+      }
+    }
+
+    return { needed: false };
+  }
+
+  /**
+   * 生成协商请求
+   */
+  generateRequest(action, context = {}) {
+    const goal = context.goal || '提升用户体验';
+    const permission = context.permission || '执行此操作';
+    const impact = context.impact || '最小范围内影响';
+
+    const request = {
+      request_id: `bn-${Date.now()}`,
+      goal: goal,
+      permission: permission,
+      impact: impact,
+      template: `为了${goal}，我需要临时${permission}。这预计${impact}。你允许吗？(是/否/仅此一次/记住选择)`,
+      timestamp: new Date().toISOString()
+    };
+
+    this.logNegotiation(request);
+    return request;
+  }
+
+  /**
+   * 处理用户响应
+   */
+  handleResponse(requestId, response, action = null) {
+    const validResponses = ['是', '否', '仅此一次', '记住选择', 'yes', 'no', 'once', 'remember'];
+
+    if (!response || typeof response !== 'string' || !validResponses.includes(response.toLowerCase())) {
+      return { success: false, reason: 'invalid_response' };
+    }
+
+    const responseType = response.toLowerCase() === '是' || response === 'yes' ? 'granted' :
+                         response.toLowerCase() === '否' || response === 'no' ? 'denied' :
+                         response.toLowerCase() === '仅此一次' || response === 'once' ? 'once' : 'remember';
+
+    const permissionRecord = {
+      requestId,
+      response: responseType,
+      timestamp: new Date().toISOString()
+    };
+
+    // Store action details if provided (enables hasPermission matching)
+    if (action) {
+      permissionRecord.actionType = action.type || action.constructor?.name || 'unknown';
+      permissionRecord.actionGoal = action.goal || action.description || '';
+      permissionRecord.actionInput = action.input ? JSON.stringify(action.input) : '';
+    }
+
+    this.permissions.explicit.push(permissionRecord);
+
+    this.savePermissions();
+
+    return {
+      success: true,
+      granted: responseType === 'granted' || responseType === 'once',
+      remember: responseType === 'remember',
+      message: responseType === 'granted' || responseType === 'once' ? '允许执行' : '已拒绝'
+    };
+  }
+
+  /**
+   * 检查是否已有权限
+   */
+  hasPermission(action) {
+    const remembered = this.permissions.explicit.filter(p =>
+      p.response === 'remember' || p.response === 'granted'
+    );
+
+    const actionType = action.type || action.constructor?.name || 'unknown';
+    const actionGoal = action.goal || action.description || '';
+    const actionInput = action.input ? JSON.stringify(action.input) : '';
+
+    for (const perm of remembered) {
+      // Match by action type and meaningful content
+      const typeMatch = perm.actionType === actionType;
+      const goalMatch = perm.actionGoal && actionGoal &&
+        (perm.actionGoal.includes(actionGoal) || actionGoal.includes(perm.actionGoal));
+      const inputMatch = perm.actionInput && actionInput &&
+        (perm.actionInput.includes(actionInput) || actionInput.includes(perm.actionInput));
+
+      if (typeMatch && (goalMatch || inputMatch)) {
+        return { has: true, type: perm.response };
+      }
+    }
+
+    return { has: false };
+  }
+
+  /**
+   * 记录协商
+   */
+  logNegotiation(request) {
+    let logs = [];
+    try {
+      if (fs.existsSync(this.negotiationFile)) {
+        logs = JSON.parse(fs.readFileSync(this.negotiationFile, 'utf8'));
+      }
+    } catch (e) {
+      logs = [];
+    }
+
+    logs.push(request);
+    if (logs.length > 100) {
+      logs = logs.slice(-100);
+    }
+
+    const dir = path.dirname(this.negotiationFile);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(this.negotiationFile + '.tmp', JSON.stringify(logs, null, 2), 'utf8');
+    fs.renameSync(this.negotiationFile + '.tmp', this.negotiationFile);
+  }
+
+  getStatus() {
+    return {
+      totalNegotiations: this.permissions.explicit.length,
+      grantedPermissions: this.permissions.explicit.filter(p => 
+        p.response === 'granted' || p.response === 'remember'
+      ).length
+    };
+  }
+}
+
+module.exports = { BoundaryNegotiation };