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

package/simulation/reports/voting-system-consensus-2025-11-30T00-11-37-199Z.json

@@ -0,0 +1,58 @@
+{
+  "scenario": "voting-system-consensus",
+  "startTime": 1764461496465,
+  "endTime": 1764461497198,
+  "duration": 733.129295,
+  "iterations": 2,
+  "agents": 5,
+  "success": 2,
+  "failures": 0,
+  "metrics": {
+    "opsPerSec": 2.728031758709083,
+    "avgLatency": 356.546208,
+    "memoryUsage": 24.356658935546875,
+    "errorRate": 0
+  },
+  "details": [
+    {
+      "iteration": 1,
+      "duration": 447.37019699999996,
+      "success": true,
+      "data": {
+        "rounds": 5,
+        "totalVotes": 250,
+        "coalitionsFormed": 5,
+        "consensusEvolution": [
+          0.58,
+          0.62,
+          0.54,
+          0.6,
+          0.6
+        ],
+        "strategicVotingDetected": 0,
+        "avgPreferenceShift": 0.020000000000000018,
+        "totalTime": 116.39697699999999
+      }
+    },
+    {
+      "iteration": 2,
+      "duration": 265.722219,
+      "success": true,
+      "data": {
+        "rounds": 5,
+        "totalVotes": 250,
+        "coalitionsFormed": 0,
+        "consensusEvolution": [
+          0.58,
+          0.52,
+          0.52,
+          0.52,
+          0.6
+        ],
+        "strategicVotingDetected": 0,
+        "avgPreferenceShift": 0.020000000000000018,
+        "totalTime": 130.73092900000006
+      }
+    }
+  ]
+}

package/simulation/reports/voting-system-consensus-2025-11-30T00-28-47-735Z.json

@@ -0,0 +1,58 @@
+{
+  "scenario": "voting-system-consensus",
+  "startTime": 1764462526691,
+  "endTime": 1764462527734,
+  "duration": 1043.194336,
+  "iterations": 2,
+  "agents": 5,
+  "success": 2,
+  "failures": 0,
+  "metrics": {
+    "opsPerSec": 1.917188323384455,
+    "avgLatency": 511.37594550000006,
+    "memoryUsage": 29.847320556640625,
+    "errorRate": 0
+  },
+  "details": [
+    {
+      "iteration": 1,
+      "duration": 693.1747210000001,
+      "success": true,
+      "data": {
+        "rounds": 5,
+        "totalVotes": 250,
+        "coalitionsFormed": 0,
+        "consensusEvolution": [
+          0.58,
+          0.58,
+          0.58,
+          0.6,
+          0.56
+        ],
+        "strategicVotingDetected": 0,
+        "avgPreferenceShift": -0.019999999999999907,
+        "totalTime": 258.90011100000004
+      }
+    },
+    {
+      "iteration": 2,
+      "duration": 329.57717,
+      "success": true,
+      "data": {
+        "rounds": 5,
+        "totalVotes": 250,
+        "coalitionsFormed": 0,
+        "consensusEvolution": [
+          0.52,
+          0.62,
+          0.56,
+          0.56,
+          0.52
+        ],
+        "strategicVotingDetected": 0,
+        "avgPreferenceShift": 0,
+        "totalTime": 213.92519600000003
+      }
+    }
+  ]
+}

package/simulation/runner.ts

@@ -0,0 +1,300 @@
+/**
+ * Simulation Runner
+ *
+ * Orchestrates multi-agent swarms to test AgentDB functionality
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { performance } from 'perf_hooks';
+
+interface SimulationOptions {
+  config: string;
+  verbosity: string;
+  iterations: string;
+  swarmSize: string;
+  model: string;
+  parallel: boolean;
+  output: string;
+  stream: boolean;
+  optimize: boolean;
+}
+
+interface SimulationResult {
+  scenario: string;
+  startTime: number;
+  endTime: number;
+  duration: number;
+  iterations: number;
+  agents: number;
+  success: number;
+  failures: number;
+  metrics: {
+    opsPerSec: number;
+    avgLatency: number;
+    memoryUsage: number;
+    errorRate: number;
+  };
+  details: any[];
+}
+
+export async function runSimulation(scenario: string, options: SimulationOptions): Promise<void> {
+  const verbosity = parseInt(options.verbosity);
+
+  if (verbosity >= 1) {
+    console.log('🚀 AgentDB Simulation System v2.0.0');
+    console.log('═'.repeat(70));
+    console.log(`Scenario: ${scenario}`);
+    console.log(`Config: ${options.config}`);
+    console.log(`Model: ${options.model}`);
+    console.log(`Swarm Size: ${options.swarmSize}`);
+    console.log(`Iterations: ${options.iterations}`);
+    console.log(`Parallel: ${options.parallel}`);
+    console.log(`Streaming: ${options.stream}`);
+    console.log(`Optimize: ${options.optimize}`);
+    console.log('═'.repeat(70));
+  }
+
+  // Load scenario
+  const scenarioPath = path.join(process.cwd(), 'simulation', 'scenarios', `${scenario}.ts`);
+  if (!fs.existsSync(scenarioPath)) {
+    console.error(`❌ Scenario not found: ${scenario}`);
+    console.error(`   Path: ${scenarioPath}`);
+    process.exit(1);
+  }
+
+  const startTime = performance.now();
+  const result: SimulationResult = {
+    scenario,
+    startTime: Date.now(),
+    endTime: 0,
+    duration: 0,
+    iterations: parseInt(options.iterations),
+    agents: parseInt(options.swarmSize),
+    success: 0,
+    failures: 0,
+    metrics: {
+      opsPerSec: 0,
+      avgLatency: 0,
+      memoryUsage: 0,
+      errorRate: 0
+    },
+    details: []
+  };
+
+  try {
+    // Import and run scenario
+    const scenarioModule = await import(scenarioPath);
+    const scenarioRunner = scenarioModule.default;
+
+    if (verbosity >= 2) {
+      console.log(`\n🎯 Running scenario: ${scenario}\n`);
+    }
+
+    // Initialize swarm
+    const swarmConfig = {
+      size: parseInt(options.swarmSize),
+      model: options.model,
+      parallel: options.parallel,
+      stream: options.stream,
+      optimize: options.optimize,
+      verbosity
+    };
+
+    // Run iterations
+    for (let i = 0; i < parseInt(options.iterations); i++) {
+      if (verbosity >= 2) {
+        console.log(`\n📍 Iteration ${i + 1}/${options.iterations}`);
+      }
+
+      const iterationStart = performance.now();
+
+      try {
+        const iterationResult = await scenarioRunner.run(swarmConfig);
+        const iterationEnd = performance.now();
+
+        result.success++;
+        result.details.push({
+          iteration: i + 1,
+          duration: iterationEnd - iterationStart,
+          success: true,
+          data: iterationResult
+        });
+
+        if (verbosity >= 3) {
+          console.log(`   ✅ Iteration ${i + 1} completed in ${(iterationEnd - iterationStart).toFixed(2)}ms`);
+          console.log(`   Result:`, JSON.stringify(iterationResult, null, 2));
+        } else if (verbosity >= 2) {
+          console.log(`   ✅ Completed in ${(iterationEnd - iterationStart).toFixed(2)}ms`);
+        }
+      } catch (error) {
+        const iterationEnd = performance.now();
+        result.failures++;
+        result.details.push({
+          iteration: i + 1,
+          duration: iterationEnd - iterationStart,
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+
+        if (verbosity >= 1) {
+          console.error(`   ❌ Iteration ${i + 1} failed:`, error);
+        }
+      }
+    }
+
+    const endTime = performance.now();
+    result.endTime = Date.now();
+    result.duration = endTime - startTime;
+
+    // Calculate metrics
+    const successfulIterations = result.details.filter(d => d.success);
+    const totalDuration = successfulIterations.reduce((sum, d) => sum + d.duration, 0);
+    result.metrics.avgLatency = totalDuration / successfulIterations.length;
+    result.metrics.opsPerSec = (result.success / (result.duration / 1000));
+    result.metrics.errorRate = result.failures / result.iterations;
+    result.metrics.memoryUsage = process.memoryUsage().heapUsed / 1024 / 1024; // MB
+
+    // Display results
+    if (verbosity >= 1) {
+      console.log('\n' + '═'.repeat(70));
+      console.log('📊 SIMULATION RESULTS');
+      console.log('═'.repeat(70));
+      console.log(`Total Duration: ${(result.duration / 1000).toFixed(2)}s`);
+      console.log(`Iterations: ${result.iterations}`);
+      console.log(`Success: ${result.success} (${((result.success / result.iterations) * 100).toFixed(1)}%)`);
+      console.log(`Failures: ${result.failures} (${((result.failures / result.iterations) * 100).toFixed(1)}%)`);
+      console.log(`\nMetrics:`);
+      console.log(`  Throughput: ${result.metrics.opsPerSec.toFixed(2)} ops/sec`);
+      console.log(`  Avg Latency: ${result.metrics.avgLatency.toFixed(2)}ms`);
+      console.log(`  Error Rate: ${(result.metrics.errorRate * 100).toFixed(2)}%`);
+      console.log(`  Memory Usage: ${result.metrics.memoryUsage.toFixed(2)} MB`);
+      console.log('═'.repeat(70));
+    }
+
+    // Save results
+    const outputDir = path.join(process.cwd(), options.output);
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const outputPath = path.join(outputDir, `${scenario}-${timestamp}.json`);
+    fs.writeFileSync(outputPath, JSON.stringify(result, null, 2));
+
+    if (verbosity >= 1) {
+      console.log(`\n💾 Results saved to: ${outputPath}\n`);
+    }
+
+  } catch (error) {
+    console.error('\n❌ Simulation failed:', error);
+    process.exit(1);
+  }
+}
+
+export async function listScenarios(): Promise<void> {
+  const scenariosDir = path.join(process.cwd(), 'simulation', 'scenarios');
+
+  if (!fs.existsSync(scenariosDir)) {
+    console.log('No scenarios found. Create scenarios in simulation/scenarios/');
+    return;
+  }
+
+  const files = fs.readdirSync(scenariosDir).filter(f => f.endsWith('.ts'));
+
+  console.log('\n📋 Available Scenarios:\n');
+
+  for (const file of files) {
+    const scenarioName = file.replace('.ts', '');
+    const scenarioPath = path.join(scenariosDir, file);
+
+    try {
+      const module = await import(scenarioPath);
+      const description = module.default?.description || 'No description';
+      console.log(`  ${scenarioName.padEnd(30)} - ${description}`);
+    } catch (error) {
+      console.log(`  ${scenarioName.padEnd(30)} - (Error loading)`);
+    }
+  }
+
+  console.log('');
+}
+
+export async function initScenario(scenario: string, options: any): Promise<void> {
+  const scenarioPath = path.join(process.cwd(), 'simulation', 'scenarios', `${scenario}.ts`);
+
+  if (fs.existsSync(scenarioPath)) {
+    console.error(`❌ Scenario already exists: ${scenario}`);
+    return;
+  }
+
+  const template = getTemplate(options.template);
+  fs.writeFileSync(scenarioPath, template);
+
+  console.log(`✅ Created scenario: ${scenario}`);
+  console.log(`   Path: ${scenarioPath}`);
+  console.log(`   Template: ${options.template}`);
+}
+
+function getTemplate(templateName: string): string {
+  const templates: Record<string, string> = {
+    basic: `/**
+ * Basic Simulation Scenario
+ */
+
+export default {
+  description: 'Basic simulation scenario',
+
+  async run(config: any) {
+    // Your simulation logic here
+    return {
+      status: 'success',
+      data: {}
+    };
+  }
+};
+`,
+    swarm: `/**
+ * Swarm Simulation Scenario
+ */
+
+export default {
+  description: 'Multi-agent swarm simulation',
+
+  async run(config: any) {
+    const { swarmInit, agentSpawn } = await import('./swarms/coordinator.js');
+
+    // Initialize swarm
+    const swarm = await swarmInit({
+      topology: 'mesh',
+      maxAgents: config.size
+    });
+
+    // Spawn agents
+    const agents = [];
+    for (let i = 0; i < config.size; i++) {
+      const agent = await agentSpawn({
+        swarmId: swarm.id,
+        type: 'worker',
+        capabilities: ['agentdb']
+      });
+      agents.push(agent);
+    }
+
+    // Execute tasks
+    const results = await Promise.all(
+      agents.map(agent => agent.execute())
+    );
+
+    return {
+      status: 'success',
+      agents: agents.length,
+      results
+    };
+  }
+};
+`
+  };
+
+  return templates[templateName] || templates.basic;
+}

package/simulation/scenarios/README-advanced/aidefence-integration.md

@@ -0,0 +1,63 @@
+# AIDefence Integration - Security Threat Modeling
+
+## Overview
+Security-focused graph database for threat pattern recognition, attack vector analysis, and defense strategy optimization.
+
+## Purpose
+Model cybersecurity threats and defenses using graph-based relationships between threats, attack vectors, and countermeasures.
+
+## Operations
+- **Threats Detected**: 5 (SQL injection, XSS, CSRF, DDoS, privilege escalation)
+- **Attack Vectors**: 4 common exploitation paths
+- **Defense Strategies**: 5 countermeasures
+- **Threat Level**: 91.6% average severity
+
+## Results
+- **Throughput**: 2.26 ops/sec
+- **Latency**: 432ms avg
+- **Threats Detected**: 5
+- **Attack Vectors**: 4
+- **Defense Strategies**: 5
+- **Avg Threat Level**: 91.6%
+
+## Technical Details
+
+### Threat Model
+```typescript
+threat: {
+  type: 'sql_injection',
+  severity: 0.95,  // High severity
+  detected: true
+}
+```
+
+### Defense Strategy
+```typescript
+defense: {
+  strategy: 'parameterized_queries',
+  effectiveness: 0.98  // 98% mitigation
+}
+```
+
+### Threat Coverage
+| Threat | Severity | Defense | Effectiveness |
+|--------|----------|---------|---------------|
+| SQL Injection | 95% | Parameterized queries | 98% |
+| XSS | 88% | Input sanitization | 93% |
+| CSRF | 85% | CSRF tokens | 90% |
+| DDoS | 92% | Rate limiting | 88% |
+| Privilege Escalation | 98% | Secure session mgmt | 95% |
+
+## Applications
+- **Security Operations Centers**: Threat intelligence
+- **Penetration Testing**: Attack surface analysis
+- **Compliance**: Security audit trails
+- **DevSecOps**: Security in CI/CD pipelines
+
+## Integration Features
+- Real-time threat detection
+- Defense effectiveness tracking
+- Attack vector mapping
+- Mitigation strategy optimization
+
+**Status**: ✅ Operational | **Package**: aidefence

package/simulation/scenarios/README-advanced/bmssp-integration.md

@@ -0,0 +1,58 @@
+# BMSSP Integration - Biologically-Motivated Symbolic-Subsymbolic Processing
+
+## Overview
+Hybrid symbolic-subsymbolic processing combining rule-based logic with neural pattern recognition.
+
+## Purpose
+Model how biological brains integrate symbolic reasoning (conscious thought) with subsymbolic processing (intuition, pattern recognition).
+
+## Operations
+- **Symbolic Rules**: 3 logical inference rules
+- **Subsymbolic Patterns**: 3 neural activation patterns
+- **Hybrid Inferences**: 3 combined reasoning steps
+- **Confidence Scores**: 85-95% average
+
+## Results
+- **Throughput**: 2.38 ops/sec
+- **Latency**: 410ms avg
+- **Memory**: 23 MB
+- **Symbolic Rules**: 3
+- **Subsymbolic Patterns**: 3
+- **Hybrid Inferences**: 3
+- **Avg Confidence**: 91.7%
+
+## Technical Details
+
+### Symbolic Layer
+```typescript
+rule: 'IF temperature > 30 THEN activate_cooling'
+confidence: 0.95
+```
+
+### Subsymbolic Layer
+```typescript
+pattern: 'temperature_trend_rising'
+strength: 0.88  // Neural activation level
+```
+
+### Integration
+Combines symbolic IF-THEN rules with subsymbolic pattern detection for robust decision-making.
+
+## Applications
+- **Smart Home Systems**: Combine rules with learned preferences
+- **Medical Diagnosis**: Clinical guidelines + pattern recognition
+- **Autonomous Vehicles**: Traffic rules + learned behaviors
+- **Robotics**: Programmed behaviors + adaptive learning
+
+## Package Integration
+- **@ruvnet/bmssp**: Core BMSSP algorithms
+- **Graph DB**: Optimized for symbolic rule graphs
+- **Distance Metric**: Cosine (best for semantic similarity)
+
+## Research Connections
+- Connectionist AI (1980s-90s)
+- Hybrid AI systems
+- Cognitive architectures (ACT-R, SOAR)
+- Dual-process theory (Kahneman)
+
+**Status**: ✅ Operational | **Package**: @ruvnet/bmssp

package/simulation/scenarios/README-advanced/consciousness-explorer.md

@@ -0,0 +1,53 @@
+# Consciousness Explorer - Multi-Layered Consciousness Model
+
+## Overview
+Multi-layered graph implementing consciousness theories: Global Workspace Theory, Integrated Information Theory, and Higher-Order Thought.
+
+## Purpose
+Model consciousness as emergent property from layered processing: perception → attention → metacognition.
+
+## Operations
+- **Layer 1**: Perceptual processing (3 modalities)
+- **Layer 2**: Attention & global workspace (3 foci)
+- **Layer 3**: Metacognitive monitoring (3 processes)
+- **Integration**: Integrated Information (φ) calculation
+
+## Results
+- **Throughput**: 2.31 ops/sec
+- **Latency**: 423ms avg
+- **Perceptual Processes**: 3
+- **Attention Processes**: 3
+- **Metacognitive Processes**: 3
+- **Integrated Information (φ)**: 3.00
+- **Consciousness Level**: 83.3%
+
+## Technical Details
+
+### Layer Architecture
+```
+Layer 1: Perception (visual, auditory, tactile)
+    ↓
+Layer 2: Attention (salient objects, global workspace broadcast)
+    ↓
+Layer 3: Metacognition (self-monitoring, error detection)
+    ↓
+φ (Integrated Information) = f(L1, L2, L3)
+```
+
+### Consciousness Metrics
+- **φ (Phi)**: 3.00 (measure of information integration)
+- **Consciousness Level**: 83.3% (weighted by layer importance)
+
+## Applications
+- **AI Safety**: Self-aware AI systems
+- **Cognitive Modeling**: Brain simulation
+- **Philosophy**: Consciousness studies
+- **Anesthesia**: Consciousness monitoring
+
+## Theoretical Frameworks
+1. Global Workspace Theory (Baars, 1988)
+2. Integrated Information Theory (Tononi, 2004)
+3. Higher-Order Thought (Rosenthal, 1986)
+4. Attention Schema Theory (Graziano, 2013)
+
+**Status**: ✅ Operational | **Package**: consciousness-explorer

package/simulation/scenarios/README-advanced/goalie-integration.md

@@ -0,0 +1,61 @@
+# Goalie Integration - Goal-Oriented AI Learning Engine
+
+## Overview
+Hierarchical goal decomposition with achievement trees, tracking progress from high-level objectives to actionable subgoals.
+
+## Purpose
+Model how AI agents can break down complex goals into manageable subgoals and track achievement progress.
+
+## Operations
+- **Primary Goals**: 3 high-level objectives
+- **Subgoals**: 9 decomposed tasks (3 per goal)
+- **Achievements**: 3 completed subgoals
+- **Causal Links**: Subgoal → Parent goal dependencies
+
+## Results
+- **Throughput**: 2.23 ops/sec
+- **Latency**: 437ms avg
+- **Primary Goals**: 3
+- **Subgoals**: 9
+- **Achievements**: 3
+- **Avg Progress**: 33.3%
+
+## Technical Details
+
+### Goal Hierarchy
+```
+Primary: build_production_system (priority: 0.95)
+  ├── Subgoal: setup_ci_cd ✅
+  ├── Subgoal: implement_logging
+  └── Subgoal: add_monitoring
+
+Primary: achieve_90_percent_test_coverage (priority: 0.88)
+  ├── Subgoal: write_unit_tests ✅
+  ├── Subgoal: write_integration_tests
+  └── Subgoal: add_e2e_tests
+
+Primary: optimize_performance_10x (priority: 0.92)
+  ├── Subgoal: profile_bottlenecks ✅
+  ├── Subgoal: optimize_queries
+  └── Subgoal: add_caching
+```
+
+### Achievement Tracking
+```typescript
+achievement: 'setup_ci_cd'
+successRate: 1.0  // 100% completed
+```
+
+## Applications
+- **Project Management AI**: Task decomposition
+- **Game AI**: Quest/objective systems
+- **Robotics**: Multi-step task planning
+- **Personal Assistants**: Goal tracking
+
+## Features
+- Hierarchical goal decomposition
+- Progress monitoring
+- Dependency tracking (causal edges)
+- Achievement unlocking
+
+**Status**: ✅ Operational | **Package**: goalie

package/simulation/scenarios/README-advanced/psycho-symbolic-reasoner.md

@@ -0,0 +1,55 @@
+# Psycho-Symbolic Reasoner - Cognitive Bias Modeling
+
+## Overview
+Hybrid reasoning combining psychological models (cognitive biases, heuristics) with symbolic logic and subsymbolic patterns.
+
+## Purpose
+Model human-like reasoning including systematic biases, demonstrating more realistic AI decision-making.
+
+## Operations
+- **Psychological Models**: 3 (confirmation bias, availability heuristic, anchoring)
+- **Symbolic Rules**: 2 logical inference rules
+- **Subsymbolic Patterns**: 5 neural activation patterns
+- **Hybrid Reasoning**: 5 integrated decisions
+
+## Results
+- **Throughput**: 2.04 ops/sec
+- **Latency**: 479ms avg
+- **Memory**: 23 MB
+- **Psychological Models**: 3
+- **Symbolic Rules**: 2
+- **Subsymbolic Patterns**: 5
+- **Hybrid Instances**: 5
+
+## Technical Details
+
+### Psychological Layer
+```typescript
+model: 'confirmation_bias'
+strength: 0.88
+// Tendency to favor confirming evidence
+```
+
+### Symbolic Layer
+```typescript
+rule: 'IF bias_detected THEN adjust_confidence'
+confidence: 0.92
+```
+
+### Integration
+Detects cognitive biases → Applies corrective symbolic rules → Uses subsymbolic patterns for nuanced decisions
+
+## Applications
+- **Decision Support Systems**: Bias-aware recommendations
+- **Educational Tools**: Teaching critical thinking
+- **UX Design**: Predict user behavior patterns
+- **Negotiation AI**: Model human decision-making
+
+## Cognitive Biases Modeled
+1. Confirmation bias
+2. Availability heuristic
+3. Anchoring effect
+4. Representativeness heuristic
+5. Framing effects
+
+**Status**: ✅ Operational | **Package**: psycho-symbolic-reasoner