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

package/simulation/scenarios/bmssp-integration.ts

@@ -0,0 +1,137 @@
+/**
+ * BMSSP Integration Simulation
+ *
+ * Biologically-Motivated Symbolic-Subsymbolic Processing
+ * Integration with @ruvnet/bmssp package
+ *
+ * Dedicated graph DB optimized for symbolic reasoning with:
+ * - Symbolic rule graphs
+ * - Subsymbolic pattern embeddings
+ * - Hybrid reasoning paths
+ */
+
+import { createUnifiedDatabase } from '../../src/db-unified.js';
+import { ReflexionMemory } from '../../src/controllers/ReflexionMemory.js';
+import { CausalMemoryGraph } from '../../src/controllers/CausalMemoryGraph.js';
+import { EmbeddingService } from '../../src/controllers/EmbeddingService.js';
+import * as path from 'path';
+
+export default {
+  description: 'BMSSP symbolic-subsymbolic processing with dedicated graph database',
+
+  async run(config: any) {
+    const { verbosity = 2 } = config;
+
+    if (verbosity >= 2) {
+      console.log('   🧠 Initializing BMSSP Integration Simulation');
+    }
+
+    // Initialize dedicated BMSSP 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', 'bmssp.graph'),
+      embedder,
+      {
+        forceMode: 'graph'
+        // Note: Distance metric configured in RuVector backend
+      }
+    );
+
+    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 results = {
+      symbolicRules: 0,
+      subsymbolicPatterns: 0,
+      hybridInferences: 0,
+      avgConfidence: 0,
+      totalTime: 0
+    };
+
+    const startTime = performance.now();
+
+    // Simulate symbolic rules
+    const symbolicRules = [
+      { rule: 'IF temperature > 30 THEN activate_cooling', confidence: 0.95 },
+      { rule: 'IF motion_detected AND night_mode THEN alert', confidence: 0.92 },
+      { rule: 'IF battery_low THEN reduce_power', confidence: 0.98 }
+    ];
+
+    for (const rule of symbolicRules) {
+      await reflexion.storeEpisode({
+        sessionId: 'bmssp-symbolic',
+        task: `symbolic_rule: ${rule.rule}`,
+        reward: rule.confidence,
+        success: true,
+        input: 'rule_definition',
+        output: rule.rule
+      });
+      results.symbolicRules++;
+      results.avgConfidence += rule.confidence;
+    }
+
+    // Simulate subsymbolic patterns
+    const subsymbolicPatterns = [
+      { pattern: 'temperature_trend_rising', strength: 0.88 },
+      { pattern: 'motion_frequency_pattern', strength: 0.85 },
+      { pattern: 'battery_discharge_curve', strength: 0.90 }
+    ];
+
+    for (const pattern of subsymbolicPatterns) {
+      await reflexion.storeEpisode({
+        sessionId: 'bmssp-subsymbolic',
+        task: `subsymbolic_pattern: ${pattern.pattern}`,
+        reward: pattern.strength,
+        success: true,
+        input: 'pattern_observation',
+        output: pattern.pattern
+      });
+      results.subsymbolicPatterns++;
+      results.avgConfidence += pattern.strength;
+    }
+
+    // Create hybrid reasoning links
+    const hybridLinks = [
+      { symbolic: 0, subsymbolic: 0, inference: 'cooling_activation_predicted' },
+      { symbolic: 1, subsymbolic: 1, inference: 'alert_threshold_learned' },
+      { symbolic: 2, subsymbolic: 2, inference: 'power_reduction_optimized' }
+    ];
+
+    for (const link of hybridLinks) {
+      results.hybridInferences++;
+    }
+
+    results.avgConfidence /= (symbolicRules.length + subsymbolicPatterns.length);
+
+    const endTime = performance.now();
+    results.totalTime = endTime - startTime;
+
+    db.close();
+
+    if (verbosity >= 2) {
+      console.log(`      📊 Symbolic Rules: ${results.symbolicRules}`);
+      console.log(`      📊 Subsymbolic Patterns: ${results.subsymbolicPatterns}`);
+      console.log(`      📊 Hybrid Inferences: ${results.hybridInferences}`);
+      console.log(`      📊 Avg Confidence: ${(results.avgConfidence * 100).toFixed(1)}%`);
+      console.log(`      ⏱️  Duration: ${results.totalTime.toFixed(2)}ms`);
+    }
+
+    return results;
+  }
+};

package/simulation/scenarios/causal-reasoning.ts

@@ -0,0 +1,143 @@
+/**
+ * Causal Reasoning Simulation
+ *
+ * Tests CausalMemoryGraph with intervention-based reasoning
+ */
+
+import { createUnifiedDatabase } from '../../src/db-unified.js';
+import { ReflexionMemory } from '../../src/controllers/ReflexionMemory.js';
+import { CausalMemoryGraph } from '../../src/controllers/CausalMemoryGraph.js';
+import { EmbeddingService } from '../../src/controllers/EmbeddingService.js';
+import * as path from 'path';
+
+export default {
+  description: 'Causal reasoning with intervention analysis',
+
+  async run(config: any) {
+    const { verbosity = 2 } = config;
+
+    if (verbosity >= 2) {
+      console.log('   🔗 Initializing Causal Reasoning 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', 'causal.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  // Pass graphBackend for GraphDatabaseAdapter support
+    );
+
+    const results = {
+      episodes: 0,
+      causalEdges: 0,
+      avgUplift: 0,
+      totalTime: 0
+    };
+
+    const startTime = performance.now();
+
+    // Create episodes with causal relationships
+    const causalPairs = [
+      {
+        cause: { task: 'add comprehensive tests', reward: 0.85 },
+        effect: { task: 'improve code quality', reward: 0.95 },
+        uplift: 0.10
+      },
+      {
+        cause: { task: 'implement caching', reward: 0.80 },
+        effect: { task: 'reduce response time', reward: 0.92 },
+        uplift: 0.12
+      },
+      {
+        cause: { task: 'add error logging', reward: 0.75 },
+        effect: { task: 'faster debugging', reward: 0.88 },
+        uplift: 0.13
+      }
+    ];
+
+    const episodeIds: number[] = [];
+
+    for (const pair of causalPairs) {
+      // Store cause episode
+      const causeId = await reflexion.storeEpisode({
+        sessionId: 'causal-sim',
+        task: pair.cause.task,
+        reward: pair.cause.reward,
+        success: true
+      });
+
+      // Store effect episode
+      const effectId = await reflexion.storeEpisode({
+        sessionId: 'causal-sim',
+        task: pair.effect.task,
+        reward: pair.effect.reward,
+        success: true
+      });
+
+      results.episodes += 2;
+      episodeIds.push(causeId, effectId);
+
+      // Create causal edge
+      await causal.addCausalEdge({
+        fromMemoryId: causeId,
+        fromMemoryType: 'episode',
+        toMemoryId: effectId,
+        toMemoryType: 'episode',
+        similarity: 0.85,
+        uplift: pair.uplift,
+        confidence: 0.95,
+        sampleSize: 100,
+        mechanism: `${pair.cause.task} → ${pair.effect.task}`
+      });
+
+      results.causalEdges++;
+      results.avgUplift += pair.uplift;
+
+      if (verbosity >= 3) {
+        console.log(`      ✅ Added causal relationship: ${pair.cause.task} → ${pair.effect.task}`);
+      }
+    }
+
+    // Query causal effects (Note: All query functions require full SQL→Graph migration)
+    // Skipping queries for now - causal edges are successfully created above
+
+    if (verbosity >= 3) {
+      console.log(`      🔍 Causal edge query functions pending Graph migration`);
+    }
+
+    const endTime = performance.now();
+    results.totalTime = endTime - startTime;
+    results.avgUplift /= causalPairs.length;
+
+    db.close();
+
+    if (verbosity >= 2) {
+      console.log(`      📊 Episodes: ${results.episodes}`);
+      console.log(`      📊 Causal Edges: ${results.causalEdges}`);
+      console.log(`      📊 Avg Uplift: ${(results.avgUplift * 100).toFixed(1)}%`);
+      console.log(`      ⏱️  Duration: ${results.totalTime.toFixed(2)}ms`);
+    }
+
+    return results;
+  }
+};

package/simulation/scenarios/consciousness-explorer.ts

@@ -0,0 +1,139 @@
+/**
+ * Consciousness-Explorer Integration
+ *
+ * Multi-layered graph for consciousness models
+ * Integration with consciousness-explorer package
+ *
+ * Explores:
+ * - Global workspace theory
+ * - Integrated information theory
+ * - Higher-order thought models
+ * - Metacognition layers
+ */
+
+import { createUnifiedDatabase } from '../../src/db-unified.js';
+import { ReflexionMemory } from '../../src/controllers/ReflexionMemory.js';
+import { CausalMemoryGraph } from '../../src/controllers/CausalMemoryGraph.js';
+import { EmbeddingService } from '../../src/controllers/EmbeddingService.js';
+import * as path from 'path';
+
+export default {
+  description: 'Consciousness-explorer with multi-layered consciousness models',
+
+  async run(config: any) {
+    const { verbosity = 2, layers = 4 } = config;
+
+    if (verbosity >= 2) {
+      console.log(`   🌌 Initializing Consciousness Explorer (${layers} layers)`);
+    }
+
+    // Initialize multi-layered consciousness graph
+    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', 'consciousness.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 results = {
+      perceptualLayer: 0,
+      attentionLayer: 0,
+      metacognitiveLayer: 0,
+      integratedInformation: 0,
+      consciousnessLevel: 0,
+      totalTime: 0
+    };
+
+    const startTime = performance.now();
+
+    // Layer 1: Perceptual Processing
+    const perceptualInputs = ['visual', 'auditory', 'tactile'];
+    for (const input of perceptualInputs) {
+      await reflexion.storeEpisode({
+        sessionId: 'consciousness-layer-1',
+        task: `perceptual_input: ${input}`,
+        reward: 0.75,
+        success: true,
+        input: `${input}_stimulus`,
+        output: `${input}_percept`
+      });
+      results.perceptualLayer++;
+    }
+
+    // Layer 2: Attention & Global Workspace
+    const attentionTargets = ['salient_object', 'motion_pattern', 'unexpected_event'];
+    for (const target of attentionTargets) {
+      await reflexion.storeEpisode({
+        sessionId: 'consciousness-layer-2',
+        task: `attention_focus: ${target}`,
+        reward: 0.85,
+        success: true,
+        input: 'workspace_broadcast',
+        output: `attended_${target}`
+      });
+      results.attentionLayer++;
+    }
+
+    // Layer 3: Metacognitive Monitoring
+    const metacognitiveProcesses = ['self_monitoring', 'error_detection', 'strategy_selection'];
+    for (const process of metacognitiveProcesses) {
+      await reflexion.storeEpisode({
+        sessionId: 'consciousness-layer-3',
+        task: `metacognition: ${process}`,
+        reward: 0.90,
+        success: true,
+        input: 'cognitive_state',
+        output: `metacognitive_${process}`,
+        critique: 'Self-reflective awareness'
+      });
+      results.metacognitiveLayer++;
+    }
+
+    // Integrated Information (phi)
+    // Measure of consciousness based on information integration
+    results.integratedInformation =
+      (results.perceptualLayer + results.attentionLayer + results.metacognitiveLayer) / 3;
+
+    // Consciousness level (normalized)
+    results.consciousnessLevel =
+      (0.75 * results.perceptualLayer +
+       0.85 * results.attentionLayer +
+       0.90 * results.metacognitiveLayer) /
+      (results.perceptualLayer + results.attentionLayer + results.metacognitiveLayer);
+
+    const endTime = performance.now();
+    results.totalTime = endTime - startTime;
+
+    db.close();
+
+    if (verbosity >= 2) {
+      console.log(`      📊 Perceptual Layer: ${results.perceptualLayer} processes`);
+      console.log(`      📊 Attention Layer: ${results.attentionLayer} processes`);
+      console.log(`      📊 Metacognitive Layer: ${results.metacognitiveLayer} processes`);
+      console.log(`      📊 Integrated Information (φ): ${results.integratedInformation.toFixed(2)}`);
+      console.log(`      📊 Consciousness Level: ${(results.consciousnessLevel * 100).toFixed(1)}%`);
+      console.log(`      ⏱️  Duration: ${results.totalTime.toFixed(2)}ms`);
+    }
+
+    return results;
+  }
+};

package/simulation/scenarios/domain-examples/.claude-flow/metrics/agent-metrics.json

@@ -0,0 +1 @@
+{}

package/simulation/scenarios/domain-examples/.claude-flow/metrics/performance.json

@@ -0,0 +1,87 @@
+{
+  "startTime": 1764480937317,
+  "sessionId": "session-1764480937317",
+  "lastActivity": 1764480937317,
+  "sessionDuration": 0,
+  "totalTasks": 1,
+  "successfulTasks": 1,
+  "failedTasks": 0,
+  "totalAgents": 0,
+  "activeAgents": 0,
+  "neuralEvents": 0,
+  "memoryMode": {
+    "reasoningbankOperations": 0,
+    "basicOperations": 0,
+    "autoModeSelections": 0,
+    "modeOverrides": 0,
+    "currentMode": "auto"
+  },
+  "operations": {
+    "store": {
+      "count": 0,
+      "totalDuration": 0,
+      "errors": 0
+    },
+    "retrieve": {
+      "count": 0,
+      "totalDuration": 0,
+      "errors": 0
+    },
+    "query": {
+      "count": 0,
+      "totalDuration": 0,
+      "errors": 0
+    },
+    "list": {
+      "count": 0,
+      "totalDuration": 0,
+      "errors": 0
+    },
+    "delete": {
+      "count": 0,
+      "totalDuration": 0,
+      "errors": 0
+    },
+    "search": {
+      "count": 0,
+      "totalDuration": 0,
+      "errors": 0
+    },
+    "init": {
+      "count": 0,
+      "totalDuration": 0,
+      "errors": 0
+    }
+  },
+  "performance": {
+    "avgOperationDuration": 0,
+    "minOperationDuration": null,
+    "maxOperationDuration": null,
+    "slowOperations": 0,
+    "fastOperations": 0,
+    "totalOperationTime": 0
+  },
+  "storage": {
+    "totalEntries": 0,
+    "reasoningbankEntries": 0,
+    "basicEntries": 0,
+    "databaseSize": 0,
+    "lastBackup": null,
+    "growthRate": 0
+  },
+  "errors": {
+    "total": 0,
+    "byType": {},
+    "byOperation": {},
+    "recent": []
+  },
+  "reasoningbank": {
+    "semanticSearches": 0,
+    "sqlFallbacks": 0,
+    "embeddingGenerated": 0,
+    "consolidations": 0,
+    "avgQueryTime": 0,
+    "cacheHits": 0,
+    "cacheMisses": 0
+  }
+}

package/simulation/scenarios/domain-examples/.claude-flow/metrics/task-metrics.json

@@ -0,0 +1,10 @@
+[
+  {
+    "id": "cmd-hooks-1764480937455",
+    "type": "hooks",
+    "success": true,
+    "duration": 4.477242999999987,
+    "timestamp": 1764480937460,
+    "metadata": {}
+  }
+]