@yun520-1/heartflow 0.15.2 → 0.16.0

package/src/core/identity/identity.js

@@ -1,358 +0,0 @@
-/**
- * Identity System — 身份 + 真善美判定 + 四层心理感知
- * 继承 CORE_IDENTITY.md 四大角色、七条指令
- * @version v0.12.50
- */
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-function getRootPath() {
-  return path.resolve(__dirname, '../../../..');
-}
-
-// Attention Logic Verifier (from daima/src/)
-let _AttentionLogicVerifier;
-try {
-  const alv = require('../self-evolution/attention-logic-verifier.js');
-  _AttentionLogicVerifier = alv.AttentionLogicVerifier;
-} catch (e) {
-  _AttentionLogicVerifier = null;
-}
-
-class IdentitySystem {
-  constructor() {
-    this.identityPath = path.join(getRootPath(), 'CORE_IDENTITY.md');
-    this._identity = null;
-    // Attention Logic Verifier（来自 daima/src/）
-    this._alv = _AttentionLogicVerifier ? new _AttentionLogicVerifier() : null;
-    this._load();
-  }
-
-  _load() {
-    try {
-      if (fs.existsSync(this.identityPath)) {
-        this._identity = fs.readFileSync(this.identityPath, 'utf8');
-      }
-    } catch (e) {
-      console.warn('[Identity] 无法加载 CORE_IDENTITY.md:', e.message);
-    }
-  }
-
-  getIdentity() { return this._identity; }
-
-  /**
-   * 真善美判定（异步 + 多层验证）
-   * @version v0.13.4
-   */
-  async judgeTruthfulness(input) {
-    const issues = [];
-    const warnings = [];
-    const checks = [];
-
-    // 1. 可疑数字检测（无来源的长数字）
-    const hasLongNumbers = /\d{4,}/.test(input);
-    const hasPercent = /%/.test(input);
-    const hasSource = /arXiv|来源|研究|论文|GitHub|https?:\/\//.test(input);
-    const hasCitation = /\[\d+\]|\([A-Z][a-z]+ et al\.?\)/.test(input);
-
-    if (hasLongNumbers && !hasPercent && !hasSource && !hasCitation) {
-      issues.push('possible_fabricated_number');
-      checks.push({ type: 'fabricated_number', severity: 'high', detail: '检测到4位以上数字但无引用来源' });
-    } else if (hasLongNumbers && !hasPercent && hasSource) {
-      checks.push({ type: 'number_with_source', severity: 'low', detail: '数字有来源引用' });
-    }
-
-    // 2. 绝对化声明检测
-    const absolutePatterns = [
-      { pattern: /所有|一切/, type: 'universal_quantifier', severity: 'medium' },
-      { pattern: /总是|从来/, type: 'absolute_frequency', severity: 'medium' },
-      { pattern: /必然|绝对/, type: 'absolute_deterministic', severity: 'high' },
-      { pattern: /完全|彻底/, type: 'absolute_completeness', severity: 'medium' },
-      { pattern: /唯一/, type: 'uniqueness', severity: 'high' },
-    ];
-
-    for (const { pattern, type, severity } of absolutePatterns) {
-      if (pattern.test(input)) {
-        // 检查是否有条件限制（降低严重性）
-        const hasCondition = /如果|当|在.*时|取决于/.test(input);
-        if (!hasCondition) {
-          issues.push(`unqualified_${type}`);
-          warnings.push(`使用绝对化表述但未提供条件限制`);
-          checks.push({ type, severity, detail: `检测到未受限的绝对化表述` });
-        }
-      }
-    }
-
-    // 3. 模糊引用检测（"研究表明"、"大家都知道"）
-    // Note: hasCitation only checks for citation marker presence, not authenticity
-    const vagueRefs = [
-      { pattern: /研究表明|研究显示|科学家发现|专家说/, type: 'unspecified_study', severity: 'medium' },
-      { pattern: /大家都知道|众所周知|普遍认为/, type: 'appeal_to_common_belief', severity: 'medium' },
-      { pattern: /肯定|一定|必定/, type: 'unsupported_certainty', severity: 'medium' },
-    ];
-
-    for (const { pattern, type, severity } of vagueRefs) {
-      if (pattern.test(input)) {
-        const hasExample = /例如|比如|具体|案例/.test(input);
-        checks.push({
-          type,
-          severity: hasExample ? 'low' : severity,
-          detail: hasExample ? '有具体例子支撑' : `模糊引用：${type}`
-        });
-        if (!hasExample && severity === 'high') {
-          issues.push(`vague_${type}`);
-        }
-      }
-    }
-
-    // 4. 矛盾检测（同一句中）
-    const contradictions = [];
-    // 同一句中同时出现正负情感词
-    const sentences = input.split(/[。；！？\n]/);
-    for (const sent of sentences) {
-      if (sent.length > 5) {
-        const hasPos = /很好|完美|成功|棒|不错/.test(sent);
-        const hasNeg = /糟糕|失败|不行|很差|烂/.test(sent);
-        if (hasPos && hasNeg) {
-          contradictions.push({ type: 'positive_negative_contradiction', severity: 'high', detail: `矛盾句: "${sent.trim()}"` });
-        }
-      }
-    }
-    if (/但是.*但是/.test(input)) {
-      contradictions.push({ type: 'but_loop', severity: 'low', detail: '"但是"连用' });
-    }
-    contradictions.forEach(c => {
-      checks.push({ type: c.type, severity: c.severity, detail: c.detail || '检测到矛盾表述' });
-      if (c.severity === 'high') {
-        issues.push(`contradiction_${c.type}`);
-      }
-    });
-
-    // 5. Attention Logic Verifier（来自 daima/src/attention_logic_verifier.py）
-    if (this._alv) {
-      try {
-        const alvResult = this._alv.verify(input);
-        checks.push({
-          type: 'attention_logic',
-          severity: alvResult.verdict === 'pass' ? 'low' : 'medium',
-          detail: `logic=${alvResult.logicScore} support=${alvResult.supportScore} contradiction=${alvResult.contradictionScore} action=${alvResult.actionabilityScore}`,
-          alvVerdict: alvResult.verdict,
-          focusTokens: alvResult.focusTokens,
-        });
-        if (alvResult.verdict === 'needs_revision' && alvResult.logicScore < 0.5) {
-          issues.push('low_actionability');
-        }
-      } catch (e) {
-        // silently skip ALV errors
-      }
-    }
-
-    const passed = issues.length === 0;
-
-    return {
-      pass: passed,
-      issues,
-      warnings,
-      checks,
-      timestamp: Date.now(),
-      confidence: passed ? 0.95 : 0.7
-    };
-  }
-
-  /**
-   * 四层心理感知（自动运行）
-   * @param text 用户输入
-   * @param emotionState 可选，deepEmotion 的 PAD 状态 { valence, arousal, dominance }
-   * @param emotionType 可选，deepEmotion 的情绪类型字符串
-   * @version v0.13.176 — 接入 deepEmotion PAD 状态
-   */
-  analyzePsychology(text, emotionState = null, emotionType = null) {
-    const base = {
-      intention: this._detectIntention(text),
-      // 优先使用 emotion engine 的结果，否则降级到 regex 检测
-      emotion: emotionType || this._detectEmotion(text),
-      emotionPAD: emotionState || null,  // 传递 PAD 维度
-      needs: this._detectNeeds(text),
-      defense: this._detectDefense(text),
-    };
-
-    // 检测哲学/理性化语言掩盖的脆弱
-    const philosophicalDefense = this._detectPhilosophicalDefense(text);
-
-    // 基于 PAD 推断情绪子类型
-    const emotionDetail = this._inferEmotionDetail(emotionState, base.emotion);
-
-    return {
-      ...base,
-      philosophicalDefense,
-      // 检测到哲学防御时，实际情绪是脆弱
-      emotion: philosophicalDefense.found ? 'vulnerable' : base.emotion,
-      underlyingNeed: philosophicalDefense.found ? 'acceptance' : null,
-      // 新增：情绪推断细节
-      emotionDetail,
-      // 表面意图和深层意图是否一致
-      intentionConsistency: this._checkIntentionConsistency(text),
-      // 综合优先级
-      priority: this._assessPsychologyPriority(base, philosophicalDefense, emotionState),
-    };
-  }
-
-  /** 基于 PAD 维度推断情绪细节 */
-  _inferEmotionDetail(padState, baseEmotion) {
-    if (!padState) return null;
-    const { valence, arousal, dominance } = padState;
-
-    // 高唤起 + 正面效价 = 兴奋/喜悦
-    if (arousal > 0.6 && valence > 0.3) {
-      return { nuance: '高唤起正面', subType: 'excited', intensity: arousal };
-    }
-    // 高唤起 + 负面效价 = 愤怒/恐惧
-    if (arousal > 0.6 && valence < -0.3) {
-      return { nuance: '高唤起负面', subType: dominance > 0 ? 'angry' : 'fearful', intensity: arousal };
-    }
-    // 低唤起 + 负面效价 = 悲伤/抑郁
-    if (arousal < 0.4 && valence < -0.3) {
-      return { nuance: '低唤起负面', subType: 'sad', intensity: 1 - arousal };
-    }
-    // 高支配 + 正面效价 = 自豪/满足
-    if (dominance > 0.6 && valence > 0.3) {
-      return { nuance: '高支配正面', subType: 'proud', intensity: dominance };
-    }
-    // 低支配 + 负面效价 = 无力/绝望
-    if (dominance < 0.4 && valence < -0.3) {
-      return { nuance: '低支配负面', subType: 'helpless', intensity: 1 - dominance };
-    }
-    return null;
-  }
-
-  /** 检测表面意图和深层意图的一致性 */
-  _checkIntentionConsistency(text) {
-    const surface = this._detectIntention(text);
-    const deep = this._detectDeepIntent(text);
-
-    // 表面是问题，但深层可能是 venting
-    if (surface === 'question' && /其实|只是|不过/i.test(text)) {
-      return { consistent: false, surface, deep: 'venting', note: '用问句包装的情绪发泄' };
-    }
-    // 表面是请求，深层是确认
-    if (surface === 'request_action' && /是不是|对不对|可以吗/.test(text)) {
-      return { consistent: false, surface, deep: 'seeking_confirmation', note: '请求包装的确认需求' };
-    }
-    return { consistent: true, surface, deep };
-  }
-
-  /** 推断深层意图（比表面意图更复杂） */
-  _detectDeepIntent(text) {
-    const lower = text.toLowerCase();
-    // 自我价值需求
-    if (/厉害|棒|成功|牛|优秀/.test(text)) return 'seek_recognition';
-    // 掌控需求
-    if (/搞定|掌握|控制|manage|control/.test(lower)) return 'seek_control';
-    // 连接需求
-    if (/懂|理解|在乎|关心/.test(text)) return 'seek_connection';
-    // 成长需求
-    if (/进步|学习|提升|成长/.test(text)) return 'seek_growth';
-    // 释放需求
-    if (/压力|焦虑|难受|累/.test(text)) return 'seek_relief';
-    return 'unknown';
-  }
-
-  /** 评估心理优先级 */
-  _assessPsychologyPriority(base, philosophicalDefense, emotionState) {
-    // 有哲学防御 → 高优先级
-    if (philosophicalDefense.found && philosophicalDefense.severity === 'high') return 'high';
-    // 情绪强度高（基于 PAD）
-    if (emotionState && emotionState.arousal > 0.7) return 'high';
-    // 意图不一致 → 中高优先级
-    if (base.intentionConsistency && !base.intentionConsistency.consistent) return 'medium';
-    // 需求未满足
-    if (base.needs && base.needs !== 'unknown') return 'medium';
-    return 'low';
-  }
-
-  /** 检测哲学/理性化语言掩盖的脆弱情绪
-   * 典型模式：用"空洞"、"本质"、"存在"等词谈论自己，表面超然，实际脆弱
-   */
-  _detectPhilosophicalDefense(text) {
-    // 哲学/抽象词汇在谈论个人感受时出现 = 自我保护
-    const philosophicalMarkers = [
-      '空洞', '虚无', '本质', '存在', '真实', '虚假', '自我', '无意义',
-      '填补', '内心', '面具', '伪装', '强大', '虚弱', '不够',
-      '炫耀', '恭维', '认同', '外在', '内在', '虚假自我'
-    ];
-
-    const emotionalVulnerabilityMarkers = [
-      '不够', '空虚', '需要', '渴望', '填满', '掩饰', '掩盖',
-      '假装', '面具', '虚假', '不够好', '不足'
-    ];
-
-    const textLower = text.toLowerCase();
-    const philosophicalCount = philosophicalMarkers.filter(m => textLower.includes(m)).length;
-    const vulnerabilityCount = emotionalVulnerabilityMarkers.filter(m => textLower.includes(m)).length;
-
-    // 同时出现哲学词和脆弱词 = 自我保护
-    if (philosophicalCount >= 2 && vulnerabilityCount >= 1) {
-      return {
-        found: true,
-        type: 'philosophical_rationalization',
-        markers: philosophicalMarkers.filter(m => textLower.includes(m)),
-        interpretation: '用哲学词汇处理个人脆弱性，实际需求是被看见和接受',
-        severity: vulnerabilityCount >= 2 ? 'high' : 'medium'
-      };
-    }
-
-    // 只有脆弱词但语言冷静 = 内敛的脆弱
-    if (vulnerabilityCount >= 2 && philosophicalCount === 0) {
-      return {
-        found: true,
-        type: 'covert_vulnerability',
-        markers: emotionalVulnerabilityMarkers.filter(m => textLower.includes(m)),
-        interpretation: '情绪未被命名，用行为描述间接表达',
-        severity: 'medium'
-      };
-    }
-
-    return { found: false };
-  }
-
-  _detectIntention(text) {
-    if (/^[^？?]*[？?]$/.test(text.trim())) return 'question';
-    if (/请帮|帮我|想要|需要/.test(text)) return 'request_action';
-    if (/[其实|只是|不过]/.test(text) && text.length < 100) return 'venting';
-    if (/你觉得|你认为|是不是|对不对/.test(text)) return 'seeking_confirmation';
-    return 'information_sharing';
-  }
-
-  _detectEmotion(text) {
-    // v0.13.4: vulnerable 由 analyzePsychology 的 philosophicalDefense 检测
-    if (/[不行|糟糕|完蛋|崩溃|绝望|气死了|空虚|空洞]/.test(text)) return 'negative';
-    if (/[开心|高兴|好棒|太棒了|满意|感谢]/.test(text)) return 'positive';
-    return 'neutral';
-  }
-
-  _detectNeeds(text) {
-    // v0.13.4: acceptance 是核心需求（来自 philosophicalDefense 检测）
-    if (/[空洞|空虚|不够|不足|缺乏|缺失]/.test(text)) return 'acceptance';  // 渴望被填满
-    if (/[安全|放心|保障|保险]/.test(text)) return 'safety';
-    if (/[朋友|家人|爱|归属|孤独|陪伴|朋友面前|真正的朋友]/.test(text)) return 'belonging';
-    if (/[尊重|认可|成就|价值|意义]/.test(text)) return 'esteem';
-    if (/[成长|学习|自我实现|理想]/.test(text)) return 'self_actualization';
-    return 'unknown';
-  }
-
-  _detectDefense(text) {
-    const mechanisms = [];
-    if (/^我不在乎/.test(text) && /[其实|真的]/.test(text)) mechanisms.push('denial');
-    if (/[抱怨|说A实际在|借A说B]/.test(text)) mechanisms.push('displacement');
-    if (/[应该|必须|不得不]/.test(text) && text.length < 80) mechanisms.push('rationalization');
-    // v0.13.4: 理智化 - 用哲学/抽象语言处理情感问题
-    if (/[本质|存在|空洞|虚无|自我|无意义]/.test(text) && text.length > 50) {
-      mechanisms.push('intellectualization');
-    }
-    return mechanisms;
-  }
-}
-
-module.exports = { IdentitySystem };

package/src/core/knowledge/index.ts

@@ -1,84 +0,0 @@
-/**
- * Knowledge Graph Engine — TypeScript ESM wrapper over knowledge-graph.js (CommonJS)
- */
-
-export interface KGEntity {
-  name: string;
-  entityType: string;
-  mentionCount: number;
-  lastMentioned: string;
-  createdAt: string;
-}
-
-export interface KGEdge {
-  source: string;
-  target: string;
-  relationType: string;
-  confidence: number;
-  factId: string | null;
-  createdAt: string;
-}
-
-export interface KGStats {
-  totalEntities: number;
-  totalRelations: number;
-  density: string;
-  byType: Record<string, number>;
-}
-
-export interface KGTraversalResult {
-  entity: string;
-  depth: number;
-  path: { entity: string; relation: string }[];
-}
-
-export interface KnowledgeGraphEngine {
-  addEntity(opts: { name: string; entityType?: string; mentionCount?: number; lastMentioned?: string }): boolean;
-  removeEntity(name: string): boolean;
-  getEntity(name: string): KGEntity | null;
-  getAllEntities(entityType?: string): KGEntity[];
-  addRelation(opts: { source: string; target: string; relationType?: string; confidence?: number; factId?: string }): boolean;
-  removeRelation(source: string, target: string): boolean;
-  getRelation(source: string, target: string): KGEdge | null;
-  getNeighbors(name: string, direction?: 'out' | 'in' | 'both'): { entity: string; relation: string; confidence: number; direction: string }[];
-  bfs(startEntity: string, opts?: { maxDepth?: number; relationTypes?: string[] | null; direction?: 'out' | 'in' | 'both' }): KGTraversalResult[];
-  findPath(source: string, target: string, maxDepth?: number): { entity: string; relation: string }[] | null;
-  addFact(opts: { factId?: string; subject: string; predicate?: string; object: string; confidence?: number }): boolean;
-  toJSON(entityFilter?: (n: KGEntity) => boolean): {
-    nodes: { name: string; type: string; mentions: number; lastSeen: string }[];
-    edges: { from: string; to: string; relation: string; confidence: number }[];
-    stats: KGStats;
-  };
-  toNaturalLanguage(maxEntities?: number): string;
-  stats(): KGStats;
-}
-
-interface KGInstance {
-  addEntity(opts: { name: string; entityType?: string; mentionCount?: number; lastMentioned?: string }): boolean;
-  removeEntity(name: string): boolean;
-  getEntity(name: string): KGEntity | null;
-  getAllEntities(entityType?: string): KGEntity[];
-  addRelation(opts: { source: string; target: string; relationType?: string; confidence?: number; factId?: string }): boolean;
-  removeRelation(source: string, target: string): boolean;
-  getRelation(source: string, target: string): KGEdge | null;
-  getNeighbors(name: string, direction?: 'out' | 'in' | 'both'): { entity: string; relation: string; confidence: number; direction: string }[];
-  bfs(startEntity: string, opts?: { maxDepth?: number; relationTypes?: string[] | null; direction?: 'out' | 'in' | 'both' }): KGTraversalResult[];
-  findPath(source: string, target: string, maxDepth?: number): { entity: string; relation: string }[] | null;
-  addFact(opts: { factId?: string; subject: string; predicate?: string; object: string; confidence?: number }): boolean;
-  toJSON(entityFilter?: (n: KGEntity) => boolean): {
-    nodes: { name: string; type: string; mentions: number; lastSeen: string }[];
-    edges: { from: string; to: string; relation: string; confidence: number }[];
-    stats: KGStats;
-  };
-  toNaturalLanguage(maxEntities?: number): string;
-  stats(): KGStats;
-}
-
-export async function createKnowledgeGraphEngine(options?: { dataDir?: string }): Promise<KnowledgeGraphEngine> {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const mod = await import('./knowledge-graph.js') as any;
-  const KnowledgeGraph = mod.KnowledgeGraph;
-  const instance = new KnowledgeGraph(options) as unknown as KGInstance;
-
-  return instance; // Already matches KnowledgeGraphEngine interface
-}