@yun520-1/heartflow 0.15.2

package/src/core/identity/identity.js

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

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