@yun520-1/heartflow 0.15.2

package/src/core/utils/state-snapshot.js

@@ -0,0 +1,382 @@
+/**
+ * State Snapshot - 状态快照与断点恢复
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const SNAPSHOT_CONFIG = {
+  snapshotDir: '.opencode/snapshots',
+  maxSnapshots: 20,
+  autoSnapshotInterval: 5,
+  snapshotFilePrefix: 'snapshot-',
+  metadataFile: 'snapshots-metadata.json'
+};
+
+class StateSnapshot {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.snapshotDir = path.join(projectRoot, SNAPSHOT_CONFIG.snapshotDir);
+    this.metadataFile = path.join(this.snapshotDir, SNAPSHOT_CONFIG.metadataFile);
+    this.interactionCount = 0;
+    this.loadMetadata();
+  }
+
+  loadMetadata() {
+    try {
+      if (fs.existsSync(this.metadataFile)) {
+        this.metadata = JSON.parse(fs.readFileSync(this.metadataFile, 'utf8'));
+      } else {
+        this.metadata = {
+          snapshots: [],
+          lastSnapshotId: null
+        };
+      }
+    } catch (e) {
+      this.metadata = { snapshots: [], lastSnapshotId: null };
+    }
+  }
+
+  saveMetadata() {
+    try {
+      if (!fs.existsSync(this.snapshotDir)) {
+        fs.mkdirSync(this.snapshotDir, { recursive: true });
+      }
+      const metaTmp = this.metadataFile + '.tmp';
+      fs.writeFileSync(metaTmp, JSON.stringify(this.metadata, null, 2));
+      fs.renameSync(metaTmp, this.metadataFile);
+    } catch (e) {
+      console.error('[StateSnapshot] Failed to save metadata:', e.message);
+    }
+  }
+
+  /**
+   * 获取当前核心状态
+   */
+  async captureCurrentState() {
+    const state = {
+      timestamp: new Date().toISOString(),
+      personality: await this.getPersonalityState(),
+      emotionVector: await this.getEmotionState(),
+      memoryPointer: await this.getMemoryState(),
+      activatedNodes: await this.getActivatedNodes(),
+      interactionCount: this.interactionCount,
+      metadata: {
+        version: '1.0',
+        system: 'HeartFlow'
+      }
+    };
+
+    return state;
+  }
+
+  async getPersonalityState() {
+    try {
+      const stateFile = path.join(this.projectRoot, '.opencode', 'memory', 'heartflow_state.json');
+      if (fs.existsSync(stateFile)) {
+        const state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+        return state.personality || state.big_five_scores || {};
+      }
+    } catch (e) {
+      console.error('[StateSnapshot] Failed to get personality state:', e.message);
+    }
+    return {};
+  }
+
+  async getEmotionState() {
+    try {
+      const stateFile = path.join(this.projectRoot, '.opencode', 'memory', 'heartflow_state.json');
+      if (fs.existsSync(stateFile)) {
+        const state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+        return {
+          currentEmotion: state.current_emotion || 'calm',
+          emotionVector: state.emotion_vector || { pleasure: 0, arousal: 0, dominance: 0 },
+          emotionalLog: state.emotional_log?.slice(-10) || []
+        };
+      }
+    } catch (e) {
+      console.error('[StateSnapshot] Failed to get emotion state:', e.message);
+    }
+    return { currentEmotion: 'calm', emotionVector: { pleasure: 0, arousal: 0, dominance: 0 } };
+  }
+
+  async getMemoryState() {
+    try {
+      const memoryFiles = ['intent-history.json', 'reflection-log.json', 'experience-log.json'];
+      const memoryState = {};
+
+      for (const file of memoryFiles) {
+        const filePath = path.join(this.projectRoot, '.opencode', 'memory', file);
+        if (fs.existsSync(filePath)) {
+          const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+          memoryState[file.replace('.json', '')] = data;
+        }
+      }
+
+      return memoryState;
+    } catch (e) {
+      console.error('[StateSnapshot] Failed to get memory state:', e.message);
+    }
+    return {};
+  }
+
+  async getActivatedNodes() {
+    try {
+      const assocFile = path.join(this.projectRoot, 'src', 'core', 'associative-engine', 'association-graph.json');
+      if (fs.existsSync(assocFile)) {
+        const assoc = JSON.parse(fs.readFileSync(assocFile, 'utf8'));
+        return {
+          nodeCount: Object.keys(assoc.nodes || {}).length,
+          lastActivation: assoc.metadata?.lastUpdate
+        };
+      }
+    } catch (e) {
+      console.error('[StateSnapshot] Failed to get activated nodes:', e.message);
+    }
+    return { nodeCount: 0 };
+  }
+
+  /**
+   * 拍照快照
+   */
+  async takeSnapshot(label = 'auto') {
+    try {
+      const state = await this.captureCurrentState();
+
+      const snapshotId = `snap_${Date.now()}`;
+      const snapshotFile = path.join(this.snapshotDir, `${SNAPSHOT_CONFIG.snapshotFilePrefix}${snapshotId}.json`);
+
+      // Write snapshot file FIRST, then update metadata
+      // If crash occurs after file write but before metadata save,
+      // orphaned snapshot file is harmless; missing metadata entry is recoverable
+      const snapshotData = {
+        id: snapshotId,
+        label,
+        ...state
+      };
+      const snapTmp = snapshotFile + '.tmp';
+      fs.writeFileSync(snapTmp, JSON.stringify(snapshotData, null, 2));
+      fs.renameSync(snapTmp, snapshotFile);
+
+      this.metadata.snapshots.push({
+        id: snapshotId,
+        label,
+        timestamp: state.timestamp,
+        interactionCount: this.interactionCount
+      });
+      this.metadata.lastSnapshotId = snapshotId;
+      this.saveMetadata();
+
+      this.cleanOldSnapshots();
+
+      console.log(`[StateSnapshot] Created snapshot ${snapshotId} (${label})`);
+
+      return {
+        success: true,
+        snapshotId,
+        timestamp: state.timestamp
+      };
+    } catch (e) {
+      console.error('[StateSnapshot] Failed to take snapshot:', e.message);
+      return { success: false, error: e.message };
+    }
+  }
+
+  /**
+   * 从快照恢复
+   */
+  async restoreFromSnapshot(snapshotId) {
+    try {
+      const snapshotFile = path.join(
+        this.snapshotDir,
+        `${SNAPSHOT_CONFIG.snapshotFilePrefix}${snapshotId}.json`
+      );
+
+      if (!fs.existsSync(snapshotFile)) {
+        return { success: false, error: 'Snapshot not found' };
+      }
+
+      const snapshot = JSON.parse(fs.readFileSync(snapshotFile, 'utf8'));
+
+      await this.restoreState(snapshot);
+
+      this.metadata.lastSnapshotId = snapshotId;
+      this.saveMetadata();
+
+      console.log(`[StateSnapshot] Restored from snapshot ${snapshotId}`);
+      
+      return {
+        success: true,
+        snapshotId,
+        restoredState: {
+          personality: snapshot.personality,
+          emotionVector: snapshot.emotionVector,
+          interactionCount: snapshot.interactionCount
+        }
+      };
+    } catch (e) {
+      console.error('[StateSnapshot] Failed to restore:', e.message);
+      return { success: false, error: e.message };
+    }
+  }
+
+  async restoreState(snapshot) {
+    try {
+      const stateFile = path.join(this.projectRoot, '.opencode', 'memory', 'heartflow_state.json');
+      let state = {};
+
+      if (fs.existsSync(stateFile)) {
+        state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+      }
+
+      if (snapshot.personality) {
+        state.personality = snapshot.personality;
+      }
+      if (snapshot.emotionVector) {
+        state.emotion_vector = snapshot.emotionVector.emotionVector;
+        state.current_emotion = snapshot.emotionVector.currentEmotion;
+        state.emotional_log = snapshot.emotionVector.emotionalLog || [];
+      } else {
+        // Emotion data absent from snapshot — clear stale emotion fields to prevent
+        // partial state where old emotion_vector persists after a snapshot taken
+        // before emotion tracking was added
+        delete state.emotion_vector;
+        delete state.current_emotion;
+        delete state.emotional_log;
+      }
+
+      const stateTmp = stateFile + '.tmp';
+      fs.writeFileSync(stateTmp, JSON.stringify(state, null, 2));
+      fs.renameSync(stateTmp, stateFile);
+
+      this.interactionCount = snapshot.interactionCount || 0;
+
+      return { success: true };
+    } catch (e) {
+      console.error('[StateSnapshot] Failed to restore state:', e.message);
+      return { success: false, error: e.message };
+    }
+  }
+
+  cleanOldSnapshots() {
+    if (this.metadata.snapshots.length <= SNAPSHOT_CONFIG.maxSnapshots) {
+      return;
+    }
+
+    const toRemove = this.metadata.snapshots.slice(
+      0,
+      this.metadata.snapshots.length - SNAPSHOT_CONFIG.maxSnapshots
+    );
+
+    for (const snap of toRemove) {
+      const file = path.join(
+        this.snapshotDir,
+        `${SNAPSHOT_CONFIG.snapshotFilePrefix}${snap.id}.json`
+      );
+      if (fs.existsSync(file)) {
+        fs.unlinkSync(file);
+      }
+    }
+
+    this.metadata.snapshots = this.metadata.snapshots.slice(
+      -SNAPSHOT_CONFIG.maxSnapshots
+    );
+  }
+
+  /**
+   * 增加交互计数并在达到阈值时自动快照
+   */
+  incrementInteraction() {
+    this.interactionCount++;
+
+    if (this.interactionCount % SNAPSHOT_CONFIG.autoSnapshotInterval === 0) {
+      this.takeSnapshot('auto');
+    }
+
+    return this.interactionCount;
+  }
+
+  /**
+   * 获取快照列表
+   */
+  listSnapshots() {
+    return this.metadata.snapshots.slice().reverse().map(s => ({
+      id: s.id,
+      label: s.label,
+      timestamp: s.timestamp,
+      interactionCount: s.interactionCount
+    }));
+  }
+
+  /**
+   * 获取快照详情
+   */
+  getSnapshotDetail(snapshotId) {
+    try {
+      const snapshotFile = path.join(
+        this.snapshotDir,
+        `${SNAPSHOT_CONFIG.snapshotFilePrefix}${snapshotId}.json`
+      );
+
+      if (!fs.existsSync(snapshotFile)) {
+        return null;
+      }
+
+      const snapshot = JSON.parse(fs.readFileSync(snapshotFile, 'utf8'));
+      return {
+        id: snapshot.id,
+        label: snapshot.label,
+        timestamp: snapshot.timestamp,
+        personality: snapshot.personality,
+        emotionVector: snapshot.emotionVector,
+        memoryPointer: Object.keys(snapshot.memoryPointer || {}).length,
+        activatedNodes: snapshot.activatedNodes,
+        interactionCount: snapshot.interactionCount
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+
+  /**
+   * 删除快照
+   */
+  deleteSnapshot(snapshotId) {
+    try {
+      const snapshotFile = path.join(
+        this.snapshotDir,
+        `${SNAPSHOT_CONFIG.snapshotFilePrefix}${snapshotId}.json`
+      );
+
+      if (!fs.existsSync(snapshotFile)) {
+        return { success: false, error: 'Snapshot not found' };
+      }
+
+      fs.unlinkSync(snapshotFile);
+
+      this.metadata.snapshots = this.metadata.snapshots.filter(s => s.id !== snapshotId);
+      if (this.metadata.lastSnapshotId === snapshotId) {
+        this.metadata.lastSnapshotId = this.metadata.snapshots[0]?.id || null;
+      }
+      this.saveMetadata();
+
+      return { success: true };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+
+  /**
+   * 获取统计信息
+   */
+  getStats() {
+    return {
+      totalSnapshots: this.metadata.snapshots.length,
+      lastSnapshotId: this.metadata.lastSnapshotId,
+      currentInteractionCount: this.interactionCount,
+      snapshotsDir: this.snapshotDir
+    };
+  }
+}
+
+module.exports = { StateSnapshot, SNAPSHOT_CONFIG };

package/src/index.ts

@@ -0,0 +1,198 @@
+// HeartFlow v0.13 — Autonomous Decision Engine
+// 主导出：整合所有引擎的一站式 API
+
+export type { EventBus, Event, EventType } from './runtime/event-bus.js';
+export type { HeartFlowConfig } from './runtime/config.js';
+
+// Core Engines
+export type { IdentityEngine, IdentityStateData, CoreIdentity } from './core/identity/index.js';
+export type { MemoryEngine, MemoryEntry } from './core/memory/index.js';
+export type { EvolutionEngine, EvolutionResult, EvolutionConfig } from './core/evolution/index.js';
+export type { CognitionEngine, ReasoningTrace, Plan } from './core/cognition/index.js';
+export type { SelfEvolutionEngine, SelfEvolutionResult, GrowthMetrics } from './core/self-evolution/index.js';
+export type { DreamEngine, DreamResult, Insight } from './core/dream/index.js';
+export type { EmotionEngine, EmotionState } from './core/emotion/index.js';
+export type { KnowledgeGraphEngine, KGNode, KGEdge } from './core/knowledge/index.js';
+export type { AgentsEngine, MultiAgentResult } from './core/agents/index.js';
+
+// Agent Engines
+export type { EthicsEngine, EthicalJudgment } from './agent/ethics/index.js';
+export type { AutonomyAgent, AutonomyDecision } from './agent/autonomy/index.js';
+export type { ConsciousnessAgent, ConsciousnessEvent, ConsciousnessState } from './agent/consciousness/index.js';
+export type { TransmissionAgent, TransmissionResult } from './agent/transmission/index.js';
+
+// Storage & Security
+export type { CheckpointEngine, Checkpoint } from './storage/checkpoint.js';
+export type { VectorStoreEngine, VectorEntry, SearchResult } from './storage/vector-store.js';
+export type { SecurityEngine, InjectionResult, SanitizedInput, PIIResult } from './security/index.js';
+
+// Orchestrator
+export type { Supervisor, AgentInput, AgentOutput } from './orchestrator/supervisor.js';
+
+// Factory exports
+export { createIdentityEngine } from './core/identity/index.js';
+export { createMemoryEngine } from './core/memory/index.js';
+export { createEvolutionEngine } from './core/evolution/index.js';
+export { createCognitionEngine } from './core/cognition/index.js';
+export { createSelfEvolutionEngine } from './core/self-evolution/index.js';
+export { createDreamEngine } from './core/dream/index.js';
+export { createEmotionEngine } from './core/emotion/index.js';
+export { createKnowledgeGraphEngine } from './core/knowledge/index.js';
+export { createAgentsEngine } from './core/agents/index.js';
+export { createEthicsEngine } from './agent/ethics/index.js';
+export { createAutonomyAgent } from './agent/autonomy/index.js';
+export { createConsciousnessAgent } from './agent/consciousness/index.js';
+export { createTransmissionAgent } from './agent/transmission/index.js';
+export { createCheckpointEngine } from './storage/checkpoint.js';
+export { createVectorStoreEngine } from './storage/vector-store.js';
+export { createSecurityEngine } from './security/index.js';
+export { createSupervisor } from './orchestrator/supervisor.js';
+export { getConfig, setConfig } from './runtime/config.js';
+
+// Main HeartFlow Engine
+import { createIdentityEngine } from './core/identity/index.js';
+import { createMemoryEngine } from './core/memory/index.js';
+import { createEvolutionEngine } from './core/evolution/index.js';
+import { createCognitionEngine } from './core/cognition/index.js';
+import { createSelfEvolutionEngine } from './core/self-evolution/index.js';
+import { createDreamEngine } from './core/dream/index.js';
+import { createEmotionEngine } from './core/emotion/index.js';
+import { createKnowledgeGraphEngine } from './core/knowledge/index.js';
+import { createAgentsEngine } from './core/agents/index.js';
+import { createEthicsEngine } from './agent/ethics/index.js';
+import { createAutonomyAgent } from './agent/autonomy/index.js';
+import { createConsciousnessAgent } from './agent/consciousness/index.js';
+import { createTransmissionAgent } from './agent/transmission/index.js';
+import { createCheckpointEngine } from './storage/checkpoint.js';
+import { createVectorStoreEngine } from './storage/vector-store.js';
+import { createSecurityEngine } from './security/index.js';
+import { createSupervisor, type SupervisorConfig } from './orchestrator/supervisor.js';
+import { globalEventBus } from './runtime/event-bus.js';
+import { getConfig } from './runtime/config.js';
+
+export interface HeartFlowEngine {
+  version: string;
+  boot(): Promise<void>;
+  shutdown(): Promise<void>;
+  ready: boolean;
+
+  // Core
+  identity: ReturnType<typeof createIdentityEngine>;
+  memory: ReturnType<typeof createMemoryEngine>;
+  evolution: ReturnType<typeof createEvolutionEngine>;
+  cognition: ReturnType<typeof createCognitionEngine>;
+  selfEvolution: ReturnType<typeof createSelfEvolutionEngine>;
+  dream: ReturnType<typeof createDreamEngine>;
+  emotion: ReturnType<typeof createEmotionEngine>;
+  knowledge: ReturnType<typeof createKnowledgeGraphEngine>;
+  agents: ReturnType<typeof createAgentsEngine>;
+
+  // Agent
+  ethics: ReturnType<typeof createEthicsEngine>;
+  autonomy: ReturnType<typeof createAutonomyAgent>;
+  consciousness: ReturnType<typeof createConsciousnessAgent>;
+  transmission: ReturnType<typeof createTransmissionAgent>;
+
+  // Infrastructure
+  checkpoint: ReturnType<typeof createCheckpointEngine>;
+  vectorStore: ReturnType<typeof createVectorStoreEngine>;
+  security: ReturnType<typeof createSecurityEngine>;
+
+  supervisor: ReturnType<typeof createSupervisor>;
+  run(input: { task: string; context?: Record<string, unknown> }): Promise<{ result: unknown; reasoning: string; steps: number; success: boolean }>;
+}
+
+export function createHeartFlow(config?: SupervisorConfig): HeartFlowEngine {
+  // Core engines
+  const identity = createIdentityEngine();
+  const memory = createMemoryEngine();
+  const evolution = createEvolutionEngine({ populationSize: 10, mutationRate: 0.1 });
+  const cognition = createCognitionEngine();
+  const selfEvolution = createSelfEvolutionEngine();
+  const dream = createDreamEngine();
+  const emotion = createEmotionEngine();
+  const knowledge = createKnowledgeGraphEngine();
+  const agents = createAgentsEngine();
+
+  // Agent engines
+  const ethics = createEthicsEngine();
+  const autonomy = createAutonomyAgent();
+  const consciousness = createConsciousnessAgent();
+  const transmission = createTransmissionAgent();
+
+  // Infrastructure
+  const checkpoint = createCheckpointEngine('0.13.0');
+  const vectorStore = createVectorStoreEngine();
+  const security = createSecurityEngine();
+
+  const supervisor = createSupervisor(
+    identity, memory, evolution, cognition,
+    ethics, autonomy, consciousness, transmission,
+    config ?? { maxSteps: 10, verbose: getConfig().verbose }
+  );
+
+  let ready = false;
+
+  return {
+    version: '0.13.0',
+    ready: false,
+
+    identity, memory, evolution, cognition,
+    selfEvolution, dream, emotion, knowledge, agents,
+    ethics, autonomy, consciousness, transmission,
+    checkpoint, vectorStore, security,
+    supervisor,
+
+    async boot(): Promise<void> {
+      identity.boot();
+      memory.boot();
+      evolution.boot();
+      cognition.boot();
+      selfEvolution.boot();
+      dream.boot();
+      emotion.boot();
+      knowledge.boot();
+      agents.boot();
+      ethics.boot();
+      autonomy.boot();
+      consciousness.boot();
+      transmission.boot();
+      checkpoint.boot();
+      vectorStore.boot();
+      security.boot();
+      supervisor.boot();
+
+      globalEventBus.emit('identity:booted', 'heartflow', { version: '0.13.8' });
+      ready = true;
+      console.log('[HeartFlow] v0.13.8 boot complete — 15 engines initialized');
+    },
+
+    async shutdown(): Promise<void> {
+      console.log('[HeartFlow] shutting down...');
+      security.shutdown();
+      vectorStore.shutdown();
+      checkpoint.shutdown();
+      transmission.shutdown();
+      consciousness.shutdown();
+      autonomy.shutdown();
+      ethics.shutdown();
+      agents.shutdown();
+      knowledge.shutdown();
+      emotion.shutdown();
+      dream.shutdown();
+      selfEvolution.shutdown();
+      cognition.shutdown();
+      evolution.shutdown();
+      memory.shutdown();
+      identity.shutdown();
+      supervisor.shutdown();
+      ready = false;
+      console.log('[HeartFlow] shutdown complete');
+    },
+
+    async run(input): Promise<{ result: unknown; reasoning: string; steps: number; success: boolean }> {
+      if (!ready) throw new Error('HeartFlow not booted. Call boot() first.');
+      return supervisor.run(input);
+    },
+  };
+}