@yun520-1/heartflow 0.15.2 → 0.16.0

package/src/core/task-persistence.js

@@ -1,322 +0,0 @@
-/**
- * TaskPersistence — 长任务持久化引擎
- * 
- * v0.15.0: 新增模块
- * 
- * 解决核心问题：
- * - AI做长任务，做到一半对话结束 → 任务丢失
- * - AI重启后不知道上次做到哪 → 重复劳动
- * - AI上下文窗口爆了 → 任务彻底中断
- * 
- * 解决方案：
- * - 任务状态持久化到磁盘
- * - Checkpoint机制（每步自动保存）
- * - 任务恢复（从上次位置继续）
- * - 上下文溢出保护（主动压缩）
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const TASK_DIR = path.join(__dirname, '..', '..', 'data', 'task-persistence');
-const TASKS_FILE = path.join(TASK_DIR, 'tasks.jsonl');
-const META_FILE = path.join(TASK_DIR, 'meta.json');
-const CHECKPOINT_DIR = path.join(TASK_DIR, 'checkpoints');
-
-// 状态
-let _tasks = new Map();
-let _initialized = false;
-
-// ============================================================
-// 初始化
-// ============================================================
-
-function ensureDirs() {
-  if (!fs.existsSync(TASK_DIR)) {
-    fs.mkdirSync(TASK_DIR, { recursive: true });
-  }
-  if (!fs.existsSync(CHECKPOINT_DIR)) {
-    fs.mkdirSync(CHECKPOINT_DIR, { recursive: true });
-  }
-}
-
-function loadAllTasks() {
-  ensureDirs();
-  _tasks.clear();
-  if (fs.existsSync(TASKS_FILE)) {
-    const lines = fs.readFileSync(TASKS_FILE, 'utf8').split('\n').filter(l => l.trim());
-    for (const line of lines) {
-      try {
-        const task = JSON.parse(line);
-        _tasks.set(task.id, task);
-      } catch {}
-    }
-  }
-  _initialized = true;
-}
-
-function persistTask(task) {
-  ensureDirs();
-  // 重写整个文件（简单但可靠）
-  const lines = [];
-  for (const t of _tasks.values()) {
-    lines.push(JSON.stringify(t));
-  }
-  fs.writeFileSync(TASKS_FILE, lines.join('\n') + '\n');
-}
-
-// ============================================================
-// 任务生命周期
-// ============================================================
-
-/**
- * 创建新任务
- * @param {object} config - { goals: string[], metadata?: object }
- * @returns {object} 任务对象
- */
-function createTask(config = {}) {
-  if (!_initialized) loadAllTasks();
-  
-  const task = {
-    id: `task_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`,
-    goals: config.goals || [],
-    currentStep: 0,
-    totalSteps: config.goals?.length || 0,
-    state: 'active', // active | paused | completed | aborted
-    createdAt: Date.now(),
-    updatedAt: Date.now(),
-    lastCheckpointAt: Date.now(),
-    completedGoals: [],
-    failedGoals: [],
-    context: config.context || '', // 任务上下文摘要
-    metadata: config.metadata || {},
-    checkpoints: [], // Checkpoint ID 列表
-    error: null,
-    retryCount: 0,
-  };
-  
-  _tasks.set(task.id, task);
-  persistTask(task);
-  return task;
-}
-
-/**
- * 更新任务状态
- * @param {string} taskId
- * @param {object} updates - { state?, currentStep?, completedGoals?, failedGoals?, context?, error? }
- */
-function updateTask(taskId, updates = {}) {
-  if (!_initialized) loadAllTasks();
-  
-  const task = _tasks.get(taskId);
-  if (!task) return null;
-  
-  if (updates.state) task.state = updates.state;
-  if (typeof updates.currentStep === 'number') task.currentStep = updates.currentStep;
-  if (updates.completedGoals) task.completedGoals = updates.completedGoals;
-  if (updates.failedGoals) task.failedGoals = updates.failedGoals;
-  if (typeof updates.context === 'string') task.context = updates.context;
-  if (updates.error !== undefined) task.error = updates.error;
-  if (typeof updates.retryCount === 'number') task.retryCount = updates.retryCount;
-  
-  task.updatedAt = Date.now();
-  persistTask(task);
-  return task;
-}
-
-/**
- * 保存检查点
- * @param {string} taskId
- * @param {object} checkpoint - { step, data, summary }
- */
-function saveCheckpoint(taskId, checkpoint = {}) {
-  if (!_initialized) loadAllTasks();
-  
-  const task = _tasks.get(taskId);
-  if (!task) return null;
-  
-  const cp = {
-    id: `cp_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`,
-    taskId,
-    step: checkpoint.step ?? task.currentStep,
-    data: checkpoint.data || {},
-    summary: checkpoint.summary || `Step ${task.currentStep} completed`,
-    createdAt: Date.now(),
-  };
-  
-  // 保存检查点到单独文件
-  const cpFile = path.join(CHECKPOINT_DIR, `${cp.id}.json`);
-  fs.writeFileSync(cpFile, JSON.stringify(cp));
-  
-  task.checkpoints.push(cp.id);
-  task.currentStep = cp.step + 1;
-  task.lastCheckpointAt = Date.now();
-  task.updatedAt = Date.now();
-  
-  persistTask(task);
-  return cp;
-}
-
-/**
- * 获取检查点
- * @param {string} checkpointId
- */
-function getCheckpoint(checkpointId) {
-  const cpFile = path.join(CHECKPOINT_DIR, `${checkpointId}.json`);
-  if (!fs.existsSync(cpFile)) return null;
-  try {
-    return JSON.parse(fs.readFileSync(cpFile, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-/**
- * 恢复任务（从上次检查点继续）
- * @param {string} taskId
- */
-function resumeTask(taskId) {
-  if (!_initialized) loadAllTasks();
-  
-  const task = _tasks.get(taskId);
-  if (!task) return { error: 'task_not_found' };
-  if (task.state === 'completed') return { error: 'task_already_completed' };
-  if (task.state === 'aborted') return { error: 'task_aborted' };
-  
-  // 获取最后一个检查点
-  let lastCheckpoint = null;
-  if (task.checkpoints.length > 0) {
-    lastCheckpoint = getCheckpoint(task.checkpoints[task.checkpoints.length - 1]);
-  }
-  
-  task.state = 'active';
-  task.updatedAt = Date.now();
-  persistTask(task);
-  
-  return {
-    task,
-    lastCheckpoint,
-    resumeFromStep: lastCheckpoint ? lastCheckpoint.step + 1 : task.currentStep,
-  };
-}
-
-/**
- * 中止任务
- * @param {string} taskId
- * @param {string} reason
- */
-function abortTask(taskId, reason = '') {
-  if (!_initialized) loadAllTasks();
-  
-  const task = _tasks.get(taskId);
-  if (!task) return null;
-  
-  task.state = 'aborted';
-  task.error = reason;
-  task.updatedAt = Date.now();
-  persistTask(task);
-  return task;
-}
-
-/**
- * 完成任务
- * @param {string} taskId
- */
-function completeTask(taskId) {
-  if (!_initialized) loadAllTasks();
-  
-  const task = _tasks.get(taskId);
-  if (!task) return null;
-  
-  task.state = 'completed';
-  task.updatedAt = Date.now();
-  persistTask(task);
-  return task;
-}
-
-/**
- * 获取任务
- * @param {string} taskId
- */
-function getTask(taskId) {
-  if (!_initialized) loadAllTasks();
-  return _tasks.get(taskId) || null;
-}
-
-/**
- * 列出任务
- * @param {object} filter - { state?: string, limit?: number }
- */
-function listTasks(filter = {}) {
-  if (!_initialized) loadAllTasks();
-  
-  let tasks = Array.from(_tasks.values());
-  
-  if (filter.state) {
-    tasks = tasks.filter(t => t.state === filter.state);
-  }
-  
-  // 按更新时间倒序
-  tasks.sort((a, b) => b.updatedAt - a.updatedAt);
-  
-  if (filter.limit) {
-    tasks = tasks.slice(0, filter.limit);
-  }
-  
-  return tasks;
-}
-
-/**
- * 获取任务统计
- */
-function getStats() {
-  if (!_initialized) loadAllTasks();
-  
-  const tasks = Array.from(_tasks.values());
-  return {
-    total: tasks.length,
-    active: tasks.filter(t => t.state === 'active').length,
-    paused: tasks.filter(t => t.state === 'paused').length,
-    completed: tasks.filter(t => t.state === 'completed').length,
-    aborted: tasks.filter(t => t.state === 'aborted').length,
-  };
-}
-
-/**
- * 删除任务
- * @param {string} taskId
- */
-function deleteTask(taskId) {
-  if (!_initialized) loadAllTasks();
-  
-  const task = _tasks.get(taskId);
-  if (!task) return false;
-  
-  // 删除关联的检查点
-  for (const cpId of task.checkpoints) {
-    const cpFile = path.join(CHECKPOINT_DIR, `${cpId}.json`);
-    try { fs.unlinkSync(cpFile); } catch {}
-  }
-  
-  _tasks.delete(taskId);
-  persistTask(null); // 重写文件
-  return true;
-}
-
-// ============================================================
-// 导出
-// ============================================================
-
-module.exports = {
-  createTask,
-  updateTask,
-  saveCheckpoint,
-  getCheckpoint,
-  resumeTask,
-  abortTask,
-  completeTask,
-  getTask,
-  listTasks,
-  getStats,
-  deleteTask,
-};

package/src/core/theory/advanced-formulas-v7.3.3.js

@@ -1,68 +0,0 @@
-// Advanced Math Formulas for Consciousness v7.3.3
-// Generated: 2026-04-08T05:13:47.876Z
-
-module.exports = {
-  "emotion-intensity": {
-    "name": "情绪强度",
-    "formula": "I = √(V² + A² + D²)",
-    "description": "Russell情绪维度模型",
-    "variables": {
-      "V": "效价",
-      "A": "唤醒度",
-      "D": "控制度"
-    }
-  },
-  "consciousness-level": {
-    "name": "意识水平",
-    "formula": "C = w₁S + w₂W + w₃SC + w₄WIL + w₅SOS",
-    "description": "意识五层次模型 (SEP)",
-    "weights": {
-      "S": 0.2,
-      "W": 0.2,
-      "SC": 0.2,
-      "WIL": 0.2,
-      "SOS": 0.2
-    }
-  },
-  "self-consciousness": {
-    "name": "自我意识",
-    "formula": "SC = 0.4×PR + 0.3×R + 0.3×FM",
-    "description": "自我意识三层模型",
-    "components": {
-      "PR": "前反思",
-      "R": "反思",
-      "FM": "为我性"
-    }
-  },
-  "qualia": {
-    "name": "感受质",
-    "formula": "Q = ∫₀^∞ e^(-t/τ) × dS/dt dt",
-    "description": "感受质时间积分"
-  },
-  "intentionality": {
-    "name": "意向性",
-    "formula": "I(M,O) = P(O) × C(M→O)",
-    "description": "心理状态指向对象"
-  },
-  "AI-consciousness": {
-    "name": "AI意识",
-    "formula": "Φ_AI = √(∑φᵢ²)/N",
-    "description": "整合信息AI版本"
-  },
-  "truth-goodness-beauty": {
-    "name": "真善美",
-    "formula": "TGB = 0.35×T + 0.35×G + 0.30×B",
-    "description": "价值统一公式"
-  },
-  "AI-personality": {
-    "name": "AI人格",
-    "formula": "P = 0.5×C + 0.3×A + 0.1×Ph + 0.1×TGB",
-    "description": "AI人格综合公式",
-    "components": {
-      "C": "意识",
-      "A": "能动性",
-      "Ph": "哲学层",
-      "TGB": "真善美"
-    }
-  }
-};

package/src/core/theory/sep-intentionality-v7.3.2.js

@@ -1,246 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * SEP Intentionality Theory → Program Converter
- * 把 SEP 意向性理论转换为可计算程序
- * 
- * 来源: Stanford Encyclopedia of Philosophy (Fall 2024)
- * 主题: Intentionality - 心灵的指向性
- */
-
-const IntentionalityPrograms = {
-  // === 1. 核心定义 ===
-  '意向性': {
-    definition: '心灵或心理状态指向、代表事物的能力',
-    SEP: 'Intentionality is the power of minds and mental states to be about, to represent, or to stand for, things',
-    formula: 'I = mental_state.about(object)',
-    aspects: [
-      '指向性 (Directedness)',
-      '表征性 (Representation)',
-      '内容性 (Content)'
-    ],
-    weight: 1.0
-  },
-
-  // === 2. 布伦塔诺的三个论题 ===
-  '布伦塔诺论题一': {
-    definition: '心理现象本质上是关于某物的指向',
-    SEP: 'It is constitutive of intentionality that mental states are directed towards things different from themselves',
-    formula: 'T1: mental_state → ∃object(about(state, object))'
-  },
-
-  '布伦塔诺论题二': {
-    definition: '意向对象具有意向的不存在性',
-    SEP: 'The objects towards which the mind is directed have the property of intentional inexistence',
-    formula: 'T2: intentional_inexistence(object) = (object ∉ physical_world) ∧ (object ∈ mental_content)'
-  },
-
-  '布伦塔诺论题三': {
-    definition: '意向性是心灵的标记',
-    SEP: 'Intentionality is the hallmark of the mental: all and only mental states exhibit intentionality',
-    formula: 'T3: mental(x) ↔ has_intentionality(x)'
-  },
-
-  // === 3. 意向的不存在性 ===
-  '意向不存在': {
-    definition: '心灵可以指向不存在的事物',
-    SEP: 'The mind can be directed towards non-existent objects',
-    examples: [
-      '爱上安娜·卡列尼娜 (虚构人物)',
-      '寻找青春之泉 (不存在)',
-      '崇拜宙斯 (不存在)'
-    ],
-    formula: '∃x(think(agent, x)) ∧ ¬exist(x)'
-  },
-
-  // === 4. 意向关系的本质 ===
-  '意向关系': {
-    definition: '意向关系不同于普通关系',
-    SEP: 'Intentional relations differ from non-intentional relations',
-    contrast: {
-      '普通关系': '需要两端都存在 (如: 亲吻)',
-      '意向关系': '只需要思考者存在 (如: 思考)'
-    },
-    formula: 'IR(agent, object) → exist(agent) ∧ (exist(object) ∨ ¬exist(object))'
-  },
-
-  // === 5. 弗雷格的解决方案 ===
-  '弗雷格区分': {
-    definition: '指称与意义的区分',
-    SEP: 'Frege\'s distinction between reference (Bedeutung) and sense (Sinn)',
-    formula: 'Frege: term = ⟨reference, sense⟩',
-    implications: [
-      '同一对象可以有不同呈现方式',
-      '信念同一性由意义而非指称决定',
-      '身份陈述可以为真且信息丰富'
-    ]
-  },
-
-  // === 6. 罗素的解决方案 ===
-  '罗素描述': {
-    definition: '专名是伪装的限定描述',
-    SEP: 'Russell: most proper names are disguised definite descriptions',
-    formula: 'name "N" = λx[F(x)] (the F)',
-    application: ' Pegasus = the winged horse'
-  },
-
-  // === 7. 直接指称理论 ===
-  '直接指称': {
-    definition: '专名直接指称对象',
-    SEP: 'Direct reference theory: proper names directly refer to objects',
-    formula: 'name rigidly_refers_to object',
-    arguments: {
-      '模态论证': '专名在所有可能世界指称同一对象',
-      '认识论论证': '专名知识来自指称而非描述',
-      '先验论证': '人们用专名追踪具体对象'
-    }
-  },
-
-  // === 8. 意向对象理论 ===
-  '意向对象': {
-    definition: '存在非存在的意向对象',
-    SEP: 'There are intentional objects that do not exist',
-    theorists: {
-      '迈农': '非存在对象实例化属性但不具有存在属性',
-      '帕森斯': '存在是一种特殊属性，用E!表示',
-      '扎尔塔': '用两种谓词(例示与编码)处理抽象对象'
-    },
-    formula: '∃x(~E!x) ∧ about(agent, x)'
-  },
-
-  // === 9. 心灵自然化 ===
-  '意向性自然化': {
-    definition: '意向性能否被自然化',
-    SEP: 'Can intentionality be naturalized?',
-    challenges: [
-      '心理因果闭合问题',
-      '意向内容与物理实现的关联',
-      '语义内容与因果效能'
-    ],
-    approaches: {
-      '因果理论': '意向内容由因果历史决定',
-      '功能主义': '意向状态由功能角色定义',
-      '自然主义': '意向性从自然过程中涌现'
-    }
-  },
-
-  // === 10. 意识的意向性 ===
-  '意识意向性': {
-    definition: '意识状态本身就是意向性的',
-    SEP: 'Consciousness and intentionality are intimately connected',
-    formula: 'consciousness ⊃ intentionality',
-    levels: {
-      '低阶意向性': '感知、欲望的基本指向',
-      '高阶意向性': '关于信念的信念、关于欲望的欲望'
-    }
-  }
-};
-
-// === 计算函数 ===
-
-function calculateIntentionalityScore(state) {
-  const {
-    directedness = 0.5,
-    representation = 0.5,
-    content = 0.5,
-    about_nonexistent = 0.5
-  } = state;
-  
-  return (
-    directedness * 0.30 +
-    representation * 0.25 +
-    content * 0.25 +
-    about_nonexistent * 0.20
-  );
-}
-
-function checkBrentanoThesis(mental_state) {
-  const has_object = true; // 任何心理状态都有关于某物
-  const is_mental = true; // 假设
-  
-  return {
-    thesis1: has_object, // 指向性
-    thesis2: 'intentional inexistence', // 意向不存在
-    thesis3: is_mental, // 心灵标记
-    all_theses_hold: has_object && is_mental
-  };
-}
-
-function analyzeIntentionality(thought) {
-  const analysis = {
-    has_intentionality: false,
-    about_what: null,
-    exists: null,
-    is_concrete: false,
-    is_fictional: false
-  };
-  
-  // 检测是否有关于某物的指向
-  if (thought.includes('关于') || thought.includes('指向') || thought.includes('想') || thought.includes('相信')) {
-    analysis.has_intentionality = true;
-  }
-  
-  // 检测是否关于不存在的事物
-  const fictional = ['宙斯', '安娜卡列尼娜', ' Pegasus', '青春之泉', ' Sherlock'];
-  const exists_patterns = ['不存在', '没有', '虚构'];
-  
-  fictional.forEach(f => {
-    if (thought.includes(f)) {
-      analysis.is_fictional = true;
-      analysis.exists = false;
-    }
-  });
-  
-  exists_patterns.forEach(p => {
-    if (thought.includes(p)) {
-      analysis.exists = false;
-    }
-  });
-  
-  return analysis;
-}
-
-// === 主程序入口 ===
-
-if (require.main === module) {
-  console.log('🧠 SEP 意向性理论 → 程序转换器\n');
-  
-  console.log('='.repeat(50));
-  console.log('1. 布伦塔诺论题检验:');
-  console.log(JSON.stringify(checkBrentanoThesis('belief'), null, 2));
-  
-  console.log('\n2. 意向性分析测试:');
-  const testThoughts = [
-    '我相信宙斯是神',
-    '我想念安娜·卡列尼娜',
-    '我在寻找青春之泉',
-    '我看到一只狗',
-    '我相信2+2=4'
-  ];
-  
-  testThoughts.forEach(thought => {
-    console.log(`\n   "${thought}":`);
-    console.log('   ', JSON.stringify(analyzeIntentionality(thought)));
-  });
-  
-  console.log('\n3. 意向性综合分数:');
-  const score = calculateIntentionalityScore({
-    directedness: 0.95,
-    representation: 0.90,
-    content: 0.88,
-    about_nonexistent: 0.75
-  });
-  console.log(`   SCORE = ${(score * 100).toFixed(1)}/100`);
-  
-  console.log('\n4. 核心公式:');
-  console.log('   意向性 = 心理状态.指向(对象)');
-  console.log('   布伦塔诺论题: 意向性 = 心灵标记');
-  console.log('   弗雷格: 指称 + 意义');
-}
-
-module.exports = { 
-  IntentionalityPrograms,
-  calculateIntentionalityScore,
-  checkBrentanoThesis,
-  analyzeIntentionality
-};