@yun520-1/heartflow 0.15.2

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

@@ -0,0 +1,886 @@
+/**
+ * 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
+};