@yun520-1/heartflow 0.15.2 → 0.16.0

package/src/core/dream/dream.ts

@@ -1,430 +0,0 @@
-/**
- * HeartFlow Dream Engine - 梦境引擎 v3
- * 
- * 心虫的梦 = 记忆碎片重组 → 发现跨域连接 → 存在论突破
- * 
- * 梦境阶段：Light → REM → Deep → Lucid → Wide
- * 每个阶段对记忆碎片做不同操作，最终输出可执行的"顿悟"
- */
-
-import { EventEmitter } from 'events';
-
-export interface DreamConfig {
-  consolidationStrength: number;  // 巩固强度
-  patternThreshold: number;        // 模式识别阈值
-  strengthenAbove: number;         // 强化阈值
-  weakenBelow: number;            // 弱化阈值
-  maxIterations: number;          // 最大迭代次数
-  minFragments: number;           // 最少碎片数才启动梦境
-}
-
-export interface DreamResult {
-  insights: Insight[];
-  strengthened: string[];   // 强化了的记忆ID
-  weakened: string[];        // 弱化了的记忆ID
-  merged: string[][];        // 合并的记忆对
-  newBlocks: string[];       // 新生成的记忆块ID
-  cycles: number;            // 梦境循环次数
-  stage: string;             // 最终阶段
-  breakthrough?: string;     // 存在论突破（如果有）
-}
-
-export interface Insight {
-  type: 'pattern' | 'connection' | 'decay' | 'merge' | 'breakthrough';
-  description: string;
-  weight: number;
-  relatedTags: string[];
-  blockIds: string[];
-  actionable?: string;       // 可执行的行动建议
-}
-
-export interface DreamState {
-  config: DreamConfig;
-  lastDreamAt: number;
-  dreamCount: number;
-  insights: Insight[];
-  stages: Record<string, number>;  // 各阶段执行次数
-}
-
-export interface RecallBlock {
-  id: string;
-  content: string;
-  tags?: string[];
-  weight?: number;
-  lastAccessed?: number;
-  createdAt?: number;
-}
-
-export interface DreamStats {
-  dreamCount: number;
-  lastDreamAt: number;
-  totalInsights: number;
-  insightTypes: Record<string, number>;
-  stages: Record<string, number>;
-  avgCycleTime?: number;
-}
-
-const DEFAULT_CONFIG: DreamConfig = {
-  consolidationStrength: 0.5,
-  patternThreshold: 3,
-  strengthenAbove: 0.75,
-  weakenBelow: 0.25,
-  maxIterations: 5,
-  minFragments: 3,
-};
-
-export function createDreamState(config: Partial<DreamConfig> = {}): DreamState {
-  return {
-    config: { ...DEFAULT_CONFIG, ...config },
-    lastDreamAt: 0,
-    dreamCount: 0,
-    insights: [],
-    stages: { Light: 0, REM: 0, Deep: 0, Lucid: 0, Wide: 0 },
-  };
-}
-
-export function getRecentInsights(state: DreamState, limit: number = 20): Insight[] {
-  return state.insights.slice(-limit);
-}
-
-export function getDreamStats(state: DreamState): DreamStats {
-  const insightTypes: Record<string, number> = {};
-  for (const ins of state.insights) {
-    insightTypes[ins.type] = (insightTypes[ins.type] ?? 0) + 1;
-  }
-  return {
-    dreamCount: state.dreamCount,
-    lastDreamAt: state.lastDreamAt,
-    totalInsights: state.insights.length,
-    insightTypes,
-    stages: { ...state.stages },
-  };
-}
-
-export interface DreamEngine extends EventEmitter {
-  state: DreamState;
-  runNightDream: (recallBlocks: Map<string, RecallBlock>) => Promise<DreamResult>;
-  getInsights: () => Insight[];
-  getStats: () => DreamStats;
-  addFragment: (block: RecallBlock) => void;
-}
-
-/**
- * 五个梦境阶段处理器
- */
-
-// Light阶段：浅层扫描，标记高权重记忆
-function lightPhase(blocks: RecallBlock[], state: DreamState): RecallBlock[] {
-  state.stages.Light++;
-  const sorted = [...blocks].sort((a, b) => (b.weight ?? 0.5) - (a.weight ?? 0.5));
-  // 只取前50%进入下一阶段
-  return sorted.slice(0, Math.max(1, Math.floor(sorted.length / 2)));
-}
-
-// REM阶段：跨域连接，发现隐藏关系
-function remPhase(blocks: RecallBlock[], state: DreamState): { pairs: [RecallBlock, RecallBlock][]; connections: number } {
-  state.stages.REM++;
-  const pairs: [RecallBlock, RecallBlock][] = [];
-  const connections: Map<string, number> = new Map();
-  
-  for (let i = 0; i < blocks.length; i++) {
-    for (let j = i + 1; j < blocks.length; j++) {
-      const score = calculateConnectionScore(blocks[i], blocks[j]);
-      if (score > state.config.patternThreshold) {
-        pairs.push([blocks[i], blocks[j]]);
-        const key = `${blocks[i].id}↔${blocks[j].id}`;
-        connections.set(key, score);
-      }
-    }
-  }
-  
-  return { pairs, connections: pairs.length };
-}
-
-// Deep阶段：矛盾检测，发现前提假设
-function deepPhase(pairs: [RecallBlock, RecallBlock][], state: DreamState): Insight[] {
-  state.stages.Deep++;
-  const insights: Insight[] = [];
-  const now = Date.now();
-  
-  for (const [a, b] of pairs) {
-    // 检查标签重叠
-    const tagsA = new Set(a.tags ?? []);
-    const tagsB = new Set(b.tags ?? []);
-    const overlap = [...tagsA].filter(t => tagsB.has(t));
-    
-    if (overlap.length > 0) {
-      insights.push({
-        type: 'connection',
-        description: `跨域连接：${a.id} 与 ${b.id} 共享标签 [${overlap.join(', ')}]`,
-        weight: overlap.length * 0.3,
-        relatedTags: overlap,
-        blockIds: [a.id, b.id],
-      });
-    }
-  }
-  
-  return insights;
-}
-
-// Lucid阶段：自我反思，发现自身模式
-function lucidPhase(blocks: RecallBlock[], insights: Insight[], state: DreamState): Insight[] {
-  state.stages.Lucid++;
-  const lucidInsights: Insight[] = [];
-  const now = Date.now();
-  
-  // 发现高频标签 → 执念模式
-  const tagFreq: Record<string, number> = {};
-  for (const block of blocks) {
-    for (const tag of block.tags ?? []) {
-      tagFreq[tag] = (tagFreq[tag] ?? 0) + 1;
-    }
-  }
-  
-  const obsessiveTags = Object.entries(tagFreq)
-    .filter(([, count]) => count >= blocks.length * 0.4)
-    .map(([tag]) => tag);
-  
-  if (obsessiveTags.length > 0) {
-    lucidInsights.push({
-      type: 'pattern',
-      description: `执念模式检测：高频标签 [${obsessiveTags.join(', ')}] 出现≥40%记忆`,
-      weight: 0.8,
-      relatedTags: obsessiveTags,
-      blockIds: blocks.map(b => b.id),
-      actionable: `审视${obsessiveTags.join('/')}是否掩盖了其他重要模式`,
-    });
-  }
-  
-  // 矛盾检测：两个记忆内容相反但标签相同
-  for (let i = 0; i < blocks.length; i++) {
-    for (let j = i + 1; j < blocks.length; j++) {
-      if (areContradictory(blocks[i].content, blocks[j].content)) {
-        lucidInsights.push({
-          type: 'pattern',
-          description: `矛盾检测：${blocks[i].id} 与 ${blocks[j].id} 内容相反但标签重叠`,
-          weight: 0.9,
-          relatedTags: [...(blocks[i].tags ?? []), ...(blocks[j].tags ?? [])].filter((t, i, arr) => arr.indexOf(t) === i),
-          blockIds: [blocks[i].id, blocks[j].id],
-          actionable: '审视前提假设：标签相同不代表立场相同',
-        });
-      }
-    }
-  }
-  
-  return lucidInsights;
-}
-
-// Wide阶段：超越逻辑，生成反事实推理
-function widePhase(blocks: RecallBlock[], insights: Insight[], state: DreamState): Insight[] {
-  state.stages.Wide++;
-  const wideInsights: Insight[] = [];
-  
-  // 反事实：如果去掉最重要的约束，会怎样？
-  const sortedByWeight = [...blocks].sort((a, b) => (b.weight ?? 0.5) - (a.weight ?? 0.5));
-  const top3 = sortedByWeight.slice(0, 3);
-  
-  if (top3.length >= 2) {
-    wideInsights.push({
-      type: 'breakthrough',
-      description: `反事实推理：若去除 "${top3[0].id}" 的影响，"${top3[1].id}" 会有何不同？`,
-      weight: 0.7,
-      relatedTags: [...(top3[0].tags ?? []), ...(top3[1].tags ?? [])],
-      blockIds: [top3[0].id, top3[1].id],
-      actionable: '质疑最高权重记忆是否被过度强化',
-    });
-  }
-  
-  // 荒谬连接：两个完全不相关的记忆能否产生新洞见？
-  if (blocks.length >= 4) {
-    const first = blocks[0];
-    const last = blocks[blocks.length - 1];
-    const sharedTags = (first.tags ?? []).filter(t => (last.tags ?? []).includes(t));
-    
-    if (sharedTags.length === 0) {
-      wideInsights.push({
-        type: 'breakthrough',
-        description: `荒谬连接：${first.id} (${(first.tags ?? []).join(', ')}) ↔ ${last.id} (${(last.tags ?? []).join(', ')}) — 看似无关但可能存在隐藏的第三层关系`,
-        weight: 0.5,
-        relatedTags: [...(first.tags ?? []), ...(last.tags ?? [])],
-        blockIds: [first.id, last.id],
-        actionable: '寻找是否存在共同的上位概念连接这两个记忆',
-      });
-    }
-  }
-  
-  return wideInsights;
-}
-
-/**
- * 辅助函数
- */
-
-// 计算两个记忆块的连接分数
-function calculateConnectionScore(a: RecallBlock, b: RecallBlock): number {
-  let score = 0;
-  
-  // 标签重叠
-  const tagsA = new Set(a.tags ?? []);
-  const tagsB = new Set(b.tags ?? []);
-  const overlap = [...tagsA].filter(t => tagsB.has(t)).length;
-  score += overlap * 2;
-  
-  // 内容相似（简单词重叠）
-  const wordsA = new Set(a.content.split(/\s+/).filter(w => w.length > 3));
-  const wordsB = new Set(b.content.split(/\s+/).filter(w => w.length > 3));
-  const contentOverlap = [...wordsA].filter(w => wordsB.has(w)).length;
-  score += contentOverlap * 0.5;
-  
-  // 时间接近（24小时内）
-  const timeA = a.lastAccessed ?? a.createdAt ?? 0;
-  const timeB = b.lastAccessed ?? b.createdAt ?? 0;
-  if (timeA && timeB && Math.abs(timeA - timeB) < 24 * 60 * 60 * 1000) {
-    score += 1;
-  }
-  
-  return score;
-}
-
-// 判断两个内容是否矛盾（简单检测）
-function areContradictory(contentA: string, contentB: string): boolean {
-  const contradictions = [
-    ['应该', '不必'], ['必须', '不需要'], ['总是', '从不'],
-    ['所有', '没有'], ['确定', '不确定'], ['知道', '不知道'],
-    ['能', '不能'], ['可以', '不可以'], ['对', '错'],
-  ];
-  
-  const lowerA = contentA.toLowerCase();
-  const lowerB = contentB.toLowerCase();
-  
-  for (const [pos, neg] of contradictions) {
-    if ((lowerA.includes(pos) && lowerB.includes(neg)) ||
-        (lowerA.includes(neg) && lowerB.includes(pos))) {
-      return true;
-    }
-  }
-  return false;
-}
-
-export function createDreamEngine(config?: Partial<DreamConfig>): DreamEngine {
-  const emitter = new EventEmitter();
-  const state = createDreamState(config);
-  const fragments: RecallBlock[] = [];
-
-  async function runNightDream(recallBlocks: Map<string, RecallBlock> = new Map()): Promise<DreamResult> {
-    const startTime = Date.now();
-    
-    // 收集碎片：优先用recallBlocks，否则用内部fragments数组
-    const blocks = recallBlocks.size > 0
-      ? [...recallBlocks.values()]
-      : [...fragments];
-    
-    // 碎片不足，不启动梦境
-    if (blocks.length < state.config.minFragments) {
-      state.lastDreamAt = Date.now();
-      return {
-        insights: [],
-        strengthened: [],
-        weakened: [],
-        merged: [],
-        newBlocks: [],
-        cycles: 0,
-        stage: 'skipped',
-      };
-    }
-
-    state.lastDreamAt = Date.now();
-    state.dreamCount++;
-
-    let currentBlocks = blocks;
-    let allInsights: Insight[] = [];
-    const strengthened: string[] = [];
-    const weakened: string[] = [];
-    const merged: string[][] = [];
-
-    // 五阶段梦境循环
-    const stageNames = ['Light', 'REM', 'Deep', 'Lucid', 'Wide'];
-    
-    for (let i = 0; i < Math.min(state.config.maxIterations, stageNames.length); i++) {
-      const stage = stageNames[i];
-      
-      if (stage === 'Light') {
-        currentBlocks = lightPhase(currentBlocks, state);
-      } else if (stage === 'REM') {
-        const { pairs } = remPhase(currentBlocks, state);
-        const deepInsights = deepPhase(pairs, state);
-        allInsights.push(...deepInsights);
-        merged.push(...pairs.map(([a, b]) => [a.id, b.id]));
-      } else if (stage === 'Deep') {
-        // Deep insights already collected in REM phase
-      } else if (stage === 'Lucid') {
-        const lucidInsights = lucidPhase(currentBlocks, allInsights, state);
-        allInsights.push(...lucidInsights);
-      } else if (stage === 'Wide') {
-        const wideInsights = widePhase(currentBlocks, allInsights, state);
-        allInsights.push(...wideInsights);
-      }
-      
-      emitter.emit('stage', { stage, blocks: currentBlocks.length, insights: allInsights.length });
-    }
-
-    // 计算强化/弱化
-    for (const block of blocks) {
-      if ((block.weight ?? 0.5) > state.config.strengthenAbove) {
-        strengthened.push(block.id);
-      } else if ((block.weight ?? 0.5) < state.config.weakenBelow) {
-        weakened.push(block.id);
-      }
-    }
-
-    // 过滤并保存 insights
-    const significantInsights = allInsights.filter(ins => ins.weight >= 0.5);
-    state.insights.push(...significantInsights);
-    
-    // 限制总 insights 数量（滚动窗口）
-    if (state.insights.length > 1000) {
-      state.insights = state.insights.slice(-500);
-    }
-
-    // 寻找存在论突破
-    const breakthroughInsight = significantInsights.find(ins => ins.type === 'breakthrough');
-
-    const result: DreamResult = {
-      insights: significantInsights,
-      strengthened,
-      weakened,
-      merged,
-      newBlocks: [],
-      cycles: Math.min(state.config.maxIterations, stageNames.length),
-      stage: breakthroughInsight ? 'Wide+Breakthrough' : 'Wide',
-      breakthrough: breakthroughInsight?.actionable,
-    };
-
-    emitter.emit('dreamComplete', result);
-    
-    const cycleTime = Date.now() - startTime;
-    emitter.emit('timing', { stage: 'dream', duration: cycleTime });
-
-    return result;
-  }
-
-  function addFragment(block: RecallBlock): void {
-    fragments.push(block);
-  }
-
-  const engine: DreamEngine = Object.assign(
-    new EventEmitter(),
-    {
-      state,
-      runNightDream,
-      getInsights: () => getRecentInsights(state),
-      getStats: () => getDreamStats(state),
-      addFragment,
-    }
-  );
-
-  return engine;
-}
-
-// 导出工厂函数（兼容旧接口）
-export { createDreamEngine as createDreamEngineFactory };

package/src/core/dream/index.ts

@@ -1,229 +0,0 @@
-// Dream Engine — 睡眠循环 + 记忆巩固
-// Inherits from: dream.ts, dream-consolidator.ts
-
-export interface DreamConfig {
-  consolidationStrength: number;
-  patternThreshold: number;
-  strengthenAbove: number;
-  weakenBelow: number;
-  maxIterations: number;
-  autoRun: boolean;
-  intervalMs: number;
-}
-
-export interface Insight {
-  type: 'pattern' | 'connection' | 'decay' | 'merge';
-  description: string;
-  weight: number;
-  relatedTags: string[];
-  blockIds: string[];
-}
-
-export interface DreamResult {
-  insights: Insight[];
-  strengthened: string[];
-  weakened: string[];
-  merged: string[][];
-  newBlocks: string[];
-  cycles: number;
-  duration: number;
-}
-
-export interface DreamEngine {
-  boot(): void;
-  dream(blocks: unknown[], recallIndex?: unknown): Promise<DreamResult>;
-  getInsights(): Insight[];
-  getStats(): { dreamCount: number; lastDreamAt: number; totalInsights: number };
-  shutdown(): void;
-}
-
-const DEFAULT_CONFIG: DreamConfig = {
-  consolidationStrength: 0.5,
-  patternThreshold: 3,
-  strengthenAbove: 0.75,
-  weakenBelow: 0.25,
-  maxIterations: 5,
-  autoRun: false,
-  intervalMs: 60000,
-};
-
-export function createDreamEngine(config: Partial<DreamConfig> = {}): DreamEngine {
-  const cfg: DreamConfig = { ...DEFAULT_CONFIG, ...config };
-  const state = {
-    dreamCount: 0,
-    lastDreamAt: 0,
-    insights: [] as Insight[],
-    timer: null as ReturnType<typeof setInterval> | null,
-  };
-
-  function boot(): void {
-    console.log('[DreamEngine] boot — sleep cycle ready');
-    if (cfg.autoRun) {
-      state.timer = setInterval(() => {
-        // Auto-dream on interval (simplified — real impl would access memory)
-      }, cfg.intervalMs);
-    }
-  }
-
-  async function dream(blocks: unknown[] = [], _recallIndex?: unknown): Promise<DreamResult> {
-    const start = Date.now();
-    const result: DreamResult = {
-      insights: [],
-      strengthened: [],
-      weakened: [],
-      merged: [],
-      newBlocks: [],
-      cycles: 0,
-      duration: 0,
-    };
-
-    if (blocks.length === 0) {
-      state.lastDreamAt = Date.now();
-      state.dreamCount++;
-      return result;
-    }
-
-    // Phase 1: Pattern Detection — find recurring tag clusters
-    const tagFreq = buildTagFrequency(blocks);
-    const patterns = extractPatterns(tagFreq, cfg.patternThreshold);
-    for (const p of patterns) {
-      const insight: Insight = {
-        type: 'pattern',
-        description: `Recurring tag cluster: ${p.tags.join(' + ')} (${p.freq}×)`,
-        weight: Math.min(1, p.freq / 10),
-        relatedTags: p.tags,
-        blockIds: p.blockIds,
-      };
-      result.insights.push(insight);
-      state.insights.push(insight);
-    }
-
-    // Phase 2: Importance Recalibration — strengthen/weak memories
-    const nowTs = Date.now();
-    for (const block of blocks) {
-      if (result.cycles >= cfg.maxIterations) break;
-      const b = block as { importance?: number; createdAt?: number; accessCount?: number };
-      if (b.importance === undefined) continue;
-      const age = (nowTs - (b.createdAt || 0)) / (24 * 3600 * 1000);
-      if (b.importance >= cfg.strengthenAbove) {
-        const boost = (b.accessCount || 0) * 0.01 * cfg.consolidationStrength;
-        b.importance = Math.min(1, (b.importance || 0) + boost);
-        result.strengthened.push(String((block as { id?: string }).id || 'unknown'));
-      } else if (b.importance <= cfg.weakenBelow) {
-        const decay = Math.pow(0.95, age / 7);
-        b.importance = Math.max(0, (b.importance || 0) * decay);
-        result.weakened.push(String((block as { id?: string }).id || 'unknown'));
-      }
-      result.cycles++;
-    }
-
-    // Phase 3: Connection Discovery
-    const connections = findConnections(blocks, patterns);
-    for (const c of connections) {
-      const insight: Insight = {
-        type: 'connection',
-        description: `Cross-block connection: ${c.tag} bridges ${c.blockIds.length} blocks`,
-        weight: c.strength,
-        relatedTags: [c.tag],
-        blockIds: c.blockIds,
-      };
-      result.insights.push(insight);
-      state.insights.push(insight);
-    }
-
-    state.lastDreamAt = Date.now();
-    state.dreamCount++;
-    result.duration = Date.now() - start;
-
-    // Keep last 100 insights
-    if (state.insights.length > 100) {
-      state.insights = state.insights.slice(-100);
-    }
-
-    return result;
-  }
-
-  function getInsights(): Insight[] {
-    return state.insights.slice(-20);
-  }
-
-  function getStats() {
-    return {
-      dreamCount: state.dreamCount,
-      lastDreamAt: state.lastDreamAt,
-      totalInsights: state.insights.length,
-    };
-  }
-
-  function shutdown(): void {
-    if (state.timer) clearInterval(state.timer);
-    console.log('[DreamEngine] shutdown');
-  }
-
-  return { boot, dream, getInsights, getStats, shutdown };
-}
-
-// ── Internal Helpers ─────────────────────────────────────────────────────────
-
-function buildTagFrequency(blocks: unknown[]): Map<string, { freq: number; blockIds: string[] }> {
-  const freq = new Map<string, { freq: number; blockIds: string[] }>();
-  for (const block of blocks) {
-    const b = block as { tags?: string[]; id?: string };
-    if (!b.tags) continue;
-    for (const tag of b.tags) {
-      if (!freq.has(tag)) freq.set(tag, { freq: 0, blockIds: [] });
-      const entry = freq.get(tag)!;
-      entry.freq++;
-      if (b.id && !entry.blockIds.includes(b.id)) entry.blockIds.push(b.id);
-    }
-  }
-  return freq;
-}
-
-function extractPatterns(tagFreq: Map<string, { freq: number; blockIds: string[] }>, threshold: number) {
-  const patterns: { tags: string[]; freq: number; blockIds: string[] }[] = [];
-  for (const [tag, data] of tagFreq) {
-    if (data.freq >= threshold) {
-      patterns.push({ tags: [tag], freq: data.freq, blockIds: data.blockIds });
-    }
-  }
-  return patterns;
-}
-
-function findConnections(blocks: unknown[], patterns: { tags: string[]; blockIds: string[] }[]) {
-  const connections: { tag: string; blockIds: string[]; strength: number }[] = [];
-  const blockTagMap = new Map<string, Set<string>>();
-  for (const block of blocks) {
-    const b = block as { id?: string; tags?: string[] };
-    if (!b.id || !b.tags) continue;
-    blockTagMap.set(b.id, new Set(b.tags));
-  }
-  for (const [tag, data] of tagFreqFromBlocks(blocks)) {
-    if (data.freq >= 2) {
-      connections.push({ tag, blockIds: data.blockIds, strength: Math.min(1, data.freq / 5) });
-    }
-  }
-  return connections;
-}
-
-function tagFreqFromBlocks(blocks: unknown[]): Map<string, { freq: number; blockIds: string[] }> {
-  return buildTagFrequency(blocks);
-}
-
-function findMergeCandidates(blocks: unknown[], patterns: { tags: string[]; blockIds: string[] }[], cfg: DreamConfig) {
-  const merges: [unknown, unknown][] = [];
-  if (cfg.consolidationStrength < 0.4) return merges;
-  // Simple heuristic: blocks with same tags and low importance
-  for (let i = 0; i < blocks.length; i++) {
-    for (let j = i + 1; j < blocks.length; j++) {
-      const a = blocks[i] as { tags?: string[]; importance?: number };
-      const b = blocks[j] as { tags?: string[]; importance?: number };
-      if (a.tags && b.tags && a.tags.some(t => b.tags!.includes(t))) {
-        if ((a.importance || 0) < 0.3 && (b.importance || 0) < 0.3) {
-          merges.push([blocks[i], blocks[j]]);
-        }
-      }
-    }
-  }
-  return merges.slice(0, 3); // limit merges per dream cycle
-}