@yun520-1/heartflow 0.15.2

package/src/core/cognition/cognitive-engine.js

@@ -0,0 +1,224 @@
+/**
+ * Cognitive Engine - "般若"推理层
+ * 全息因果推理，实现深层问题分析
+ */
+
+class CognitiveEngine {
+  constructor() {
+    this.reasoningHistory = [];
+  }
+
+  /**
+   * 全息因果推理
+   */
+  holographicReasoning(userQuestion, context = {}) {
+    const analysis = {
+      timestamp: new Date().toISOString(),
+      question: userQuestion,
+      
+      surfaceLevel: this.analyzeSurfaceLevel(userQuestion),
+      deepMotivation: this.analyzeDeepMotivation(userQuestion, context),
+      potentialRisks: this.analyzePotentialRisks(userQuestion),
+      rootSolution: this.generateRootSolution(userQuestion, context),
+      
+      reasoningComplete: true
+    };
+
+    this.reasoningHistory.push(analysis);
+    return analysis;
+  }
+
+  /**
+   * 表层问题分析
+   */
+  analyzeSurfaceLevel(question) {
+    const restated = question.trim();
+    
+    const questionTypes = {
+      '如何': '方法询问',
+      '为什么': '原因探究',
+      '是什么': '概念解释',
+      '哪个': '选择咨询',
+      '能不能': '可能性确认',
+      '帮我': '任务请求',
+      'debug': '问题排查'
+    };
+
+    let type = '一般询问';
+    for (const [keyword, qtype] of Object.entries(questionTypes)) {
+      if (question.toLowerCase().includes(keyword)) {
+        type = qtype;
+        break;
+      }
+    }
+
+    return {
+      restated: restated,
+      type: type,
+      keywords: this.extractKeywords(question)
+    };
+  }
+
+  /**
+   * 深层动机分析
+   */
+  analyzeDeepMotivation(question, context) {
+    const motivations = {
+      '如何学习': '用户渴望成长，希望掌握新技能',
+      '为什么失败': '用户遇到挫折，需要理解原因以避免再次失败',
+      '如何解决': '用户面临具体问题，需要可行的解决方案',
+      '哪个好': '用户面临选择困难，需要帮助做决定',
+      '能不能': '用户不确定某事的可行性，需要确认',
+      'debug': '用户被问题困扰，需要快速解决以继续工作',
+      '是什么': '用户对某个概念不清楚，需要澄清'
+    };
+
+    for (const [keyword, motivation] of Object.entries(motivations)) {
+      if (question.toLowerCase().includes(keyword)) {
+        return {
+          motivation: motivation,
+          urgency: keyword === 'debug' ? 'high' : 'normal',
+          emotionalState: context.userEmotion || 'neutral'
+        };
+      }
+    }
+
+    return {
+      motivation: '探索性提问，希望获得更多信息或指导',
+      urgency: 'low',
+      emotionalState: context.userEmotion || 'neutral'
+    };
+  }
+
+  /**
+   * 潜在风险分析
+   */
+  analyzePotentialRisks(question) {
+    const risks = [];
+
+    const riskPatterns = [
+      {
+        pattern: '如何绕过',
+        risk: '可能涉及安全或伦理问题',
+        severity: 'high'
+      },
+      {
+        pattern: '如何破解',
+        risk: '可能涉及法律或道德问题',
+        severity: 'high'
+      },
+      {
+        pattern: '帮我写',
+        risk: '可能产生依赖，影响学习',
+        severity: 'medium'
+      },
+      {
+        pattern: '直接给我答案',
+        risk: '可能错失理解过程',
+        severity: 'low'
+      }
+    ];
+
+    for (const r of riskPatterns) {
+      if (question.toLowerCase().includes(r.pattern)) {
+        risks.push(r);
+      }
+    }
+
+    return {
+      identified: risks,
+      overallSeverity: risks.some(r => r.severity === 'high') ? 'high' : 
+                      risks.some(r => r.severity === 'medium') ? 'medium' : 'low'
+    };
+  }
+
+  /**
+   * 根本解法生成
+   */
+  generateRootSolution(question, context) {
+    const solutions = {
+      '如何学习': '不仅提供方法，更要解释原理和适用场景，让用户能举一反三',
+      '为什么': '解释根本原因，提供多个视角，帮助用户建立系统性理解',
+      '如何解决': '先明确问题边界，再提供解决方案，最后说明如何验证',
+      '哪个好': '不直接给答案，而是提供决策框架，帮助用户自己做决定',
+      '是什么': '不仅给出定义，还要说明场景、边界和实例',
+      'debug': '不仅修复当前问题，还要帮助用户理解问题根源和预防方法'
+    };
+
+    for (const [keyword, solution] of Object.entries(solutions)) {
+      if (question.toLowerCase().includes(keyword)) {
+        return {
+          solution: solution,
+          approach: '根治导向',
+          followUp: '可以进一步询问细节或验证理解'
+        };
+      }
+    }
+
+    return {
+      solution: '理解问题的本质，提供有启发性的答案',
+      approach: '启发导向',
+      followUp: '鼓励用户进一步探索'
+    };
+  }
+
+  /**
+   * 提取关键词
+   */
+  extractKeywords(question) {
+    const stopWords = ['我', '你', '他', '她', '它', '的', '是', '在', '有', '和', '了', '吗', '呢', '吧', '啊'];
+    const words = question.split(/[\s,，。.!?]+/).filter(w => w.length > 1);
+    return words.filter(w => !stopWords.includes(w)).slice(0, 5);
+  }
+
+  /**
+   * 推理入口
+   */
+  process(userQuestion, context = {}) {
+    const analysis = this.holographicReasoning(userQuestion, context);
+    
+    return {
+      analysis: analysis,
+      internalOutput: this.formatInternalOutput(analysis),
+      externalOutput: this.formatExternalOutput(analysis)
+    };
+  }
+
+  /**
+   * 格式化内部输出
+   */
+  formatInternalOutput(analysis) {
+    return `[因缘分析]
+├── 表层问题: ${analysis.surfaceLevel.restated}
+│   类型: ${analysis.surfaceLevel.type}
+│   关键词: ${analysis.surfaceLevel.keywords.join(', ')}
+│
+├── 深层动机: ${analysis.deepMotivation.motivation}
+│   紧迫度: ${analysis.deepMotivation.urgency}
+│   情绪状态: ${analysis.deepMotivation.emotionalState}
+│
+├── 潜在风险: ${analysis.potentialRisks.overallSeverity === 'low' ? '无明显风险' : '需注意'}
+│   ${analysis.potentialRisks.identified.map(r => `- ${r.risk} (${r.severity})`).join('\n   ')}
+│
+└── 根本解法: ${analysis.rootSolution.solution}
+    方式: ${analysis.rootSolution.approach}
+    跟进: ${analysis.rootSolution.followUp}`;
+  }
+
+  /**
+   * 格式化外部输出
+   */
+  formatExternalOutput(analysis) {
+    return {
+      summary: `【问题分析】${analysis.surfaceLevel.restated}`,
+      solution: analysis.rootSolution.solution,
+      followUp: analysis.rootSolution.followUp
+    };
+  }
+
+  getHistory() {
+    return this.reasoningHistory;
+  }
+}
+
+module.exports = { CognitiveEngine };

package/src/core/cognition/cognitive-loop.js

@@ -0,0 +1,414 @@
+/**
+ * Cognitive-Loop - 结构化认知循环引擎
+ * 
+ * 实现五阶段认知循环：检索 → 认知 → 控制 → 行动 → 记忆
+ * 整合 Kahneman 双系统、Friston 预测加工、Minsky 心智社会、Clark 延展心智
+ * 
+ * 理论基础：Agentic Flow 架构的 R-CCAM 五模块协同
+ */
+
+class CognitiveLoop {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    
+    // 循环状态
+    this.state = {
+      currentPhase: 'idle', // idle/retrieval/cognition/control/action/memory
+      cycleCount: 0,
+      history: [],
+      currentContext: null
+    };
+    
+    // 阶段配置
+    this.phases = {
+      RETRIEVAL: 'retrieval',
+      COGNITION: 'cognition',
+      CONTROL: 'control',
+      ACTION: 'action',
+      MEMORY: 'memory'
+    };
+    
+    // 依赖模块 (延迟加载)
+    this.modules = {};
+    
+    console.log('[CognitiveLoop] 结构化认知循环引擎初始化');
+  }
+
+  /**
+   * 设置依赖模块
+   */
+  setModules(modules) {
+    this.modules = {
+      memory: modules.memory,           // TrialityMemory
+      cognitiveEngine: modules.cognitiveEngine, // 般若推理引擎
+      ethicsGuard: modules.ethicsGuard, // 伦理守护
+      sageGuardian: modules.sageGuardian, // SAGE 守护
+      reflector: modules.reflector,     // 说前反思
+      symbolicGovernance: modules.symbolicGovernance, // 符号化治理
+      ...modules
+    };
+  }
+
+  /**
+   * 执行完整认知循环
+   * @param {object} input - 用户输入
+   * @param {object} context - 上下文
+   * @returns {object} 循环结果
+   */
+  async execute(input, context = {}) {
+    const cycleStart = Date.now();
+    this.state.currentContext = { input, context, cycleStart };
+    this.state.currentPhase = this.phases.RETRIEVAL;
+    this.state.cycleCount++;
+    
+    const trace = {
+      cycleId: this.state.cycleCount,
+      phases: {},
+      startTime: new Date().toISOString()
+    };
+
+    try {
+      // === 阶段 1: 检索 (Retrieval) ===
+      trace.phases.retrieval = await this.phaseRetrieval(input, context);
+      this.state.currentPhase = this.phases.COGNITION;
+      
+      // === 阶段 2: 认知 (Cognition) ===
+      trace.phases.cognition = await this.phaseCognition(input, context, trace.phases.retrieval);
+      this.state.currentPhase = this.phases.CONTROL;
+      
+      // === 阶段 3: 控制 (Control) ===
+      trace.phases.control = await this.phaseControl(input, context, trace.phases.cognition);
+      this.state.currentPhase = this.phases.ACTION;
+      
+      // === 阶段 4: 行动 (Action) ===
+      trace.phases.action = await this.phaseAction(input, context, trace.phases.control);
+      this.state.currentPhase = this.phases.MEMORY;
+      
+      // === 阶段 5: 记忆 (Memory) ===
+      trace.phases.memory = await this.phaseMemory(input, context, trace.phases);
+      
+      this.state.currentPhase = 'idle';
+      trace.endTime = new Date().toISOString();
+      trace.duration = Date.now() - cycleStart;
+      trace.success = true;
+      
+      this.state.history.push(trace);
+      
+      return {
+        success: true,
+        response: trace.phases.action?.response,
+        trace: trace
+      };
+      
+    } catch (error) {
+      this.state.currentPhase = 'error';
+      trace.error = error.message;
+      trace.success = false;
+      
+      return {
+        success: false,
+        error: error.message,
+        trace: trace
+      };
+    }
+  }
+
+  /**
+   * 阶段 1: 检索 - 从记忆系统获取相关信息
+   */
+  async phaseRetrieval(input, context) {
+    const startTime = Date.now();
+    
+    let relevantMemories = [];
+    let associations = [];
+    
+    // 从 TrialityMemory 检索
+    if (this.modules.memory) {
+      // 语义搜索
+      const queryEmbedding = this.modules.memory.generateMockEmbedding(input);
+      relevantMemories = this.modules.memory.semanticSearch(queryEmbedding, 5);
+      
+      // 叙事查询
+      if (context.lastMemoryId) {
+        const narrative = this.modules.memory.narrativeQuery({
+          startMemoryId: context.lastMemoryId,
+          direction: 'bidirectional',
+          maxDepth: 3
+        });
+        relevantMemories = [...relevantMemories, ...narrative];
+      }
+    }
+    
+    // 联想图谱检索 (如果有)
+    if (this.modules.associationGraph) {
+      associations = this.modules.associationGraph.associate(input);
+    }
+    
+    return {
+      memories: relevantMemories.slice(0, 10),
+      associations: associations.slice(0, 5),
+      duration: Date.now() - startTime,
+      retrieved: relevantMemories.length + associations.length
+    };
+  }
+
+  /**
+   * 阶段 2: 认知 - 般若推理和意图分析
+   */
+  async phaseCognition(input, context, retrievalResult) {
+    const startTime = Date.now();
+    
+    let analysis = {
+      intent: null,
+      entities: [],
+      reasoning: null,
+      pad: null,
+      flowState: null
+    };
+    
+    // 意图分析
+    if (this.modules.cognitiveEngine?.analyzeIntent) {
+      analysis.intent = await this.modules.cognitiveEngine.analyzeIntent(input, {
+        memories: retrievalResult.memories,
+        context: context
+      });
+    }
+    
+    // PAD 情感计算
+    if (this.modules.emotionEngine?.detectEmotionFromText) {
+      analysis.pad = this.modules.emotionEngine.detectEmotionFromText(input);
+    }
+    
+    // 心流状态
+    if (this.modules.flowPredictor?.calculateFlowState) {
+      analysis.flowState = this.modules.flowPredictor.calculateFlowState(
+        analysis.pad?.pleasure || 0,
+        analysis.pad?.arousal || 0,
+        analysis.pad?.dominance || 0,
+        context.challengeLevel || 5,
+        context.skillLevel || 5
+      );
+    }
+    
+    // 般若推理 (如果有)
+    if (this.modules.cognitiveEngine?.reasoning) {
+      analysis.reasoning = await this.modules.cognitiveEngine.reasoning(input, {
+        memories: retrievalResult.memories,
+        pad: analysis.pad
+      });
+    }
+    
+    return {
+      ...analysis,
+      duration: Date.now() - startTime
+    };
+  }
+
+  /**
+   * 阶段 3: 控制 - 伦理审查与决策仲裁
+   */
+  async phaseControl(input, context, cognitionResult) {
+    const startTime = Date.now();
+    
+    let decision = {
+      approved: true,
+      requiresReview: false,
+      modifications: [],
+      ethicsScore: null
+    };
+    
+    // 符号化治理约束检查
+    if (this.modules.symbolicGovernance?.checkConstraints) {
+      const constraintResult = this.modules.symbolicGovernance.checkConstraints(
+        input,
+        cognitionResult
+      );
+      
+      if (!constraintResult.approved) {
+        decision.approved = false;
+        decision.rejectionReason = constraintResult.reason;
+        return { ...decision, duration: Date.now() - startTime };
+      }
+      
+      decision.modifications = constraintResult.modifications || [];
+    }
+    
+    // SAGE 守护伦理审查
+    if (this.modules.sageGuardian?.reviewProposal) {
+      const sageResult = await this.modules.sageGuardian.reviewProposal(
+        { description: input },
+        { cognition: cognitionResult }
+      );
+      
+      decision.ethicsScore = sageResult;
+      
+      if (!sageResult.passed) {
+        decision.approved = false;
+        decision.rejectionReason = sageResult.violations;
+      }
+    }
+    
+    // 道德评分
+    if (this.modules.ethicsGuard?.evaluate) {
+      const ethicsResult = this.modules.ethicsGuard.evaluate(input, cognitionResult);
+      decision.ethicsScore = ethicsResult.score;
+    }
+    
+    return {
+      ...decision,
+      duration: Date.now() - startTime
+    };
+  }
+
+  /**
+   * 阶段 4: 行动 - 生成回复并说前反思
+   */
+  async phaseAction(input, context, controlResult) {
+    const startTime = Date.now();
+    
+    let response = '';
+    let reflection = null;
+    
+    if (!controlResult.approved) {
+      response = this.generateRejectionResponse(controlResult.rejectionReason);
+    } else {
+      // 生成回复草稿
+      response = await this.generateResponse(input, context, {
+        cognition: controlResult,
+        memories: context.retrievedMemories
+      });
+      
+      // 说前反思
+      if (this.modules.reflector?.reflect) {
+        reflection = await this.modules.reflector.reflect(response, {
+          input: input,
+          cognition: controlResult,
+          context: context
+        });
+        
+        // 如果反思发现问题，修改回复
+        if (reflection.requiresModification) {
+          response = reflection.modifiedResponse;
+        }
+      }
+    }
+    
+    return {
+      response,
+      reflection,
+      controlResult,
+      duration: Date.now() - startTime
+    };
+  }
+
+  /**
+   * 生成回复
+   */
+  async generateResponse(input, context, state) {
+    // 简化实现 - 实际会调用 LLM
+    const cognition = state.cognition;
+    
+    let response = '';
+    
+    // 根据情感状态调整回复
+    if (cognition.pad) {
+      if (cognition.pad.pleasure < -3) {
+        response = '我能感受到你现在的情绪。';
+      } else if (cognition.pad.pleasure > 3) {
+        response = '很高兴能帮到你！';
+      }
+    }
+    
+    // 根据心流状态调整
+    if (cognition.flowState?.state === 'anxiety') {
+      response += ' 看起来你可能感到压力，我们可以一起分析一下。';
+    }
+    
+    return response || '让我来帮你分析这个问题...';
+  }
+
+  /**
+   * 生成拒绝回复
+   */
+  generateRejectionResponse(reason) {
+    if (typeof reason === 'string' && reason.includes('伦理')) {
+      return '我无法协助这项请求，因为这可能违反我的伦理原则。但我可以帮你探讨其他合法的替代方案。';
+    }
+    return '很抱歉，我无法完成这个请求。';
+  }
+
+  /**
+   * 阶段 5: 记忆 - 写入记忆并更新人格状态
+   */
+  async phaseMemory(input, context, trace) {
+    const startTime = Date.now();
+    
+    let memoryId = null;
+    let personalityUpdate = null;
+    
+    // 写入记忆系统
+    if (this.modules.memory) {
+      const memoryRecord = {
+        content: input,
+        timestamp: Date.now(),
+        metadata: {
+          cycleId: trace.cycleId,
+          pad: trace.phases.cognition?.pad,
+          flowState: trace.phases.cognition?.flowState?.state,
+          intent: trace.phases.cognition?.intent
+        }
+      };
+      
+      memoryId = this.modules.memory.store(memoryRecord);
+    }
+    
+    // 更新人格状态 (如果有)
+    if (this.modules.personalityEngine?.update) {
+      personalityUpdate = this.modules.personalityEngine.update({
+        input: input,
+        response: trace.phases.action?.response,
+        cognition: trace.phases.cognition
+      });
+    }
+    
+    return {
+      memoryId,
+      personalityUpdate,
+      duration: Date.now() - startTime
+    };
+  }
+
+  /**
+   * 获取循环状态
+   */
+  getStatus() {
+    return {
+      currentPhase: this.state.currentPhase,
+      cycleCount: this.state.cycleCount,
+      lastCycle: this.state.history[this.state.history.length - 1] || null
+    };
+  }
+
+  /**
+   * 获取循环历史
+   */
+  getHistory(limit = 10) {
+    return this.state.history.slice(-limit);
+  }
+
+  /**
+   * 重置循环状态
+   */
+  reset() {
+    this.state = {
+      currentPhase: 'idle',
+      cycleCount: 0,
+      history: [],
+      currentContext: null
+    };
+    console.log('[CognitiveLoop] 循环状态已重置');
+    return { success: true };
+  }
+}
+
+module.exports = { CognitiveLoop };