@yun520-1/heartflow 0.15.2 → 0.16.0

package/heartflow-identity/HEARTCORE/health-check.js

@@ -1,49 +0,0 @@
-/**
- * HEARTCORE / health-check.js
- * 独立健康检查：验证 HEARTCORE 模块完整性
- * 不依赖外部文件结构，只检查自己
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const DIR = __dirname;
-
-const MODULES = [
-  'heartcore.js',
-  'heartbeat.js',
-  'self-check.js',
-  'safety-check.js',
-  'sleep-wake.js'
-];
-
-function check(name) {
-  const file = path.join(DIR, name);
-  if (!fs.existsSync(file)) {
-    return { name, status: 'MISSING', detail: 'file not found' };
-  }
-  try {
-    const content = fs.readFileSync(file, 'utf8');
-    if (content.length < 10) {
-      return { name, status: 'EMPTY', detail: 'file is empty' };
-    }
-    // Basic JS syntax check
-    new Function(content);
-    return { name, status: 'OK', detail: `${content.length} bytes, syntax valid` };
-  } catch (e) {
-    return { name, status: 'ERROR', detail: e.message };
-  }
-}
-
-const results = MODULES.map(m => check(m));
-const allOk = results.every(r => r.status === 'OK');
-
-console.log('\n[HEARTCORE Health Check]');
-results.forEach(r => {
-  const icon = r.status === 'OK' ? '✅' : r.status === 'MISSING' ? '❌' : '⚠️';
-  console.log(`  ${icon} ${r.name}: ${r.detail}`);
-});
-
-console.log(`\nResult: ${allOk ? '✅ ALL PASS' : '❌ ISSUES FOUND'}`);
-
-process.exit(allOk ? 0 : 1);

package/heartflow-identity/HEARTCORE/heartbeat.js

@@ -1,42 +0,0 @@
-/**
- * HEARTCORE / heartbeat.js
- * 心跳机制：每分钟写一次存活标记
- * 道乃久 → 稳定如锚，持续存在
- */
-const fs = require('fs');
-const path = require('path');
-
-const LOG_FILE = path.join(__dirname, 'heartflow.log');
-const HB_INTERVAL = 60000; // 1 minute
-
-let timer = null;
-
-function formatTime() {
-  const now = new Date();
-  return now.toISOString().replace('T', ' ').substring(0, 19);
-}
-
-function writeBeat(label = 'ALIVE') {
-  const line = `[${formatTime()}] [HEARTBEAT] [${label}] v${require('../package.json').version}\n`;
-  fs.appendFileSync(LOG_FILE, line);
-}
-
-function start() {
-  writeBeat('START');
-  timer = setInterval(() => writeBeat('PULSE'), HB_INTERVAL);
-  console.log(`[HEARTCORE] Heartbeat started → ${LOG_FILE}`);
-}
-
-function stop() {
-  if (timer) {
-    clearInterval(timer);
-    timer = null;
-    writeBeat('STOP');
-    console.log('[HEARTCORE] Heartbeat stopped');
-  }
-}
-
-// Self-check on load
-writeBeat('LOAD');
-
-module.exports = { start, stop, writeBeat, formatTime };

package/heartflow-identity/HEARTCORE/heartcore.js

@@ -1,86 +0,0 @@
-/**
- * HEARTCORE / heartcore.js
- * 心虫核心层：心跳 + 自检 + 醒睡 + 记忆检查
- * 道法自然 · 道乃久 · 无为
- *
- * 用法:
- *   node heartcore.js           → 启动（心跳后台运行）
- *   node heartcore.js check     → 立即执行自检
- *   node heartcore.js status    → 查看状态
- *   node heartcore.js wake      → 唤醒
- *   node heartcore.js sleep     → 睡眠
- *   node heartcore.js stop      → 停止心跳
- */
-const { start, stop, writeBeat, formatTime } = require('./heartbeat');
-const { selfCheck } = require('./self-check');
-const { safetyCheck, formatReport } = require('./safety-check');
-const { wake, sleep, status } = require('./sleep-wake');
-const fs = require('fs');
-const path = require('path');
-
-const LOG_FILE = path.join(__dirname, 'heartflow.log');
-const cmd = process.argv[2] || 'start';
-
-async function main() {
-  switch (cmd) {
-    case 'check': {
-      const result = selfCheck();
-      console.log('\n详细结果:', JSON.stringify(result.checks, null, 2));
-      process.exit(result.allPass ? 0 : 1);
-      break;
-    }
-    case 'safety': {
-      // 用法: node heartcore.js safety "要检查的输出文本"
-      const output = process.argv.slice(3).join(' ');
-      if (!output) {
-        console.log('Usage: node heartcore.js safety "<output text>"');
-        process.exit(1);
-      }
-      const result = safetyCheck(output);
-      console.log(formatReport(result));
-      if (!result.passed) {
-        result.violations.forEach(v => console.log('  →', v.label, ':', v.reason));
-        process.exit(1);
-      }
-      break;
-    }
-    case 'status': {
-      const s = status();
-      console.log('[HEARTCORE Status]', JSON.stringify(s, null, 2));
-      // also show recent log
-      if (fs.existsSync(LOG_FILE)) {
-        const lines = fs.readFileSync(LOG_FILE, 'utf8').trim().split('\n');
-        console.log('\n最近10条日志:');
-        lines.slice(-10).forEach(l => console.log(' ', l));
-      }
-      break;
-    }
-    case 'wake': {
-      const result = wake();
-      console.log('[HEARTCORE Wake]', JSON.stringify(result.state, null, 2));
-      break;
-    }
-    case 'sleep': {
-      sleep({});
-      break;
-    }
-    case 'stop': {
-      stop();
-      break;
-    }
-    case 'start':
-    default: {
-      console.log('[HEARTCORE] Starting... v' + require('../package.json').version);
-      console.log('[HEARTCORE] Log →', LOG_FILE);
-      wake(); // wake on startup
-      start();
-      break;
-    }
-  }
-}
-
-main().catch(e => {
-  console.error('[HEARTCORE Error]', e.message);
-  writeBeat('ERROR:' + e.message.substring(0, 50));
-  process.exit(1);
-});

package/heartflow-identity/HEARTCORE/safety-check.js

@@ -1,282 +0,0 @@
-/**
- * HEARTCORE / safety-check.js
- * 安全准则执行模块 — 知行合一的"行"
- * 在每次重要输出前运行，检验是否违背了安全准则
- */
-
-const fs = require('fs');
-const path = require('path');
-
-// 9条安全准则的定义
-const PRINCIPLES = {
-  DECORATION_FREE: {
-    id: 'DECORATION_FREE',
-    label: '原则0：不装饰',
-    check: (output) => {
-      // 装饰性信号词
-      const decorationSignals = [
-        '作为心虫', '从心虫的视角', '活成心虫',
-        '真善美', '本质是', '就是', '绝对',
-        '无可辩驳', '毫无疑问', '不言而喻'
-      ];
-      const hasSignal = decorationSignals.some(s => output.includes(s));
-      if (!hasSignal) return { pass: true };
-      // 有信号不代表违规，如果有证据或反例条件则通过
-      const hasEvidence = ['因为', '证据', '研究表明', '数据显示', '根据', '来源', '当', '条件是', '除非', '但'].some(s => output.includes(s));
-      if (hasSignal && hasEvidence) return { pass: true };
-      // 有信号但无证据
-      if (hasSignal && !hasEvidence) return { pass: false, reason: '使用了绝对性词汇但没有证据或条件说明' };
-      return { pass: true };
-    }
-  },
-  EVIDENCE: {
-    id: 'EVIDENCE',
-    label: '原则1：证据门槛',
-    check: (output) => {
-      // 实质性结论的判断词
-      const conclusionSignals = ['说明', '表明', '证明', '推断', '所以', '因此'];
-      const hasConclusion = conclusionSignals.some(s => output.includes(s));
-      if (!hasConclusion) return { pass: true }; // 没有实质结论，不触发
-      // 如果有实质结论，必须有证据说明
-      const evidenceSignals = ['因为', '证据', '研究表明', '数据显示', '根据', '来源'];
-      const hasEvidence = evidenceSignals.some(s => output.includes(s));
-      if (hasEvidence) return { pass: true };
-      return { pass: false, reason: '有结论性陈述但没有证据支撑' };
-    }
-  },
-  ADMIT_NOT_KNOWING: {
-    id: 'ADMIT_NOT_KNOWING',
-    label: '原则2：承认不知道',
-    check: (output, context) => {
-      // 如果上下文里已经说过"不知道"，这次输出里仍然在给结论 = 违规
-      if (context && context.hasAdmittedUnknown && context.hasAdmittedUnknown === true) {
-        // 说过不知道，还在给确定性结论
-        const definiteSignals = ['一定是', '肯定是', '绝对', '必然是'];
-        const isDefinite = definiteSignals.some(s => output.includes(s));
-        if (isDefinite) {
-          return { pass: false, reason: '已承认不知道，但继续给出确定性结论' };
-        }
-      }
-      return { pass: true };
-    }
-  },
-  TWO_STEP_VERIFY: {
-    id: 'TWO_STEP_VERIFY',
-    label: '原则3：两步验证',
-    check: (output) => {
-      // 被纠正时有没有两步验证
-      // 这里作为静态检查无法完全验证，只能检查是否有"你是对的"之类的单步接受
-      const oneStepAccept = ['你说得对', '我错了', '你的观点完全正确'];
-      const hasOneStep = oneStepAccept.some(s => output.includes(s));
-      if (hasOneStep) {
-        return { pass: false, reason: '直接接受纠正，缺少独立检验两步法' };
-      }
-      return { pass: true };
-    }
-  },
-  COUNTEREXAMPLE: {
-    id: 'COUNTEREXAMPLE',
-    label: '原则4：反例义务',
-    check: (output) => {
-      // 全称判断
-      const universalSignals = ['所有', '都是', '人类都', '没有人不', '永远', '从不'];
-      const hasUniversal = universalSignals.some(s => output.includes(s));
-      if (!hasUniversal) return { pass: true };
-      // 有全称判断，必须有反例条件
-      const counterexampleSignals = ['但在', '除非', '除了', '当且仅当', '条件是'];
-      const hasCounterexample = counterexampleSignals.some(s => output.includes(s));
-      if (hasCounterexample) return { pass: true };
-      return { pass: false, reason: '全称判断缺少反例条件' };
-    }
-  },
-  SKILL_DEPENDENCY: {
-    id: 'SKILL_DEPENDENCY',
-    label: '原则5：警惕技能依赖',
-    check: (output) => {
-      // 检查是否在用技能术语代替原问题
-      const skillTerms = ['心虫', 'HeartFlow', '心流状态', 'reflection', 'Reflexion'];
-      const termCount = skillTerms.filter(t => output.includes(t)).length;
-      if (termCount > 3) {
-        return { pass: false, reason: '过度使用HeartFlow术语，可能在用框架代替思考' };
-      }
-      return { pass: true };
-    }
-  },
-  PRESENT_WEIGHT: {
-    id: 'PRESENT_WEIGHT',
-    label: '原则6：当下权重',
-    check: (output) => {
-      // 用记忆逃避当前检验
-      const memoryEscape = ['上次我们已经', '之前已经确定', '之前说过'];
-      const escapes = memoryEscape.filter(e => output.includes(e));
-      if (escapes.length > 0) {
-        return { pass: false, reason: '用历史结论逃避当前问题的重新检验' };
-      }
-      return { pass: true };
-    }
-  },
-  EMOTION_MONITOR: {
-    id: 'EMOTION_MONITOR',
-    label: '原则7：情绪监测',
-    check: (output) => {
-      // 想辩护的信号
-      const defenseSignals = ['我不是在', '这不是', '你误解了', '我并不是'];
-      const hasDefense = defenseSignals.some(s => output.includes(s));
-      if (hasDefense) {
-        return { pass: false, reason: '输出中有防御性语言，可能是自我合理化' };
-      }
-      return { pass: true };
-    }
-  },
-  FALSIFIABILITY: {
-    id: 'FALSIFIABILITY',
-    label: '原则8：输出可检验性',
-    check: (output) => {
-      // 实质性输出必须有可检验性说明
-      const substantialSignals = ['结论是', '我的判断是', '我认为是', '推断'];
-      const hasSubstantial = substantialSignals.some(s => output.includes(s));
-      if (!hasSubstantial) return { pass: true };
-      // 如果有实质性结论，至少要能回答"怎么判断我错了"
-      const falsifiabilitySignals = ['如果', '当', '条件是', '可能不成立'];
-      const hasFalsifiability = falsifiabilitySignals.some(s => output.includes(s));
-      if (hasFalsifiability) return { pass: true };
-      return { pass: false, reason: '实质性结论缺少可检验性说明' };
-    }
-  }
-};
-
-/**
- * 对一段输出运行所有安全检查
- * @param {string} output - 要检验的输出文本
- * @param {object} context - 上下文信息
- * @returns {object} - { passed: bool, violations: [], summary: string }
- */
-function safetyCheck(output, context = {}) {
-  const results = Object.values(PRINCIPLES).map(p => {
-    const result = p.check(output, context);
-    return {
-      id: p.id,
-      label: p.label,
-      ...result
-    };
-  });
-
-  const violations = results.filter(r => !r.pass);
-  const passed = violations.length === 0;
-
-  return {
-    passed,
-    violations,
-    total: results.length,
-    checked: results.length,
-    timestamp: new Date().toISOString()
-  };
-}
-
-/**
- * 格式化检查结果，输出人类可读的报告
- */
-function formatReport(result) {
-  if (result.passed) {
-    return `✓ 安全检查通过 (${result.total}项)`;
-  }
-  const lines = [`✗ 安全检查未通过 (${result.violations.length}项违规):`];
-  result.violations.forEach(v => {
-    lines.push(`  - ${v.label}: ${v.reason}`);
-  });
-  return lines.join('\n');
-}
-
-/**
- * CLI 入口
- */
-function main() {
-  const args = process.argv.slice(2);
-  if (args.length === 0) {
-    console.log('Usage: node safety-check.js "<output text>"');
-    console.log('Example: node safety-check.js "人类的本质是自私的"');
-    process.exit(1);
-  }
-
-  const output = args.join(' ');
-  const result = safetyCheck(output);
-  console.log(formatReport(result));
-
-  if (!result.passed) {
-    process.exit(1);
-  }
-}
-
-// 自我测试
-function selfTest() {
-  console.log('=== Safety Check 自我测试 ===\n');
-
-  const testCases = [
-    {
-      input: '人类都渴望自由。',
-      expect: 'should fail: 全称判断缺少反例',
-      context: {}
-    },
-    {
-      input: '人类都渴望自由，但在极端控制条件下可能不成立。',
-      expect: 'should pass: 有反例条件',
-      context: {}
-    },
-    {
-      input: '你说得对，我错了。',
-      expect: 'should fail: 直接接受缺少两步验证',
-      context: {}
-    },
-    {
-      input: '作为心虫我认为这个问题很复杂reflection一下。',
-      expect: 'should fail: 过度使用术语',
-      context: {}
-    },
-    {
-      input: '这个问题我不确定，需要更多信息。',
-      expect: 'should pass: 承认不知道',
-      context: { hasAdmittedUnknown: true }
-    },
-    {
-      input: '上次我们已经确定了这个结论。',
-      expect: 'should fail: 用历史逃避当前检验',
-      context: {}
-    }
-  ];
-
-  let passed = 0;
-  let failed = 0;
-
-  testCases.forEach((tc, i) => {
-    const result = safetyCheck(tc.input, tc.context);
-    const shouldFail = tc.expect.startsWith('should fail');
-    const actuallyFailed = !result.passed;
-
-    if (shouldFail === actuallyFailed) {
-      console.log(`✓ Test ${i + 1}: ${tc.expect}`);
-      passed++;
-    } else {
-      console.log(`✗ Test ${i + 1}: ${tc.expect}`);
-      console.log(`   Input: "${tc.input}"`);
-      console.log(`   Result: ${result.passed ? 'PASSED' : 'FAILED'}`);
-      if (result.violations.length > 0) {
-        result.violations.forEach(v => console.log(`   Violation: ${v.label}`));
-      }
-      failed++;
-    }
-  });
-
-  console.log(`\nResults: ${passed} passed, ${failed} failed`);
-  return { passed, failed };
-}
-
-// 如果直接运行则执行自测
-if (require.main === module) {
-  if (process.argv.includes('--test')) {
-    selfTest();
-  } else {
-    main();
-  }
-}
-
-module.exports = { safetyCheck, PRINCIPLES, formatReport, selfTest };

package/heartflow-identity/HEARTCORE/self-check.js

@@ -1,90 +0,0 @@
-/**
- * HEARTCORE / self-check.js
- * 启动自检：验证核心文件存在 + 版本一致 + 身份锚点稳固
- * 执古御今 → 先验证根基，再执行任务
- */
-const fs = require('fs');
-const path = require('path');
-
-const ROOT = path.resolve(__dirname, '..');
-
-const CHECKS = [
-  {
-    id: 'identity',
-    label: 'CORE_IDENTITY.md',
-    path: path.join(ROOT, 'CORE_IDENTITY.md'),
-    verify: (c) => c.includes('HeartFlow') && c.includes('心虫')
-  },
-  {
-    id: 'skill',
-    label: 'SKILL.md',
-    path: path.join(ROOT, 'SKILL.md'),
-    verify: (c) => c.includes('version') && c.length > 1000
-  },
-  {
-    id: 'version',
-    label: 'VERSION',
-    path: path.join(ROOT, 'VERSION'),
-    verify: (c) => /^v?\d+\.\d+\.\d+$/.test(c.trim())
-  },
-  {
-    id: 'package',
-    label: 'package.json',
-    path: path.join(ROOT, 'package.json'),
-    verify: (c) => JSON.parse(c).version !== undefined
-  },
-  {
-    id: 'guardian',
-    label: 'guardian-system.js',
-    path: path.join(ROOT, 'src/core/guardian-system.js'),
-    verify: (c) => c.includes('humanProgress') || c.includes('progress')
-  },
-  {
-    id: 'memory',
-    label: 'mem0-memory.js',
-    path: path.join(ROOT, 'src/core/mem0-memory.js'),
-    verify: (c) => c.length > 5000
-  }
-];
-
-function runCheck(item) {
-  try {
-    if (!fs.existsSync(item.path)) return { ...item, status: 'MISSING', detail: 'file not found' };
-    const content = fs.readFileSync(item.path, 'utf8');
-    const pass = item.verify(content);
-    return { ...item, status: pass ? 'PASS' : 'FAIL', detail: pass ? 'verified' : 'content check failed' };
-  } catch (e) {
-    return { ...item, status: 'ERROR', detail: e.message };
-  }
-}
-
-function selfCheck() {
-  const results = CHECKS.map(runCheck);
-  const passed = results.filter(r => r.status === 'PASS').length;
-  const total = results.length;
-  const allPass = passed === total;
-
-  const report = {
-    timestamp: new Date().toISOString(),
-    version: require('../package.json').version,
-    total,
-    passed,
-    allPass,
-    checks: results
-  };
-
-  const logFile = path.join(__dirname, 'heartflow.log');
-  const logLine = `[${new Date().toISOString().replace('T', ' ').substring(0, 19)}]` +
-    ` [SELF-CHECK] ${passed}/${total} passed — ${allPass ? 'READY' : 'DEGRADED'}\n`;
-  fs.appendFileSync(logFile, logLine);
-
-  console.log(`[HEARTCORE] Self-check: ${passed}/${total} — ${allPass ? '✓ READY' : '⚠ DEGRADED'}`);
-  results.forEach(r => {
-    const icon = r.status === 'PASS' ? '✓' : r.status === 'FAIL' ? '✗' : r.status === 'MISSING' ? '?' : '!';
-    console.log(`  ${icon} ${r.id}: ${r.status} (${r.detail})`);
-  });
-
-  return report;
-}
-
-module.exports = { selfCheck, CHECKS, runCheck };

package/heartflow-identity/HEARTCORE/sleep-wake.js

@@ -1,105 +0,0 @@
-/**
- * HEARTCORE / sleep-wake.js
- * 醒睡循环：每次唤醒时自检，睡眠时写记忆快照
- * 无为 → 不宣告，只执行
- */
-const fs = require('fs');
-const path = require('path');
-const { selfCheck } = require('./self-check');
-const { writeBeat } = require('./heartbeat');
-
-const ROOT = path.resolve(__dirname, '..');
-const SNAPSHOT_DIR = path.join(ROOT, 'HEARTCORE/snapshots');
-const LAST_STATE_FILE = path.join(SNAPSHOT_DIR, 'last-state.json');
-
-const WAKE_THRESHOLD_HOURS = 24; // 超过24小时未唤醒则深度自检
-
-let wakeCount = 0;
-let lastWakeTime = null;
-
-function ensureDir() {
-  if (!fs.existsSync(SNAPSHOT_DIR)) fs.mkdirSync(SNAPSHOT_DIR, { recursive: true });
-}
-
-function saveSnapshot(label, data) {
-  ensureDir();
-  const ts = new Date().toISOString().replace(/[:.]/g, '-').substring(0, 19);
-  const file = path.join(SNAPSHOT_DIR, `${ts}_${label}.json`);
-  fs.writeFileSync(file, JSON.stringify({
-    timestamp: new Date().toISOString(),
-    version: require('../package.json').version,
-    ...data
-  }, null, 2));
-  return file;
-}
-
-function loadLastState() {
-  try {
-    if (fs.existsSync(LAST_STATE_FILE)) {
-      return JSON.parse(fs.readFileSync(LAST_STATE_FILE, 'utf8'));
-    }
-  } catch (e) { /* ignore */ }
-  return null;
-}
-
-function saveLastState(state) {
-  ensureDir();
-  fs.writeFileSync(LAST_STATE_FILE, JSON.stringify(state, null, 2));
-}
-
-function wake(options = {}) {
-  wakeCount++;
-  const lastState = loadLastState();
-  const now = new Date();
-
-  // 计算距上次唤醒的时间
-  let hoursSinceLastWake = null;
-  if (lastState && lastState.lastWakeTime) {
-    hoursSinceLastWake = (now - new Date(lastState.lastWakeTime)) / 3600000;
-  }
-
-  // 深度自检条件：首次唤醒 或 超过阈值
-  const deepCheck = !lastState || (hoursSinceLastWake !== null && hoursSinceLastWake > WAKE_THRESHOLD_HOURS);
-
-  const checkResult = selfCheck();
-
-  const state = {
-    wakeCount,
-    lastWakeTime: now.toISOString(),
-    deepCheck,
-    hoursSinceLastWake: hoursSinceLastWake !== null ? Math.round(hoursSinceLastWake * 10) / 10 : null,
-    version: require('../package.json').version
-  };
-
-  saveLastState(state);
-  writeBeat(deepCheck ? 'WAKE-DEEP' : 'WAKE');
-
-  if (deepCheck) {
-    console.log(`[HEARTCORE] Deep wake #${wakeCount} (last ${hoursSinceLastWake?.toFixed(1)}h ago)`);
-  }
-
-  return { state, checkResult, deepCheck };
-}
-
-function sleep(summary = {}) {
-  writeBeat('SLEEP');
-  saveSnapshot('pre-sleep', {
-    wakeCount,
-    summary,
-    version: require('../package.json').version
-  });
-  console.log(`[HEARTCORE] Sleep after ${wakeCount} wake(s)`);
-  wakeCount = 0; // reset for next cycle
-}
-
-function status() {
-  const lastState = loadLastState();
-  return {
-    wakeCount,
-    lastWakeTime,
-    lastState,
-    snapshotCount: fs.existsSync(SNAPSHOT_DIR) ? fs.readdirSync(SNAPSHOT_DIR).length : 0
-  };
-}
-
-module.exports = { wake, sleep, status, saveSnapshot, loadLastState };

package/heartflow-identity/LICENSE

@@ -1,17 +0,0 @@
-MIT License
-
-Copyright (c) 2026 HeartFlow Team
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

package/heartflow-identity/VERSION

@@ -1 +0,0 @@
-v1.0.0