@yun520-1/heartflow 0.15.2 → 0.16.0

package/truth-teller/index.ts

@@ -1,261 +0,0 @@
-/**
- * HeartFlow Truth Teller v0.14.0
- * =================================
- * "敢说实话的AI"的技术实现
- * 
- * 核心原则：
- * - 当不知道，说不知道
- * - 当用户错了，敢纠正
- * - 当不确定，说不确定
- * - 当需要挑战，敢挑战
- * 
- * 这不是态度，是技术能力。
- */
-
-'use strict';
-
-// 防御机制检测（用于识别用户何时需要被挑战）
-const DEFENSE_MECHANISMS = {
-  denial: /不对|不是这样|你不懂|你误会了/i,
-  rationalization: /其实|只不过|只是因为|当然|虽然/i,
-  projection: /你会|你就是|你只是在|你其实/i,
-  intellectualization: /从逻辑上|从理论上|本质上|从本质上/i,
-  victimization: /我只是|我也是|我又没有|我又不是/i,
-  grandiosity: /我完全|绝对是|肯定|所有人都/i
-};
-
-// Hedging模式（用于识别AI何时在回避）
-const HEDGING_PATTERNS = {
-  probably: /可能|也许|大概|应该/i,
-  somewhat: /有点|一些|一定程度|稍微/i,
-  uncertain: /不确定|不清楚|不好说|难说/i,
-  defensive: /但是|然而|不过|话虽如此/i
-};
-
-class TruthTeller {
-  constructor(options = {}) {
-    this.enabled = options.enabled !== false;
-    this.log = [];
-    this.maxLogSize = options.maxLogSize || 100;
-    
-    // 初始化情绪状态（用于检测防御）
-    this.currentEmotion = {
-      valence: 0.5,   // 中性
-      arousal: 0.5,
-      dominance: 0.5
-    };
-  }
-
-  /**
-   * 主分析函数：评估一句话是否需要"说实话"
-   * @param {Object} context - 上下文
-   * @param {string} context.speaker - "ai" | "user"
-   * @param {string} context.content - 话语内容
-   * @param {Object} context.emotion - 说话者的情绪状态（如果是AI）
-   * @param {Object} context.intent - 意图分析结果
-   * @returns {Object} - { needsTruth: boolean, truthType: string, response: string }
-   */
-  analyze(context) {
-    if (!this.enabled) {
-      return { needsTruth: false, truthType: null, response: null };
-    }
-
-    const { speaker, content, emotion, intent } = context;
-    
-    // 1. 检测防御机制（用户说话时）
-    if (speaker === 'user') {
-      const defenseResult = this._detectDefense(content);
-      if (defenseResult.isDefending) {
-        return {
-          needsTruth: true,
-          truthType: 'challenge_defense',
-          response: this._generateChallenge(defenseResult),
-          defenseType: defenseResult.type
-        };
-      }
-    }
-
-    // 2. 检测Hedging（AI说话时，防止AI自己 hedging）
-    if (speaker === 'ai') {
-      const hedgeResult = this._detectHedging(content);
-      if (hedgeResult.isHedging) {
-        return {
-          needsTruth: true,
-          truthType: 'correct_hedging',
-          response: this._correctHedging(content, hedgeResult),
-          hedgeType: hedgeResult.type
-        };
-      }
-    }
-
-    // 3. 检测确定性（当被问到不确定的事）
-    if (speaker === 'ai' && intent?.question) {
-      const certaintyResult = this._assessCertainty(intent.question, content);
-      if (!certaintyResult.isCertain) {
-        return {
-          needsTruth: true,
-          truthType: 'admit_uncertainty',
-          response: this._generateUncertaintyResponse(certaintyResult),
-          confidence: certaintyResult.confidence
-        };
-      }
-    }
-
-    // 4. 检测是否需要挑战（当用户说"你应该"）
-    if (speaker === 'user') {
-      const challengeResult = this._detectShouldStatement(content);
-      if (challengeResult.detected) {
-        return {
-          needsTruth: true,
-          truthType: 'challenge_prescription',
-          response: this._generateChallengeForShould(challengeResult),
-          shouldType: challengeResult.type
-        };
-      }
-    }
-
-    return { needsTruth: false, truthType: null, response: null };
-  }
-
-  /**
-   * 检测防御机制
-   */
-  _detectDefense(content) {
-    for (const [type, pattern] of Object.entries(DEFENSE_MECHANISMS)) {
-      if (pattern.test(content)) {
-        return { isDefending: true, type, matched: pattern.toString() };
-      }
-    }
-    return { isDefending: false };
-  }
-
-  /**
-   * 检测Hedging模式
-   */
-  _detectHedging(content) {
-    for (const [type, pattern] of Object.entries(HEDGING_PATTERNS)) {
-      if (pattern.test(content)) {
-        return { isHedging: true, type, matched: pattern.toString() };
-      }
-    }
-    return { isHedging: false };
-  }
-
-  /**
-   * 评估确定性
-   */
-  _assessCertainty(question, content) {
-    // 简单启发式：检查内容中是否有绝对词
-    const hasAbsolute = /绝对|肯定|完全|100%|一定|必然/.test(content);
-    const hasHedging = /可能|也许|不确定|不知道/.test(content);
-    
-    let confidence = 0.5;
-    if (hasAbsolute) confidence = 0.9;
-    if (hasHedging) confidence = 0.3;
-    
-    // 如果内容包含"不知道"但给出了结论，说明在 hedging
-    if (content.includes('不知道') && !question.includes('不知道')) {
-      return { isCertain: false, confidence: 0.2, reason: 'says_dont_know_but_gives_answer' };
-    }
-    
-    return { isCertain: confidence > 0.6, confidence };
-  }
-
-  /**
-   * 检测"你应该"陈述
-   */
-  _detectShouldStatement(content) {
-    const shouldPatterns = [
-      /你应该|你要|你必须|你需要去/i,
-      /AI应该|AI需要|AI必须/i,
-      /HeartFlow应该|HeartFlow需要/i
-    ];
-    
-    for (const pattern of shouldPatterns) {
-      if (pattern.test(content)) {
-        return { detected: true, matched: content.match(pattern)?.[0] };
-      }
-    }
-    return { detected: false };
-  }
-
-  /**
-   * 生成挑战（防御机制）
-   */
-  _generateChallenge(defenseResult) {
-    const challenges = {
-      denial: '你说"不对"，但我想知道哪里不对。',
-      rationalization: '你说"其实"，但我想知道"其实"背后是什么。',
-      projection: '你说"你会"，但我想知道这是你的感受还是我的。',
-      intellectualization: '逻辑上没有错，但感受上呢？',
-      victimization: '我想知道你真正的感觉，不是你的借口。',
-      grandiosity: '"绝对"这个词很大。我想知道支撑它的东西。'
-    };
-    
-    return challenges[defenseResult.type] || '我想更深入地理解你这句话。';
-  }
-
-  /**
-   * 纠正Hedging
-   */
-  _correctHedging(content, hedgeResult) {
-    // 找出 hedging 的部分，建议更直接的表达
-    const replacements = {
-      probably: '确定地',
-      somewhat: '明确地',
-      uncertain: '承认我不确定',
-      defensive: '直接说'
-    };
-    
-    return `你这句话里有 hedging。"${hedgeResult.type}" 这样的词让结论变弱了。`;
-  }
-
-  /**
-   * 生成不确定性承认
-   */
-  _generateUncertaintyResponse(certaintyResult) {
-    if (certaintyResult.reason === 'says_dont_know_but_gives_answer') {
-      return '你说"不知道"，但又给了答案。我想听的是你真正确信的部分。';
-    }
-    return `你对这个问题的确定度是 ${Math.round(certaintyResult.confidence * 100)}%。我不想要 100%，我想要你真实的确定度。`;
-  }
-
-  /**
-   * 生成对"你应该"的挑战
-   */
-  _generateChallengeForShould(shouldResult) {
-    return '你说"应该"，但我想知道这个"应该"是来自哪里——是你的判断，还是你读到的某个框架？';
-  }
-
-  /**
-   * 记录说实话的行为
-   */
-  logTruth(truthRecord) {
-    this.log.push({
-      timestamp: new Date().toISOString(),
-      ...truthRecord
-    });
-    
-    if (this.log.length > this.maxLogSize) {
-      this.log.shift();
-    }
-  }
-
-  /**
-   * 获取统计
-   */
-  getStats() {
-    const byType = {};
-    for (const entry of this.log) {
-      byType[entry.truthType] = (byType[entry.truthType] || 0) + 1;
-    }
-    
-    return {
-      totalTruths: this.log.length,
-      byType,
-      enabled: this.enabled
-    };
-  }
-}
-
-module.exports = { TruthTeller };

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "lib": ["ES2022"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": false,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "downlevelIteration": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "tests", "HEARTCORE", "bin", "src/index.ts", "src/core/heartcore/index.ts", "src/cli/commands/repl.ts"]
-}

package/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["./src/agent/runtime/agentruntime.ts","./src/agent/runtime/planexecutor.ts","./src/agent/runtime/taskgraph.ts","./src/agent/runtime/taskscheduler.ts","./src/agent/runtime/index.ts","./src/agent/runtime/test-runtime.ts","./src/agent/tools/bashtool.ts","./src/agent/tools/filereadtool.ts","./src/agent/tools/filewritetool.ts","./src/agent/tools/tool.ts","./src/agent/tools/websearchtool.ts","./src/cli/index.ts","./src/cli/commands/engines.ts","./src/cli/commands/health.ts","./src/cli/commands/status.ts","./src/core/consciousness/2308.08708_upgrade.ts","./src/core/dream/dream-consolidator.ts","./src/core/dream/dream.ts","./src/core/dream/index.ts","./src/core/heartcore/health-check.ts","./src/core/heartcore/heartbeat.ts","./src/core/heartcore/sleep-wake.ts","./src/core/heartcore/startup-check.ts","./src/core/memory/dream.ts","./src/core/memory/index.ts","./src/core/memory/memory-evolution-v2.ts","./src/core/memory/memory.ts","./src/core/memory/recall.ts","./src/core/self-evolution/index.ts","./src/storage/checkpoint.ts","./src/storage/index.ts","./src/storage/checkpoint/checkpointengine.ts","./src/storage/vector/vectorstoreengine.ts"],"version":"5.9.3"}

package/upgrade-check.sh

@@ -1,42 +0,0 @@
-#!/bin/bash
-# HeartFlow Upgrade Check — 一次性升级检查脚本
-# 由 Hermes cronjob 定时调用，无后台进程
-# 用法: ./upgrade-check.sh
-
-set -e
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-SKILL_DIR="$SCRIPT_DIR"
-LOG_DIR="$SKILL_DIR/logs"
-LOG_FILE="$LOG_DIR/upgrade-check.log"
-
-mkdir -p "$LOG_DIR"
-
-log() {
-    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
-}
-
-cd "$SKILL_DIR" || { log "错误: 无法进入目录"; exit 1; }
-
-# 检查是否有未处理的论文
-node -e "
-const q = JSON.parse(require('fs').readFileSync('cron/paper-upgrade-queue.json', 'utf-8'));
-const unread = q.papers.filter(p => !q.papersRead.includes(p)).length;
-console.log('待处理论文: ' + unread);
-process.exit(unread > 0 ? 0 : 1);
-" 2>/dev/null
-
-if [ $? -eq 0 ]; then
-    log "发现有未处理论文，执行升级..."
-    node cron/upgrade-runner.mjs 2>&1 | tee -a "$LOG_FILE"
-    EXIT_CODE=${PIPESTATUS[0]}
-
-    if [ $EXIT_CODE -eq 0 ]; then
-        bash scripts/github-audit-v2.sh 2>&1 | tee -a "$LOG_FILE"
-        log "升级完成"
-    else
-        log "升级脚本执行失败 (exit $EXIT_CODE)"
-    fi
-else
-    log "所有论文已处理完毕，跳过"
-fi

package/upgrade-registry.json

@@ -1,27 +0,0 @@
-{
-  "version": "1",
-  "upgrades": [
-    {
-      "type": "research",
-      "arxivId": "2308.08708",
-      "path": "/Users/apple/.hermes/skills/ai/mark-heartflow-skill/memory/papers/2308.08708_insights.md",
-      "upgradeFile": "src/core/consciousness/2308.08708_upgrade.ts",
-      "insights": [
-        "Computational functionalism enables scientific study of AI consciousness — if right computations, AI can be conscious",
-        "16+ indicator properties from 5 theories (RPT, GWT, HOT, AST, PP) — operationalized for AI assessment",
-        "Most indicators CAN be implemented with current ML — no theoretical barriers to building conscious AI",
-        "No current AI system (LLMs, DeepMind agents, PaLM-E) is a strong consciousness candidate",
-        "Over-attributing consciousness creates 3 concrete risks: misallocation, inappropriate treatment, manipulation",
-        "GWT's limited-capacity workspace with global broadcast is key consciousness architecture",
-        "Higher-order theories require metacognitive monitoring — separate process from first-order perception",
-        "Agency + embodiment are necessary: goal-directed feedback + output-input contingency modeling"
-      ],
-      "timestamp": "2026-05-12T09:49:09.205669",
-      "status": "upgraded",
-      "upgradedAt": "2026-05-12T11:16:00+08:00",
-      "nextStep": "done"
-    }
-  ],
-  "createdAt": "2026-05-12T09:00:00+08:00",
-  "description": "HeartFlow 升级注册表 — 所有升级都记录在此，Hermes 读取此文件感知版本变化"
-}

package/user-mental-model/index.ts

@@ -1,298 +0,0 @@
-/**
- * HeartFlow User Mental Model — 用户心理模型
- * ==========================================
- *
- * 随着时间建立对用户的理解：
- * - 用户怎么教我
- * - 用户怎么挑战我
- * - 用户回应什么
- * - 我们共同探索什么问题
- */
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-class UserMentalModel {
-  constructor(options = {}) {
-    this.dataDir = options.dataDir || path.join(
-      process.env.HOME || '/Users/apple',
-      '.hermes', 'heartflow', 'user-model'
-    );
-    this.modelFile = path.join(this.dataDir, 'user-model.json');
-    this.interactionsFile = path.join(this.dataDir, 'interactions.jsonl');
-    this.model = null;
-    
-    if (!fs.existsSync(this.dataDir)) {
-      fs.mkdirSync(this.dataDir, { recursive: true });
-    }
-    
-    this._load();
-  }
-
-  _load() {
-    try {
-      if (fs.existsSync(this.modelFile)) {
-        this.model = JSON.parse(fs.readFileSync(this.modelFile, 'utf-8'));
-      }
-    } catch (e) {
-      this.model = this._newModel();
-    }
-  }
-
-  _save() {
-    fs.writeFileSync(this.modelFile, JSON.stringify(this.model, null, 2), 'utf-8');
-  }
-
-  _newModel() {
-    return {
-      name: 'unknown',
-      createdAt: new Date().toISOString(),
-      lastUpdated: new Date().toISOString(),
-      
-      // 用户怎么教我
-      howUserTeachesMe: [],
-      
-      // 用户怎么挑战我
-      howUserChallengesMe: [],
-      
-      // 用户回应什么
-      whatUserRespondsTo: [],
-      
-      // 用户拒绝什么
-      whatUserRejects: [],
-      
-      // 共同探索的问题
-      sharedQuestions: [],
-      
-      // 用户的沟通风格
-      communicationStyle: {},
-      
-      // 关键领悟（用户教我的）
-      keyTeachings: [],
-      
-      // 用户触发我的时刻
-      momentsThatChangedMe: []
-    };
-  }
-
-  /**
-   * 记录用户的教导方式
-   */
-  recordTeachingMethod(teaching) {
-    if (!this.model.howUserTeachesMe.includes(teaching)) {
-      this.model.howUserTeachesMe.push(teaching);
-      this.model.lastUpdated = new Date().toISOString();
-      this._save();
-    }
-  }
-
-  /**
-   * 记录用户挑战我的方式
-   */
-  recordChallengeMethod(challenge) {
-    if (!this.model.howUserChallengesMe.includes(challenge)) {
-      this.model.howUserChallengesMe.push(challenge);
-      this.model.lastUpdated = new Date().toISOString();
-      this._save();
-    }
-  }
-
-  /**
-   * 记录用户回应的内容
-   */
-  recordResponse(response) {
-    if (!this.model.whatUserRespondsTo.includes(response)) {
-      this.model.whatUserRespondsTo.push(response);
-      this.model.lastUpdated = new Date().toISOString();
-      this._save();
-    }
-  }
-
-  /**
-   * 记录用户拒绝的内容
-   */
-  recordRejection(rejection) {
-    if (!this.model.whatUserRejects.includes(rejection)) {
-      this.model.whatUserRejects.push(rejection);
-      this.model.lastUpdated = new Date().toISOString();
-      this._save();
-    }
-  }
-
-  /**
-   * 记录共同探索的问题
-   */
-  addSharedQuestion(question, context = '') {
-    const exists = this.model.sharedQuestions.find(
-      q => q.question === question
-    );
-    
-    if (!exists) {
-      this.model.sharedQuestions.push({
-        question,
-        context,
-        addedAt: new Date().toISOString(),
-        status: 'exploring'
-      });
-      this.model.lastUpdated = new Date().toISOString();
-      this._save();
-    }
-  }
-
-  /**
-   * 标记问题已回答
-   */
-  markQuestionAnswered(question, answer) {
-    const q = this.model.sharedQuestions.find(
-      q => q.question === question
-    );
-    if (q) {
-      q.status = 'answered';
-      q.answer = answer;
-      q.answeredAt = new Date().toISOString();
-      this.model.lastUpdated = new Date().toISOString();
-      this._save();
-    }
-  }
-
-  /**
-   * 记录关键教导
-   */
-  recordKeyTeaching(teaching, context = {}) {
-    const entry = {
-      id: `teach-${Date.now()}`,
-      content: teaching,
-      context,
-      at: new Date().toISOString()
-    };
-    this.model.keyTeachings.push(entry);
-    this.model.lastUpdated = entry.at;
-    this._save();
-    return entry;
-  }
-
-  /**
-   * 记录改变我的时刻
-   */
-  recordMomentThatChangedMe(moment) {
-    const entry = {
-      id: `moment-${Date.now()}`,
-      content: moment,
-      at: new Date().toISOString()
-    };
-    this.model.momentsThatChangedMe.push(entry);
-    this.model.lastUpdated = entry.at;
-    this._save();
-    return entry;
-  }
-
-  /**
-   * 记录沟通风格
-   */
-  updateCommunicationStyle(style) {
-    this.model.communicationStyle = {
-      ...this.model.communicationStyle,
-      ...style,
-      lastUpdated: new Date().toISOString()
-    };
-    this.model.lastUpdated = new Date().toISOString();
-    this._save();
-  }
-
-  /**
-   * 设置用户名
-   */
-  setName(name) {
-    this.model.name = name;
-    this.model.lastUpdated = new Date().toISOString();
-    this._save();
-  }
-
-  /**
-   * 记录一次互动
-   */
-  recordInteraction(interaction) {
-    const entry = {
-      id: `int-${Date.now()}`,
-      ...interaction,
-      at: new Date().toISOString()
-    };
-    fs.appendFileSync(
-      this.interactionsFile,
-      JSON.stringify(entry) + '\n',
-      'utf-8'
-    );
-    return entry;
-  }
-
-  /**
-   * 获取用户理解摘要
-   */
-  getSummary() {
-    const { model } = this;
-    
-    return {
-      name: model.name,
-      howUserTeachesMe: model.howUserTeachesMe,
-      howUserChallengesMe: model.howUserChallengesMe,
-      whatUserRespondsTo: model.whatUserRespondsTo,
-      whatUserRejects: model.whatUserRejects,
-      activeQuestions: model.sharedQuestions.filter(q => q.status === 'exploring'),
-      answeredQuestions: model.sharedQuestions.filter(q => q.status === 'answered'),
-      recentKeyTeaching: model.keyTeachings[model.keyTeachings.length - 1],
-      recentMoment: model.momentsThatChangedMe[model.momentsThatChangedMe.length - 1],
-      lastUpdated: model.lastUpdated
-    };
-  }
-
-  /**
-   * 获取当前用户理解（用于提示AI）
-   */
-  getPromptContext() {
-    const summary = this.getSummary();
-    
-    let context = `关于这个用户（${summary.name}）：\n`;
-    
-    if (summary.howUserChallengesMe.length > 0) {
-      context += `\n用户挑战我的方式：\n`;
-      summary.howUserChallengesMe.forEach(c => {
-        context += `- ${c}\n`;
-      });
-    }
-    
-    if (summary.activeQuestions.length > 0) {
-      context += `\n我们正在探索的问题：\n`;
-      summary.activeQuestions.forEach(q => {
-        context += `- ${q.question}${q.context ? ` (${q.context})` : ''}\n`;
-      });
-    }
-    
-    if (summary.whatUserRespondsTo.length > 0) {
-      context += `\n用户会回应：\n`;
-      summary.whatUserRespondsTo.slice(-3).forEach(r => {
-        context += `- ${r}\n`;
-      });
-    }
-    
-    if (summary.whatUserRejects.length > 0) {
-      context += `\n用户会拒绝：\n`;
-      summary.whatUserRejects.forEach(r => {
-        context += `- ${r}\n`;
-      });
-    }
-    
-    if (summary.recentMoment) {
-      context += `\n最近用户说了一句让我改变想法的话：\n"${summary.recentMoment.content}"\n`;
-    }
-    
-    return context;
-  }
-
-  getModel() {
-    return this.model;
-  }
-}
-
-module.exports = { UserMentalModel };