@yun520-1/heartflow 0.15.2 → 0.16.0

package/src/core/self-evolution/generative-agents.js

@@ -1,886 +0,0 @@
-/**
- * Generative Agents - Memory Stream Architecture
- * Based on "Generative Agents: Interactive Simulacra of Human Behavior" (Park et al. 2023)
- * arXiv: 2304.03442, UIST '23
- * 
- * Core Architecture:
- * - Memory Stream: Comprehensive record of agent's experience (natural language)
- * - Reflection: Synthesizes memories into higher-level inferences
- * - Planning: Translates conclusions into high-level action plans
- * 
- * Key Innovation: Three-component architecture enabling emergent social behaviors
- * and believable agent simulation through dynamic memory retrieval
- * 
- * @version v0.13.13
- */
-
-'use strict';
-
-const path = require('path');
-const fs = require('fs');
-
-/**
- * Memory Object - Base element of the memory stream
- * Contains natural language description, timestamps, and metadata
- */
-class MemoryObject {
-  constructor(type, content, metadata = {}) {
-    this.id = `mem-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    this.type = type; // 'observation', 'reflection', 'plan', 'event'
-    this.content = content;
-    this.createdAt = Date.now();
-    this.lastAccessedAt = Date.now();
-    this.importance = metadata.importance || 5; // 1-10 scale
-    this.tags = metadata.tags || [];
-    this.metadata = metadata;
-  }
-
-  access() {
-    this.lastAccessedAt = Date.now();
-  }
-
-  toString() {
-    return `[${this.type}] ${this.content}`;
-  }
-}
-
-/**
- * Observation - Events directly perceived by the agent
- * Base element of the memory stream
- */
-class Observation extends MemoryObject {
-  constructor(content, metadata = {}) {
-    super('observation', content, metadata);
-    this.actor = metadata.actor || null; // Who performed the action
-    this.subject = metadata.subject || null; // What the action was performed on
-    this.location = metadata.location || null;
-  }
-}
-
-/**
- * Reflection - Higher-level, abstract thoughts generated by the agent
- * Synthesized from multiple observations
- */
-class Reflection extends MemoryObject {
-  constructor(content, insights, evidence, metadata = {}) {
-    super('reflection', content, metadata);
-    this.insights = insights; // Extracted high-level insights
-    this.evidence = evidence; // Memory IDs that support this reflection
-    this.level = metadata.level || 1; // Abstraction level (higher = more abstract)
-  }
-}
-
-/**
- * Plan - Future sequence of actions for the agent
- * Includes location, start time, and duration
- */
-class Plan extends MemoryObject {
-  constructor(content, details = {}) {
-    super('plan', content, {});
-    this.location = details.location || null;
-    this.startTime = details.startTime || null;
-    this.duration = details.duration || null;
-    this.subTasks = details.subTasks || [];
-    this.status = details.status || 'pending'; // 'pending', 'in_progress', 'completed'
-  }
-
-  addSubTask(task) {
-    this.subTasks.push(task);
-  }
-
-  complete() {
-    this.status = 'completed';
-  }
-}
-
-/**
- * Memory Retrieval Function
- * Implements the three-component scoring:
- * 1. Recency - exponential decay over time
- * 2. Importance - distinguishes mundane from core memories
- * 3. Relevance - cosine similarity with query embedding
- */
-class MemoryRetrieval {
-  constructor(config = {}) {
-    this.recencyDecay = config.recencyDecay || 0.995;
-    this.recencyWeight = config.recencyWeight || 1.0;
-    this.importanceWeight = config.importanceWeight || 1.0;
-    this.relevanceWeight = config.relevanceWeight || 1.0;
-    this.maxResults = config.maxResults || 10;
-  }
-
-  /**
-   * Calculate recency score using exponential decay
-   * @param {number} hoursAgo - Hours since memory was last accessed
-   * @returns {number} Recency score [0, 1]
-   */
-  calculateRecency(hoursAgo) {
-    return Math.pow(this.recencyDecay, hoursAgo);
-  }
-
-  /**
-   * Calculate importance score (already stored with memory)
-   * @param {number} importance - Importance value [1-10]
-   * @returns {number} Normalized importance [0, 1]
-   */
-  normalizeImportance(importance) {
-    return importance / 10;
-  }
-
-  /**
-   * Calculate relevance using cosine similarity (simplified embedding)
-   * In production, would use actual embeddings
-   * @param {string} text1 - First text
-   * @param {string} text2 - Second text
-   * @returns {number} Relevance score [0, 1]
-   */
-  calculateRelevance(text1, text2) {
-    // Simple keyword-based similarity
-    const words1 = new Set(text1.toLowerCase().split(/\s+/).filter(w => w.length > 2));
-    const words2 = new Set(text2.toLowerCase().split(/\s+/).filter(w => w.length > 2));
-    
-    if (words1.size === 0 || words2.size === 0) return 0;
-    
-    const intersection = [...words1].filter(w => words2.has(w)).length;
-    const union = new Set([...words1, ...words2]).size;
-    
-    return union > 0 ? intersection / union : 0;
-  }
-
-  /**
-   * Retrieve relevant memories for a given query
-   * @param {MemoryObject[]} memories - All memories in the stream
-   * @param {string} query - Query describing current situation
-   * @param {object} context - Additional context for filtering
-   * @returns {MemoryObject[]} Sorted list of relevant memories
-   */
-  retrieve(memories, query, context = {}) {
-    const now = Date.now();
-    const scores = [];
-
-    for (const memory of memories) {
-      // Calculate recency
-      const hoursAgo = (now - memory.lastAccessedAt) / (1000 * 60 * 60);
-      const recencyScore = this.calculateRecency(hoursAgo);
-
-      // Calculate importance (normalized)
-      const importanceScore = this.normalizeImportance(memory.importance);
-
-      // Calculate relevance
-      const relevanceScore = this.calculateRelevance(query, memory.content);
-
-      // Weighted combination
-      const totalScore = 
-        this.recencyWeight * recencyScore +
-        this.importanceWeight * importanceScore +
-        this.relevanceWeight * relevanceScore;
-
-      scores.push({
-        memory,
-        score: totalScore,
-        breakdown: { recency: recencyScore, importance: importanceScore, relevance: relevanceScore }
-      });
-    }
-
-    // Sort by score descending
-    scores.sort((a, b) => b.score - a.score);
-
-    // Return top results
-    return scores.slice(0, this.maxResults).map(s => ({
-      memory: s.memory,
-      score: s.score,
-      breakdown: s.breakdown
-    }));
-  }
-}
-
-/**
- * Reflection Generator
- * Synthesizes observations into higher-level reflections
- * Triggered when sum of importance scores exceeds threshold
- */
-class ReflectionGenerator {
-  constructor(config = {}) {
-    this.importanceThreshold = config.importanceThreshold || 150;
-    this.maxMemoriesForReflection = config.maxMemoriesForReflection || 100;
-  }
-
-  /**
-   * Determine if reflection should be triggered
-   * @param {MemoryObject[]} recentMemories - Recent memories to evaluate
-   * @returns {boolean} True if reflection should be generated
-   */
-  shouldReflect(recentMemories) {
-    const totalImportance = recentMemories
-      .slice(0, this.maxMemoriesForReflection)
-      .reduce((sum, m) => sum + m.importance, 0);
-    
-    return totalImportance >= this.importanceThreshold;
-  }
-
-  /**
-   * Generate candidate questions from recent memories
-   * @param {MemoryObject[]} memories - Recent memories
-   * @returns {string[]} Candidate questions
-   */
-  generateCandidateQuestions(memories) {
-    // In production, would use LLM to generate questions
-    // Here we use heuristic extraction
-    const contents = memories.map(m => m.content).join('\n');
-    
-    const questions = [];
-    
-    // Detect topics
-    if (/research|study|paper/i.test(contents)) {
-      questions.push('What is the subject passionate about?');
-    }
-    if (/talk|converse|discuss/i.test(contents)) {
-      questions.push('What is the nature of the relationship?');
-    }
-    if (/work|job|task/i.test(contents)) {
-      questions.push('What are the work priorities and deadlines?');
-    }
-    
-    // Default questions
-    if (questions.length === 0) {
-      questions.push('What are the most salient observations?');
-      questions.push('What patterns can be identified?');
-    }
-    
-    return questions.slice(0, 3);
-  }
-
-  /**
-   * Generate reflection from memories
-   * @param {MemoryObject[]} memories - Relevant memories
-   * @param {string} question - Question being addressed
-   * @returns {object} Reflection with insights and evidence
-   */
-  generateReflection(memories, question) {
-    const insights = [];
-    const evidence = memories.map(m => m.id);
-    
-    // In production, would use LLM to extract insights
-    // Here we use pattern matching
-    
-    const contents = memories.map(m => m.content).join(' ');
-    
-    // Detect passion/interest
-    if (/research|study|paper|write/i.test(contents)) {
-      insights.push('Subject is dedicated to their research work');
-    }
-    
-    // Detect relationships
-    if (/talk|converse|discuss|meet/i.test(contents)) {
-      insights.push('Subject has active social interactions');
-    }
-    
-    // Detect location patterns
-    const locations = memories.filter(m => m.location).map(m => m.location);
-    if (locations.length > 0) {
-      const mostCommon = this.mostCommon(locations);
-      insights.push(`Frequently at ${mostCommon}`);
-    }
-    
-    // Generate reflection content
-    const content = insights.length > 0 
-      ? `Based on recent observations: ${insights.join('. ')}`
-      : 'No significant patterns detected in recent observations';
-
-    return {
-      content,
-      insights,
-      evidence,
-      question,
-      timestamp: Date.now()
-    };
-  }
-
-  mostCommon(arr) {
-    const counts = {};
-    arr.forEach(item => { counts[item] = (counts[item] || 0) + 1; });
-    return Object.entries(counts).sort((a, b) => b[1] - a[1])[0]?.[0] || 'unknown';
-  }
-}
-
-/**
- * Plan Generator
- * Creates and manages agent plans using top-down decomposition
- */
-class PlanGenerator {
-  constructor(config = {}) {
-    this.planDetailLevels = config.planDetailLevels || 5;
-    this.hoursPerChunk = config.hoursPerChunk || 2;
-  }
-
-  /**
-   * Create initial day plan from agent summary and previous day
-   * @param {object} agentSummary - Agent's summary description
-   * @param {string} previousDaySummary - Summary of previous day's activities
-   * @param {string} currentDate - Current date
-   * @returns {Plan[]} Generated plans
-   */
-  createDayPlan(agentSummary, previousDaySummary, currentDate) {
-    const plans = [];
-    
-    // In production, would use LLM to generate plans
-    // Here we use template-based generation
-    
-    const wakeHour = 8;
-    const sleepHour = 22;
-    const activeHours = sleepHour - wakeHour;
-    const chunks = Math.floor(activeHours / this.hoursPerChunk);
-    
-    const templates = [
-      { hour: wakeHour, activity: 'morning routine', location: 'home' },
-      { hour: wakeHour + 1, activity: 'breakfast', location: 'kitchen' },
-      { hour: 9, activity: 'work/school', location: 'office/classroom' },
-      { hour: 12, activity: 'lunch', location: 'cafetereria' },
-      { hour: 13, activity: 'work/classes', location: 'office/classroom' },
-      { hour: 17, activity: 'personal time', location: 'varies' },
-      { hour: 19, activity: 'dinner', location: 'home' },
-      { hour: 20, activity: 'evening relaxation', location: 'home' },
-    ];
-    
-    templates.forEach((t, i) => {
-      if (i < chunks) {
-        const plan = new Plan(
-          `${t.activity} at ${t.hour}:00`,
-          {
-            location: t.location,
-            startTime: `${currentDate} ${t.hour}:00`,
-            duration: this.hoursPerChunk * 60, // minutes
-            subTasks: []
-          }
-        );
-        plans.push(plan);
-      }
-    });
-    
-    return plans;
-  }
-
-  /**
-   * Refine plan with more detail (top-down decomposition)
-   * @param {Plan} plan - Plan to refine
-   * @param {string} context - Additional context
-   * @returns {Plan} Refined plan with sub-tasks
-   */
-  refinePlan(plan, context = '') {
-    // Add sub-tasks based on activity type
-    const activityLower = plan.content.toLowerCase();
-    
-    if (/work|study|research/i.test(activityLower)) {
-      plan.addSubTask('Gather materials/resources');
-      plan.addSubTask('Focus on primary task');
-      plan.addSubTask('Take breaks periodically');
-    }
-    
-    if (/paint|art|creative/i.test(activityLower)) {
-      plan.addSubTask('Gather art supplies');
-      plan.addSubTask('Set up workspace');
-      plan.addSubTask('Work on project');
-      plan.addSubTask('Clean up materials');
-    }
-    
-    if (/cook|meal/i.test(activityLower)) {
-      plan.addSubTask('Prepare ingredients');
-      plan.addSubTask('Cook meal');
-      plan.addSubTask('Set table');
-      plan.addSubTask('Clean up kitchen');
-    }
-    
-    return plan;
-  }
-
-  /**
-   * Update plan based on environment changes
-   * @param {Plan[]} plans - Current plans
-   * @param {object} change - Environment change
-   * @returns {Plan[]} Updated plans
-   */
-  reactToEnvironment(plans, change) {
-    // In production, would use LLM to decide how to modify plans
-    // Here we use simple heuristics
-    
-    if (change.interrupted) {
-      // Find current plan and mark as interrupted
-      const currentPlan = plans.find(p => p.status === 'in_progress');
-      if (currentPlan) {
-        currentPlan.status = 'interrupted';
-      }
-    }
-    
-    if (change.opportunity) {
-      // Could add new plan for opportunity
-      const opportunityPlan = new Plan(
-        `Take advantage of: ${change.opportunity}`,
-        { location: change.location || null }
-      );
-      plans.push(opportunityPlan);
-    }
-    
-    return plans;
-  }
-}
-
-/**
- * Memory Stream - Long-term memory module
- * Maintains comprehensive record of agent's experience
- */
-class MemoryStream {
-  constructor(config = {}) {
-    this.memories = [];
-    this.maxMemories = config.maxMemories || 10000;
-    this.retrieval = new MemoryRetrieval(config.retrieval);
-    this.reflectionGenerator = new ReflectionGenerator(config.reflection);
-    this.planGenerator = new PlanGenerator(config.plan);
-    
-    // Importance scoring callback (in production, would use LLM)
-    this.importanceFn = config.importanceFn || this.defaultImportance;
-  }
-
-  /**
-   * Default importance scoring function
-   */
-  defaultImportance(content) {
-    const lower = content.toLowerCase();
-    
-    // High importance events
-    if (/breakup|acceptance|fired|death|birth|marriage/i.test(lower)) return 8;
-    if (/passionate|love|hate|excited|angry/i.test(lower)) return 7;
-    
-    // Medium importance
-    if (/work|school|project|meeting|deadline/i.test(lower)) return 5;
-    if (/friend|family|colleague/i.test(lower)) return 5;
-    
-    // Low importance - daily routines
-    if (/eat|sleep|brush|shower|bed|routine/i.test(lower)) return 2;
-    
-    return 4; // Default
-  }
-
-  /**
-   * Add observation to memory stream
-   * @param {string} content - Observation content
-   * @param {object} metadata - Additional metadata
-   */
-  addObservation(content, metadata = {}) {
-    const importance = metadata.importance || this.importanceFn(content);
-    
-    const observation = new Observation(content, {
-      ...metadata,
-      importance
-    });
-    
-    this.memories.push(observation);
-    this.enforceMaxSize();
-    
-    return observation;
-  }
-
-  /**
-   * Add reflection to memory stream
-   * @param {Reflection} reflection - Reflection object
-   */
-  addReflection(reflection) {
-    this.memories.push(reflection);
-    this.enforceMaxSize();
-    return reflection;
-  }
-
-  /**
-   * Add plan to memory stream
-   * @param {Plan} plan - Plan object
-   */
-  addPlan(plan) {
-    this.memories.push(plan);
-    this.enforceMaxSize();
-    return plan;
-  }
-
-  /**
-   * Retrieve relevant memories for current situation
-   * @param {string} query - Query describing current situation
-   * @param {object} context - Additional context
-   * @returns {object[]} Retrieved memories with scores
-   */
-  retrieve(query, context = {}) {
-    const results = this.retrieval.retrieve(this.memories, query, context);
-    
-    // Update last accessed time
-    results.forEach(r => r.memory.access());
-    
-    return results;
-  }
-
-  /**
-   * Check if reflection should be triggered and generate if needed
-   * @returns {Reflection|null} Generated reflection or null
-   */
-  maybeGenerateReflection() {
-    const recentMemories = this.getRecentMemories(100);
-    
-    if (this.reflectionGenerator.shouldReflect(recentMemories)) {
-      const questions = this.reflectionGenerator.generateCandidateQuestions(recentMemories);
-      const question = questions[0];
-      
-      const relevantMemories = this.retrieve(question);
-      const memoryObjects = relevantMemories.map(r => r.memory);
-      
-      const reflectionData = this.reflectionGenerator.generateReflection(memoryObjects, question);
-      
-      const reflection = new Reflection(
-        reflectionData.content,
-        reflectionData.insights,
-        reflectionData.evidence,
-        { level: 1 }
-      );
-      
-      this.addReflection(reflection);
-      return reflection;
-    }
-    
-    return null;
-  }
-
-  /**
-   * Get recent memories
-   * @param {number} count - Number of recent memories
-   * @returns {MemoryObject[]}
-   */
-  getRecentMemories(count = 10) {
-    return [...this.memories]
-      .sort((a, b) => b.createdAt - a.createdAt)
-      .slice(0, count);
-  }
-
-  /**
-   * Get all memories of a specific type
-   * @param {string} type - Memory type
-   * @returns {MemoryObject[]}
-   */
-  getMemoriesByType(type) {
-    return this.memories.filter(m => m.type === type);
-  }
-
-  /**
-   * Enforce maximum memory size using FIFO
-   */
-  enforceMaxSize() {
-    while (this.memories.length > this.maxMemories) {
-      // Find oldest-lowest-importance in O(n) instead of full O(n log n) sort
-      let minScore = Infinity;
-      let minIdx = -1;
-      for (let i = 0; i < this.memories.length; i++) {
-        const m = this.memories[i];
-        const score = (m.createdAt || 0) + (m.importance || 0) * 1e10;
-        if (score < minScore) { minScore = score; minIdx = i; }
-      }
-      if (minIdx >= 0) this.memories.splice(minIdx, 1);
-    }
-  }
-
-  /**
-   * Get statistics
-   */
-  getStats() {
-    const byType = {};
-    this.memories.forEach(m => {
-      byType[m.type] = (byType[m.type] || 0) + 1;
-    });
-    
-    return {
-      total: this.memories.length,
-      byType,
-      recentCount: this.getRecentMemories(5).length
-    };
-  }
-}
-
-/**
- * Generative Agent - Main Class
- * Combines Memory Stream, Reflection, and Planning for believable agent behavior
- */
-class GenerativeAgent {
-  constructor(config = {}) {
-    this.name = config.name || 'Agent';
-    this.age = config.age || null;
-    this.traits = config.traits || [];
-    this.summary = config.summary || '';
-    
-    this.memoryStream = new MemoryStream(config.memory);
-    this.observationCount = 0;
-    this.planCount = 0;
-    
-    console.log(`[GenerativeAgent] ${this.name} initialized`);
-  }
-
-  /**
-   * Set agent's core description
-   * @param {string} summary - Summary description
-   * @param {string[]} traits - Innate traits
-   */
-  setCoreDescription(summary, traits = []) {
-    this.summary = summary;
-    this.traits = traits;
-    
-    // Add to memory
-    this.memoryStream.addObservation(
-      `Core identity: ${summary}`,
-      { importance: 10, tags: ['identity'] }
-    );
-  }
-
-  /**
-   * Perceive environment and add observation
-   * @param {string} content - What was perceived
-   * @param {object} metadata - Additional metadata
-   */
-  observe(content, metadata = {}) {
-    this.observationCount++;
-    
-    const observation = this.memoryStream.addObservation(content, {
-      ...metadata,
-      importance: metadata.importance || this.memoryStream.importanceFn(content)
-    });
-    
-    // Check for reflection
-    const reflection = this.memoryStream.maybeGenerateReflection();
-    if (reflection) {
-      console.log(`[${this.name}] Generated reflection: ${reflection.content.substring(0, 50)}...`);
-    }
-    
-    return observation;
-  }
-
-  /**
-   * Retrieve relevant memories for current situation
-   * @param {string} situation - Current situation description
-   * @returns {MemoryObject[]} Relevant memories
-   */
-  remember(situation) {
-    const results = this.memoryStream.retrieve(situation);
-    return results;
-  }
-
-  /**
-   * Create daily plan
-   * @param {string} date - Date for plan
-   * @param {string} previousDaySummary - Previous day's activities
-   */
-  planDay(date, previousDaySummary = '') {
-    const plans = this.planGenerator.createDayPlan(
-      this.summary + '\nTraits: ' + this.traits.join(', '),
-      previousDaySummary,
-      date
-    );
-    
-    plans.forEach(p => {
-      this.planGenerator.refinePlan(p);
-      this.memoryStream.addPlan(p);
-      this.planCount++;
-    });
-    
-    return plans;
-  }
-
-  /**
-   * Get current plan
-   * @returns {Plan[]}
-   */
-  getCurrentPlans() {
-    return this.memoryStream.getMemoriesByType('plan')
-      .filter(p => p.status === 'pending' || p.status === 'in_progress');
-  }
-
-  /**
-   * React to environment change
-   * @param {object} change - Environment change
-   */
-  react(change) {
-    // Observe the change
-    this.observe(`Environment changed: ${change.description || JSON.stringify(change)}`);
-    
-    // Update plans if needed
-    const plans = this.getCurrentPlans();
-    this.planGenerator.reactToEnvironment(plans, change);
-  }
-
-  /**
-   * Converse with another agent
-   * @param {string} message - Message received
-   * @param {GenerativeAgent} other - Other agent
-   * @returns {string} Response
-   */
-  async converse(message, other) {
-    // Remember the conversation
-    this.observe(`${this.name} and ${other.name} conversed about: ${message}`);
-    
-    // Retrieve relevant memories
-    const relevant = this.remember(message);
-    
-    // In production, would use LLM to generate response
-    // Here we generate simple response
-    const response = this.generateResponse(message, relevant, other);
-    
-    // Remember own response
-    this.observe(`${this.name} said to ${other.name}: ${response}`);
-    
-    return response;
-  }
-
-  /**
-   * Generate response (simplified)
-   */
-  generateResponse(message, relevantMemories, other) {
-    const memoryContents = relevantMemories.map(r => r.memory.content).join('; ');
-    
-    if (/party|event|invitation/i.test(message)) {
-      return "That sounds great! I'd like to come.";
-    }
-    if (/help|assist|support/i.test(message)) {
-      return "I'd be happy to help with that.";
-    }
-    if (/what.*doing|plans/i.test(message)) {
-      const plans = this.getCurrentPlans();
-      if (plans.length > 0) {
-        return `I'm planning to ${plans[0].content}`;
-      }
-    }
-    
-    return "I understand. Let me think about that.";
-  }
-
-  /**
-   * Get agent summary for prompting
-   * @returns {string} Summary string
-   */
-  getSummary() {
-    return `${this.name}${this.age ? ` (age ${this.age})` : ''}. ${this.summary}. Traits: ${this.traits.join(', ')}`;
-  }
-
-  /**
-   * Get statistics
-   */
-  getStats() {
-    return {
-      name: this.name,
-      observations: this.observationCount,
-      plans: this.planCount,
-      memoryStats: this.memoryStream.getStats()
-    };
-  }
-}
-
-// Create default plan generator for backwards compatibility
-GenerativeAgent.prototype.planGenerator = new PlanGenerator();
-
-/**
- * Demo function demonstrating Generative Agents architecture
- */
-function demo() {
-  console.log('='.repeat(60));
-  console.log('Generative Agents Demo - Memory Stream Architecture');
-  console.log('='.repeat(60));
-  
-  // Create agent
-  const eddy = new GenerativeAgent({
-    name: 'Eddy Lin',
-    age: 19,
-    traits: ['friendly', 'outgoing', 'hospitable'],
-    config: {
-      memory: {
-        maxMemories: 100,
-        retrieval: { maxResults: 5 }
-      }
-    }
-  });
-  
-  // Set core description
-  eddy.setCoreDescription(
-    'Eddy Lin is a student at Oak Hill College studying music theory and composition. ' +
-    'He loves to explore different musical styles and is always looking for ways to expand his knowledge.',
-    ['friendly', 'outgoing', 'hospitable']
-  );
-  
-  console.log('\n--- Memory Stream: Adding Observations ---');
-  
-  // Add observations (simulating environment perception)
-  const observations = [
-    { content: 'Eddy Lin is writing a research paper on gentrification', location: 'library' },
-    { content: 'Eddy Lin enjoys reading a book on urban development', location: 'library' },
-    { content: 'Eddy Lin is conversing with Ayesha Khan about exercising', location: 'gym' },
-    { content: 'Eddy Lin is setting up his music studio at home', location: 'home' },
-    { content: 'Eddy Lin is meeting with his music professor about composition project', location: 'campus' },
-  ];
-  
-  observations.forEach(obs => {
-    eddy.observe(obs.content, { location: obs.location });
-    console.log(`  + Observation: ${obs.content.substring(0, 50)}...`);
-  });
-  
-  console.log('\n--- Memory Retrieval: Query "research and passion" ---');
-  
-  const relevant = eddy.remember('research and passion');
-  relevant.forEach(r => {
-    console.log(`  [score: ${r.score.toFixed(3)}] ${r.memory.content.substring(0, 60)}...`);
-    console.log(`      breakdown: recency=${r.breakdown.recency.toFixed(2)}, importance=${r.breakdown.importance.toFixed(2)}, relevance=${r.breakdown.relevance.toFixed(2)}`);
-  });
-  
-  console.log('\n--- Reflection Generation ---');
-  
-  // Force reflection generation for demo
-  const reflection = eddy.memoryStream.maybeGenerateReflection();
-  if (reflection) {
-    console.log(`  Generated Reflection: ${reflection.content}`);
-    console.log(`  Insights: ${reflection.insights.join(', ')}`);
-  } else {
-    console.log('  (Reflection threshold not met yet)');
-  }
-  
-  console.log('\n--- Planning: Create Day Plan ---');
-  
-  const plans = eddy.planDay('2024-02-14', 'Tuesday: classes, library study, dinner with friends');
-  plans.forEach(p => {
-    console.log(`  Plan: ${p.content}`);
-    console.log(`    Location: ${p.location}, Duration: ${p.duration}min`);
-    if (p.subTasks.length > 0) {
-      console.log(`    Sub-tasks: ${p.subTasks.join(', ')}`);
-    }
-  });
-  
-  console.log('\n--- Social Interaction ---');
-  
-  const edison = new GenerativeAgent({ name: 'Isabella', traits: ['warm', 'organized'] });
-  eddy.converse('Would you like to come to a Valentine\'s Day party?', edison).then(response => {
-    console.log(`  Eddy's response: "${response}"`);
-    
-    console.log('\n--- Memory Statistics ---');
-    const stats = eddy.getStats();
-    console.log(`  Total memories: ${stats.memoryStats.total}`);
-    console.log(`  By type:`, stats.memoryStats.byType);
-    
-    console.log('\n--- Agent Statistics ---');
-    console.log(`  Observations: ${stats.observations}`);
-    console.log(`  Plans created: ${stats.plans}`);
-    
-    console.log('\n' + '='.repeat(60));
-    console.log('Demo complete!');
-    console.log('='.repeat(60));
-  });
-}
-
-// Export for HeartFlow integration
-module.exports = {
-  GenerativeAgent,
-  MemoryStream,
-  MemoryRetrieval,
-  ReflectionGenerator,
-  PlanGenerator,
-  MemoryObject,
-  Observation,
-  Reflection,
-  Plan,
-  demo
-};