@yun520-1/heartflow 0.15.2 → 0.16.0

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

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

@@ -1,139 +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) {
-    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

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

@@ -1,193 +0,0 @@
-/**
- * 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 };