agentdb 2.0.0-alpha.1 → 2.0.0-alpha.2

package/simulation/scenarios/research-swarm.ts

@@ -0,0 +1,187 @@
+/**
+ * Research-Swarm Integration
+ *
+ * Distributed research graph DB
+ * Integration with research-swarm package
+ *
+ * Features:
+ * - Collaborative research agents
+ * - Literature review aggregation
+ * - Hypothesis generation and testing
+ * - Knowledge synthesis
+ */
+
+import { createUnifiedDatabase } from '../../src/db-unified.js';
+import { ReflexionMemory } from '../../src/controllers/ReflexionMemory.js';
+import { CausalMemoryGraph } from '../../src/controllers/CausalMemoryGraph.js';
+import { SkillLibrary } from '../../src/controllers/SkillLibrary.js';
+import { EmbeddingService } from '../../src/controllers/EmbeddingService.js';
+import * as path from 'path';
+
+export default {
+  description: 'Research-swarm distributed research with collaborative agents',
+
+  async run(config: any) {
+    const { verbosity = 2, researchers = 5 } = config;
+
+    if (verbosity >= 2) {
+      console.log(`   🔬 Initializing Research-Swarm (${researchers} researchers)`);
+    }
+
+    // Initialize distributed research graph database
+    const embedder = new EmbeddingService({
+      model: 'Xenova/all-MiniLM-L6-v2',
+      dimension: 384,
+      provider: 'transformers'
+    });
+    await embedder.initialize();
+
+    const db = await createUnifiedDatabase(
+      path.join(process.cwd(), 'simulation', 'data', 'advanced', 'research-swarm.graph'),
+      embedder,
+      { forceMode: 'graph' }
+    );
+
+    const reflexion = new ReflexionMemory(
+      db.getGraphDatabase() as any,
+      embedder,
+      undefined,
+      undefined,
+      db.getGraphDatabase() as any
+    );
+
+    const causal = new CausalMemoryGraph(
+      db.getGraphDatabase() as any,
+      db.getGraphDatabase() as any
+    );
+
+    const skills = new SkillLibrary(
+      db.getGraphDatabase() as any,
+      embedder,
+      undefined,
+      db.getGraphDatabase() as any
+    );
+
+    const results = {
+      papers: 0,
+      hypotheses: 0,
+      experiments: 0,
+      synthesizedKnowledge: 0,
+      totalTime: 0
+    };
+
+    const startTime = performance.now();
+
+    // Literature Review (each researcher finds papers)
+    const papers = [
+      'neural_architecture_search_techniques',
+      'few_shot_learning_methods',
+      'transfer_learning_strategies',
+      'meta_learning_algorithms',
+      'continual_learning_approaches'
+    ];
+
+    const paperIds: number[] = [];
+    for (let i = 0; i < papers.length; i++) {
+      const id = await reflexion.storeEpisode({
+        sessionId: `researcher-${i % researchers}`,
+        task: `literature_review: ${papers[i]}`,
+        reward: 0.80 + Math.random() * 0.15,  // Quality varies
+        success: true,
+        input: 'academic_search',
+        output: `paper_summary_${papers[i]}`
+      });
+      paperIds.push(id);
+      results.papers++;
+    }
+
+    // Hypothesis Generation (synthesizing from papers)
+    const hypotheses = [
+      'combining_meta_learning_with_architecture_search_improves_few_shot',
+      'transfer_learning_enables_faster_continual_learning',
+      'meta_architecture_search_reduces_hyperparameter_tuning'
+    ];
+
+    const hypothesisIds: number[] = [];
+    for (const hypothesis of hypotheses) {
+      const id = await reflexion.storeEpisode({
+        sessionId: 'research-synthesis',
+        task: `hypothesis: ${hypothesis}`,
+        reward: 0.70,  // Untested hypothesis
+        success: false,  // Not yet validated
+        input: 'literature_synthesis',
+        output: `hypothesis_${hypothesis}`,
+        critique: 'Requires experimental validation'
+      });
+      hypothesisIds.push(id);
+      results.hypotheses++;
+
+      // Link hypothesis to supporting papers
+      for (let i = 0; i < Math.min(2, paperIds.length); i++) {
+        await causal.addCausalEdge({
+          fromMemoryId: paperIds[i],
+          fromMemoryType: 'episode',
+          toMemoryId: id,
+          toMemoryType: 'episode',
+          similarity: 0.85,
+          uplift: 0.20,
+          confidence: 0.80,
+          sampleSize: 100,
+          mechanism: 'paper_supports_hypothesis'
+        });
+      }
+    }
+
+    // Experimental Validation
+    const experiments = [
+      { hypothesis: 0, result: 'confirmed', confidence: 0.92 },
+      { hypothesis: 1, result: 'confirmed', confidence: 0.88 },
+      { hypothesis: 2, result: 'partially_confirmed', confidence: 0.75 }
+    ];
+
+    for (const exp of experiments) {
+      await reflexion.storeEpisode({
+        sessionId: 'experimental-validation',
+        task: `experiment_validate_hypothesis_${exp.hypothesis}`,
+        reward: exp.confidence,
+        success: exp.result === 'confirmed',
+        input: `hypothesis_${exp.hypothesis}`,
+        output: exp.result,
+        critique: `Confidence: ${exp.confidence}`
+      });
+      results.experiments++;
+    }
+
+    // Knowledge Synthesis (create reusable research methods)
+    const researchMethods = [
+      'meta_architecture_search_protocol',
+      'few_shot_evaluation_framework',
+      'transfer_learning_pipeline'
+    ];
+
+    for (const method of researchMethods) {
+      await skills.createSkill({
+        name: method,
+        description: 'Research methodology',
+        code: `// Reusable research method: ${method}`,
+        successRate: 0.85
+      });
+      results.synthesizedKnowledge++;
+    }
+
+    const endTime = performance.now();
+    results.totalTime = endTime - startTime;
+
+    db.close();
+
+    if (verbosity >= 2) {
+      console.log(`      📊 Papers Reviewed: ${results.papers}`);
+      console.log(`      📊 Hypotheses Generated: ${results.hypotheses}`);
+      console.log(`      📊 Experiments Conducted: ${results.experiments}`);
+      console.log(`      📊 Synthesized Knowledge: ${results.synthesizedKnowledge} methods`);
+      console.log(`      ⏱️  Duration: ${results.totalTime.toFixed(2)}ms`);
+    }
+
+    return results;
+  }
+};

package/simulation/scenarios/skill-evolution.ts

@@ -0,0 +1,135 @@
+/**
+ * Skill Evolution Simulation
+ *
+ * Tests SkillLibrary with skill creation, evolution, and composition
+ */
+
+import { createUnifiedDatabase } from '../../src/db-unified.js';
+import { SkillLibrary } from '../../src/controllers/SkillLibrary.js';
+import { EmbeddingService } from '../../src/controllers/EmbeddingService.js';
+import * as path from 'path';
+
+export default {
+  description: 'Skill library evolution with composition and refinement',
+
+  async run(config: any) {
+    const { verbosity = 2 } = config;
+
+    if (verbosity >= 2) {
+      console.log('   🛠️  Initializing Skill Evolution Simulation');
+    }
+
+    // Initialize AgentDB
+    const embedder = new EmbeddingService({
+      model: 'Xenova/all-MiniLM-L6-v2',
+      dimension: 384,
+      provider: 'transformers'
+    });
+    await embedder.initialize();
+
+    const db = await createUnifiedDatabase(
+      path.join(process.cwd(), 'simulation', 'data', 'skills.graph'),
+      embedder,
+      { forceMode: 'graph' }
+    );
+
+    const skills = new SkillLibrary(
+      db.getGraphDatabase() as any,
+      embedder,
+      undefined,  // vectorBackend
+      db.getGraphDatabase() as any  // graphBackend
+    );
+
+    // Simulate skill creation and evolution
+    const skillTemplates = [
+      {
+        name: 'jwt_authentication',
+        description: 'Generate and verify JWT tokens',
+        code: 'function generateJWT(payload) { return jwt.sign(payload, SECRET); }',
+        successRate: 0.95
+      },
+      {
+        name: 'database_query_optimizer',
+        description: 'Optimize database queries with batch loading',
+        code: 'function batchLoad(ids) { return DataLoader.load(ids); }',
+        successRate: 0.88
+      },
+      {
+        name: 'error_handler',
+        description: 'Comprehensive error handling middleware',
+        code: 'function errorHandler(err, req, res, next) { /* ... */ }',
+        successRate: 0.92
+      },
+      {
+        name: 'cache_manager',
+        description: 'Redis-based caching with TTL',
+        code: 'function cacheSet(key, val, ttl) { return redis.setex(key, ttl, val); }',
+        successRate: 0.90
+      },
+      {
+        name: 'validation_schema',
+        description: 'Request validation with Zod schemas',
+        code: 'const schema = z.object({ email: z.string().email() });',
+        successRate: 0.93
+      }
+    ];
+
+    const results = {
+      created: 0,
+      searched: 0,
+      avgSuccessRate: 0,
+      totalTime: 0
+    };
+
+    const startTime = performance.now();
+
+    // Create skills
+    for (const template of skillTemplates) {
+      await skills.createSkill(template);
+      results.created++;
+      results.avgSuccessRate += template.successRate;
+
+      if (verbosity >= 3) {
+        console.log(`      ✅ Created skill: ${template.name}`);
+      }
+    }
+
+    // Search for skills
+    const searchQueries = [
+      'authentication',
+      'database optimization',
+      'error handling',
+      'caching',
+      'validation'
+    ];
+
+    for (const query of searchQueries) {
+      const found = await skills.searchSkills({
+        query,
+        k: 3,
+        minSuccessRate: 0.8
+      });
+
+      results.searched += found.length;
+
+      if (verbosity >= 3) {
+        console.log(`      🔍 Found ${found.length} skills for: ${query}`);
+      }
+    }
+
+    const endTime = performance.now();
+    results.totalTime = endTime - startTime;
+    results.avgSuccessRate /= skillTemplates.length;
+
+    db.close();
+
+    if (verbosity >= 2) {
+      console.log(`      📊 Created: ${results.created} skills`);
+      console.log(`      📊 Searched: ${results.searched} results`);
+      console.log(`      📊 Avg Success Rate: ${(results.avgSuccessRate * 100).toFixed(1)}%`);
+      console.log(`      ⏱️  Duration: ${results.totalTime.toFixed(2)}ms`);
+    }
+
+    return results;
+  }
+};

package/simulation/scenarios/stock-market-emergence.ts

@@ -0,0 +1,323 @@
+/**
+ * Stock Market Emergence Simulation
+ *
+ * Models complex market dynamics with:
+ * - Multi-agent trading strategies (momentum, value, contrarian, HFT)
+ * - Market microstructure (order book, bid-ask spread)
+ * - Herding behavior and cascades
+ * - Flash crash detection and circuit breakers
+ * - Sentiment propagation through agent network
+ * - Adaptive learning from P&L
+ *
+ * Tests AgentDB's ability to model emergent collective behavior
+ * and adaptive learning in high-frequency financial systems.
+ */
+
+import { createUnifiedDatabase } from '../../src/db-unified.js';
+import { ReflexionMemory } from '../../src/controllers/ReflexionMemory.js';
+import { EmbeddingService } from '../../src/controllers/EmbeddingService.js';
+import { PerformanceOptimizer, executeParallel } from '../utils/PerformanceOptimizer.js';
+import * as path from 'path';
+
+interface Trader {
+  id: string;
+  strategy: 'momentum' | 'value' | 'contrarian' | 'HFT' | 'index';
+  cash: number;
+  shares: number;
+  profitLoss: number;
+  tradeHistory: Trade[];
+  sentiment: number; // -1 (bearish) to +1 (bullish)
+}
+
+interface Trade {
+  timestamp: number;
+  price: number;
+  quantity: number;
+  type: 'buy' | 'sell';
+  traderId: string;
+}
+
+interface MarketState {
+  tick: number;
+  price: number;
+  volume: number;
+  volatility: number;
+  bidAskSpread: number;
+  sentimentIndex: number;
+}
+
+export default {
+  description: 'Stock market with multi-strategy traders, herding, flash crashes, and adaptive learning',
+
+  async run(config: any) {
+    const { verbosity = 2, ticks = 100, traderCount = 100 } = config;
+
+    if (verbosity >= 2) {
+      console.log(`   📈 Initializing Stock Market: ${traderCount} traders, ${ticks} ticks`);
+    }
+
+    // Initialize performance optimizer
+    const optimizer = new PerformanceOptimizer({ batchSize: 100 });
+
+    const embedder = new EmbeddingService({
+      model: 'Xenova/all-MiniLM-L6-v2',
+      dimension: 384,
+      provider: 'transformers'
+    });
+    await embedder.initialize();
+
+    const db = await createUnifiedDatabase(
+      path.join(process.cwd(), 'simulation', 'data', 'stock-market.graph'),
+      embedder,
+      { forceMode: 'graph' }
+    );
+
+    const reflexion = new ReflexionMemory(
+      db.getGraphDatabase() as any,
+      embedder,
+      undefined,
+      undefined,
+      db.getGraphDatabase() as any
+    );
+
+    const results = {
+      ticks: 0,
+      totalTrades: 0,
+      flashCrashes: 0,
+      herdingEvents: 0,
+      priceRange: { min: 100, max: 100 },
+      avgVolatility: 0,
+      strategyPerformance: new Map<string, number>(),
+      adaptiveLearningEvents: 0,
+      totalTime: 0
+    };
+
+    const startTime = performance.now();
+
+    // Initialize traders with different strategies
+    const strategyDistribution = ['momentum', 'value', 'contrarian', 'HFT', 'index'];
+    const traders: Trader[] = Array.from({ length: traderCount }, (_, i) => ({
+      id: `trader-${i}`,
+      strategy: strategyDistribution[i % strategyDistribution.length] as any,
+      cash: 10000,
+      shares: Math.floor(Math.random() * 50),
+      profitLoss: 0,
+      tradeHistory: [],
+      sentiment: Math.random() * 2 - 1
+    }));
+
+    let currentPrice = 100;
+    const priceHistory: number[] = [100];
+    const trades: Trade[] = [];
+    let circuitBreakerActive = false;
+
+    // Market simulation ticks
+    for (let tick = 0; tick < ticks; tick++) {
+      const tickTrades: Trade[] = [];
+
+      // Each trader decides to trade based on strategy
+      for (const trader of traders) {
+        if (circuitBreakerActive && Math.random() > 0.1) continue; // 90% stop trading during circuit breaker
+
+        let shouldBuy = false;
+        let shouldSell = false;
+
+        switch (trader.strategy) {
+          case 'momentum':
+            // Buy if price rising, sell if falling
+            if (priceHistory.length >= 5) {
+              const recentChange = (priceHistory[priceHistory.length - 1] - priceHistory[priceHistory.length - 5]) / priceHistory[priceHistory.length - 5];
+              shouldBuy = recentChange > 0.01;
+              shouldSell = recentChange < -0.01;
+            }
+            break;
+
+          case 'value':
+            // Buy if price below 100, sell if above
+            shouldBuy = currentPrice < 95;
+            shouldSell = currentPrice > 105;
+            break;
+
+          case 'contrarian':
+            // Buy when others sell, sell when others buy
+            if (priceHistory.length >= 3) {
+              const recentChange = currentPrice - priceHistory[priceHistory.length - 2];
+              shouldBuy = recentChange < -2;
+              shouldSell = recentChange > 2;
+            }
+            break;
+
+          case 'HFT':
+            // High frequency: trade on tiny movements
+            if (priceHistory.length >= 2) {
+              const microChange = currentPrice - priceHistory[priceHistory.length - 1];
+              shouldBuy = microChange < -0.1 && Math.random() > 0.7;
+              shouldSell = microChange > 0.1 && Math.random() > 0.7;
+            }
+            break;
+
+          case 'index':
+            // Passive: rarely trade
+            shouldBuy = Math.random() > 0.98;
+            shouldSell = Math.random() > 0.98;
+            break;
+        }
+
+        // Execute trades
+        if (shouldBuy && trader.cash > currentPrice) {
+          const quantity = Math.min(Math.floor(trader.cash / currentPrice), 10);
+          if (quantity > 0) {
+            const trade: Trade = {
+              timestamp: tick,
+              price: currentPrice,
+              quantity,
+              type: 'buy',
+              traderId: trader.id
+            };
+            tickTrades.push(trade);
+            trader.cash -= currentPrice * quantity;
+            trader.shares += quantity;
+            trader.tradeHistory.push(trade);
+          }
+        } else if (shouldSell && trader.shares > 0) {
+          const quantity = Math.min(trader.shares, 10);
+          const trade: Trade = {
+            timestamp: tick,
+            price: currentPrice,
+            quantity,
+            type: 'sell',
+            traderId: trader.id
+          };
+          tickTrades.push(trade);
+          trader.cash += currentPrice * quantity;
+          trader.shares -= quantity;
+          trader.tradeHistory.push(trade);
+        }
+      }
+
+      // Update price based on supply/demand
+      const buyOrders = tickTrades.filter(t => t.type === 'buy').length;
+      const sellOrders = tickTrades.filter(t => t.type === 'sell').length;
+      const orderImbalance = (buyOrders - sellOrders) / (buyOrders + sellOrders + 1);
+
+      // Price impact
+      const priceChange = orderImbalance * 2 + (Math.random() - 0.5) * 0.5;
+      currentPrice = Math.max(1, currentPrice + priceChange);
+
+      priceHistory.push(currentPrice);
+      trades.push(...tickTrades);
+      results.totalTrades += tickTrades.length;
+
+      // Update price range
+      results.priceRange.min = Math.min(results.priceRange.min, currentPrice);
+      results.priceRange.max = Math.max(results.priceRange.max, currentPrice);
+
+      // Calculate volatility (std dev of last 10 prices)
+      if (priceHistory.length >= 10) {
+        const recent = priceHistory.slice(-10);
+        const mean = recent.reduce((a, b) => a + b) / recent.length;
+        const variance = recent.reduce((sum, price) => sum + Math.pow(price - mean, 2), 0) / recent.length;
+        const volatility = Math.sqrt(variance);
+        results.avgVolatility += volatility;
+
+        // Flash crash detection (>10% drop in 10 ticks)
+        if ((recent[0] - recent[recent.length - 1]) / recent[0] > 0.10) {
+          results.flashCrashes++;
+          circuitBreakerActive = true;
+          if (verbosity >= 3) {
+            console.log(`      ⚠️  Flash crash detected at tick ${tick}! Circuit breaker activated.`);
+          }
+        }
+      }
+
+      // Deactivate circuit breaker after 5 ticks
+      if (circuitBreakerActive && tick % 5 === 0) {
+        circuitBreakerActive = false;
+      }
+
+      // Detect herding (>60% traders moving same direction)
+      const herdingThreshold = 0.6;
+      if (buyOrders / (buyOrders + sellOrders + 1) > herdingThreshold ||
+          sellOrders / (buyOrders + sellOrders + 1) > herdingThreshold) {
+        results.herdingEvents++;
+      }
+
+      // Update trader sentiment based on profit/loss
+      for (const trader of traders) {
+        const portfolioValue = trader.cash + trader.shares * currentPrice;
+        const initialValue = 10000 + 50 * 100; // initial cash + shares * starting price
+        trader.profitLoss = portfolioValue - initialValue;
+        trader.sentiment = Math.tanh(trader.profitLoss / 1000); // -1 to +1
+      }
+
+      results.ticks++;
+
+      if (verbosity >= 3 && tick % 20 === 0) {
+        console.log(`      📊 Tick ${tick}: Price $${currentPrice.toFixed(2)}, Trades: ${tickTrades.length}, Circuit Breaker: ${circuitBreakerActive}`);
+      }
+    }
+
+    // Adaptive learning: Store top 10 most profitable traders' strategies - OPTIMIZED
+    const sortedByProfit = traders.sort((a, b) => b.profitLoss - a.profitLoss);
+
+    // Queue all episode storage operations for parallel execution
+    for (let i = 0; i < Math.min(10, sortedByProfit.length); i++) {
+      const trader = sortedByProfit[i];
+
+      optimizer.queueOperation(async () => {
+        await reflexion.storeEpisode({
+          sessionId: 'market-simulation',
+          task: `trade with ${trader.strategy} strategy`,
+          input: `Initial capital: $10000, Strategy: ${trader.strategy}`,
+          output: `Final P&L: $${trader.profitLoss.toFixed(2)}, Trades: ${trader.tradeHistory.length}`,
+          reward: Math.tanh(trader.profitLoss / 5000), // -1 to +1
+          success: trader.profitLoss > 0,
+          critique: trader.profitLoss > 0 ? 'Profitable strategy' : 'Losses incurred',
+          metadata: {
+            strategy: trader.strategy,
+            finalPortfolio: trader.cash + trader.shares * currentPrice,
+            totalTrades: trader.tradeHistory.length
+          }
+        });
+        results.adaptiveLearningEvents++;
+      });
+    }
+
+    // Execute batch operation
+    await optimizer.executeBatch();
+
+    // Calculate strategy performance
+    for (const strategy of strategyDistribution) {
+      const strategyTraders = traders.filter(t => t.strategy === strategy);
+      const avgPL = strategyTraders.reduce((sum, t) => sum + t.profitLoss, 0) / strategyTraders.length;
+      results.strategyPerformance.set(strategy, avgPL);
+    }
+
+    results.avgVolatility /= Math.max(1, ticks - 9);
+
+    const endTime = performance.now();
+    results.totalTime = endTime - startTime;
+
+    db.close();
+
+    // Get optimization metrics
+    const optimizerMetrics = optimizer.getMetrics();
+
+    if (verbosity >= 2) {
+      console.log(`      📊 Ticks: ${results.ticks}`);
+      console.log(`      📊 Total Trades: ${results.totalTrades}`);
+      console.log(`      📊 Flash Crashes: ${results.flashCrashes}`);
+      console.log(`      📊 Herding Events: ${results.herdingEvents}`);
+      console.log(`      📊 Price Range: $${results.priceRange.min.toFixed(2)} - $${results.priceRange.max.toFixed(2)}`);
+      console.log(`      📊 Avg Volatility: ${results.avgVolatility.toFixed(2)}`);
+      console.log(`      📊 Strategy Performance:`);
+      for (const [strategy, pl] of results.strategyPerformance.entries()) {
+        console.log(`         ${strategy}: ${pl > 0 ? '+' : ''}$${pl.toFixed(2)}`);
+      }
+      console.log(`      ⏱️  Duration: ${results.totalTime.toFixed(2)}ms`);
+      console.log(`      ⚡ Optimization: ${optimizerMetrics.batchOperations} batches, ${optimizerMetrics.avgLatency} avg`);
+    }
+
+    return results;
+  }
+};