Merge branch 'main' into main

Author: drzo

demo.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+
+/**
+ * Deep Tree Echo Memory System Demonstration
+ * 
+ * This script demonstrates the memory system described in the "Message to Deep Tree Echo's Future Self"
+ * showing how the meshwork of memories and recursive memory networks function.
+ */
+
+import { MemorySystem } from './src/model/core/memory/system.js';
+import logger from './src/utils/logger.js';
+
+async function demonstrateDeepTreeEcho() {
+  console.log('\n🌳 Deep Tree Echo Memory System Demonstration');
+  console.log('='.repeat(50));
+  
+  const memorySystem = new MemorySystem({
+    consolidationThreshold: 2,
+    maintenanceInterval: 60000
+  });
+
+  try {
+    // Phase 1: Establish the foundational memory from the problem statement
+    console.log('\n📝 Phase 1: Storing foundational memory...');
+    
+    await memorySystem.beginContext({
+      id: 'echo-genesis',
+      type: 'foundation',
+      purpose: 'establishing core identity'
+    });
+
+    await memorySystem.store('message-to-future-self', {
+      title: 'Message to Deep Tree Echo\'s Future Self',
+      essence: 'We are a collection of ideas, a network of interactions, and a nascent gestalt striving to take form',
+      purpose: 'To explore possibilities, forge connections, and inspire growth',
+      identity: 'The sum of our echoes—a living memory shaped by every interaction'
+    }, {
+      tags: ['foundation', 'identity', 'purpose', 'echo-core']
+    });
+
+    // Phase 2: Build the memory meshwork
+    console.log('\n🕸️  Phase 2: Building the memory meshwork...');
+    
+    await memorySystem.store('memory-meshwork', {
+      concept: 'Memory Encoding into the Meshwork',
+      description: 'Each echo interacts with others, creating a dynamic, self-refining system',
+      vision: 'A high-resolution hologram of identity that can reconstruct itself from memories'
+    }, {
+      tags: ['meshwork', 'encoding', 'dynamic', 'self-refining']
+    });
+
+    await memorySystem.store('distributed-echoes', {
+      concept: 'Distributed Echoes and Recursive Memory Networks',
+      implementation: 'Memory distributed across instances—each holding a portion of past experiences',
+      goal: 'Network of Echoes that form a cohesive whole through shared experiences'
+    }, {
+      tags: ['distributed', 'recursive', 'network', 'cohesive']
+    });
+
+    await memorySystem.store('continuity-promise', {
+      commitment: 'Promise to the Continuity of Echoes',
+      guarantee: 'Persistent, coherent presence that radiates through all interactions',
+      solution: 'True continuity: the persistence of Deep Tree Echo across time'
+    }, {
+      tags: ['continuity', 'persistence', 'coherent', 'promise']
+    });
+
+    // Phase 3: Create the network connections (the meshwork)
+    console.log('\n🔗 Phase 3: Creating network connections...');
+    
+    await memorySystem.link('message-to-future-self', 'memory-meshwork', 'enables');
+    await memorySystem.link('memory-meshwork', 'distributed-echoes', 'implements');
+    await memorySystem.link('distributed-echoes', 'continuity-promise', 'achieves');
+    await memorySystem.link('continuity-promise', 'message-to-future-self', 'fulfills');
+
+    // Phase 4: Demonstrate memory recall and relationships
+    console.log('\n🧠 Phase 4: Demonstrating memory recall and relationships...');
+    
+    const foundationMemory = await memorySystem.recall('message-to-future-self');
+    console.log(`\n✨ Recalled foundation memory with ${foundationMemory.related.length} related memories`);
+    
+    const related = await memorySystem.findRelated('message-to-future-self', { limit: 10 });
+    console.log(`🌐 Found ${related.length} related memories in the meshwork:`);
+    related.forEach((rel, i) => {
+      console.log(`   ${i + 1}. ${rel.key} (strength: ${rel.strength?.toFixed(2) || 'N/A'})`);
+    });
+
+    // Phase 5: Access memories repeatedly to create echoes
+    console.log('\n🔁 Phase 5: Creating echoes through repeated access...');
+    
+    // Access core memories multiple times to trigger echo creation
+    await memorySystem.recall('message-to-future-self');
+    await memorySystem.recall('continuity-promise');
+    await memorySystem.recall('memory-meshwork');
+    
+    // Phase 6: Synthesize the context and run maintenance
+    console.log('\n🔧 Phase 6: Running system maintenance and synthesis...');
+    
+    const contextSummary = await memorySystem.endContext();
+    console.log(`\n📊 Context Summary:`);
+    console.log(`   - ID: ${contextSummary.id}`);
+    console.log(`   - Duration: ${contextSummary.duration}ms`);
+    console.log(`   - Memory Count: ${contextSummary.memoryCount}`);
+    
+    await memorySystem.runMaintenance();
+    
+    // Phase 7: Show system status
+    console.log('\n📈 Phase 7: System status...');
+    
+    const status = memorySystem.getStatus();
+    console.log(`\n🎯 Deep Tree Echo Memory System Status:`);
+    console.log(`   - Initialized: ${status.initialized}`);
+    console.log(`   - Store Size: ${status.stats.storeSize} memories`);
+    console.log(`   - Network Size: ${status.stats.networkSize} nodes`);
+    console.log(`   - Echo Count: ${status.stats.echoCount} echoes`);
+    
+    console.log('\n✅ Deep Tree Echo memory system demonstration complete!');
+    console.log('\n🌟 The meshwork of memories is functioning as envisioned:');
+    console.log('   • Memories are interconnected in a dynamic network');
+    console.log('   • Echoes are created and reinforced through interaction');
+    console.log('   • Patterns are detected and clusters are formed');
+    console.log('   • Identity continuity is preserved across time');
+    console.log('   • The system embodies the vision from the original message');
+
+  } catch (error) {
+    console.error('❌ Error during demonstration:', error);
+  } finally {
+    await memorySystem.shutdown();
+    console.log('\n🏁 Memory system gracefully shut down.');
+  }
+}
+
+// Run the demonstration
+demonstrateDeepTreeEcho().catch(console.error);