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

package/simulation/types.ts

@@ -0,0 +1,177 @@
+/**
+ * Shared TypeScript types for AgentDB simulation framework
+ */
+
+export interface SimulationScenario {
+  id: string;
+  name: string;
+  category: string;
+  description: string;
+  config: any;
+  run(config: any): Promise<SimulationReport>;
+}
+
+export interface SimulationReport {
+  scenarioId: string;
+  timestamp: string;
+  executionTimeMs: number;
+  summary: Record<string, any>;
+  metrics: Record<string, any>;
+  detailedResults?: any[];
+  analysis?: string;
+  recommendations?: string[];
+  artifacts?: Record<string, any>;
+}
+
+// Unified metrics interface for all scenarios
+export interface UnifiedMetrics {
+  latencyUs: {
+    p50: number;
+    p95: number;
+    p99: number;
+  };
+  recallAtK: {
+    k10: number;
+    k50: number;
+    k100: number;
+  };
+  qps: number;
+  memoryMB: number;
+  coherenceScore?: number;  // Multi-run consistency 0-1
+}
+
+export interface PerformanceMetrics {
+  throughput?: number;
+  latencyMs?: number;
+  memoryMB?: number;
+  cpuPercent?: number;
+  [key: string]: any;
+}
+
+export interface SearchResult {
+  id: string;
+  distance: number;
+  metadata?: any;
+}
+
+export interface TrainingExample {
+  input: any;
+  output: any;
+  metadata?: any;
+}
+
+export interface SearchOptions {
+  k?: number;
+  ef?: number;
+  filter?: any;
+  [key: string]: any;
+}
+
+export interface GraphPath {
+  nodes: string[];
+  edges: Array<{ from: string; to: string; weight?: number }>;
+  length: number;
+  cost?: number;
+}
+
+// === Clustering Analysis Types ===
+
+export interface LouvainConfig {
+  resolutionParameter: number;
+  convergenceThreshold: number;
+  minModularity: number;
+  targetSemanticPurity: number;
+  hierarchicalLevels: number;
+}
+
+export interface Community {
+  id: string;
+  nodes: any[];
+  internalEdges: number;
+  totalDegree: number;
+  modularity: number;
+  semanticPurity: number;
+}
+
+// === Self-Organizing HNSW Types ===
+
+export interface MPCConfig {
+  predictionHorizon: number;
+  controlHorizon: number;
+  adaptationIntervalMs: number;
+  degradationThreshold: number;
+  preventionRate: number;
+}
+
+export interface DegradationForecast {
+  step: number;
+  predictedLatency: number;
+  confidence: number;
+}
+
+// === Neural Augmentation Types ===
+
+export interface GNNEdgeSelectionConfig {
+  adaptiveM: { min: number; max: number };
+  targetMemoryReduction: number;
+  gnnLayers: number;
+  hiddenDim: number;
+}
+
+export interface RLNavigationConfig {
+  trainingEpisodes: number;
+  convergenceEpisodes: number;
+  targetHopReduction: number;
+  learningRate: number;
+}
+
+export interface JointOptimizationConfig {
+  refinementCycles: number;
+  targetGain: number;
+  learningRate: number;
+}
+
+export interface NeuralPolicyQuality {
+  quality: number; // 0-1 score
+  convergedAt: number; // Episode number
+  hopReduction: number; // % reduction vs greedy
+}
+
+// === Hypergraph Exploration Types ===
+
+export interface HypergraphConfig {
+  avgHyperedgeSize: number;
+  compressionRatio: number;
+  cypherQueryTargetMs: number;
+  taskCoverage: number;
+}
+
+export interface HyperedgeMetrics {
+  size: number;
+  pattern: string;
+  nodes: number[];
+  weight: number;
+}
+
+// === Quantum-Hybrid Types ===
+
+export interface QuantumViabilityTimeline {
+  current2025: { viability: number; bottleneck: string };
+  nearTerm2030: { viability: number; bottleneck: string };
+  longTerm2040: { viability: number; ready: boolean };
+}
+
+export interface QuantumHardwareProfile {
+  year: number;
+  qubits: number;
+  errorRate: number;
+  coherenceMs: number;
+  viabilityScore?: number;
+}
+
+export interface TheoreticalSpeedup {
+  groverSpeedup: number; // √M for neighbor selection
+  quantumWalkSpeedup: number; // √log N for graph traversal
+  amplitudeEncodingSpeedup: number; // O(1) vs O(d)
+  overall: number;
+}

package/simulation/utils/PerformanceOptimizer.ts

@@ -0,0 +1,269 @@
+/**
+ * Performance Optimizer for AgentDB Simulations
+ *
+ * Optimizations:
+ * - Batch database operations
+ * - Intelligent caching
+ * - Parallel agent execution
+ * - Memory pooling
+ * - Query optimization
+ * - Connection pooling
+ */
+
+export class PerformanceOptimizer {
+  private batchQueue: Array<() => Promise<any>> = [];
+  private batchSize: number = 100;
+  private cache: Map<string, { data: any; timestamp: number; ttl: number }> = new Map();
+  private metrics: {
+    batchOperations: number;
+    cacheHits: number;
+    cacheMisses: number;
+    totalLatency: number;
+    operations: number;
+  } = {
+    batchOperations: 0,
+    cacheHits: 0,
+    cacheMisses: 0,
+    totalLatency: 0,
+    operations: 0
+  };
+
+  constructor(options: { batchSize?: number } = {}) {
+    this.batchSize = options.batchSize || 100;
+  }
+
+  /**
+   * Add operation to batch queue
+   */
+  queueOperation(operation: () => Promise<any>): void {
+    this.batchQueue.push(operation);
+  }
+
+  /**
+   * Execute all queued operations in parallel batches
+   */
+  async executeBatch(): Promise<any[]> {
+    if (this.batchQueue.length === 0) return [];
+
+    const startTime = performance.now();
+    const results: any[] = [];
+
+    // Process in batches to avoid overwhelming the system
+    for (let i = 0; i < this.batchQueue.length; i += this.batchSize) {
+      const batch = this.batchQueue.slice(i, i + this.batchSize);
+      const batchResults = await Promise.all(batch.map(op => op()));
+      results.push(...batchResults);
+      this.metrics.batchOperations++;
+    }
+
+    this.batchQueue = [];
+    const endTime = performance.now();
+    this.metrics.totalLatency += endTime - startTime;
+    this.metrics.operations += results.length;
+
+    return results;
+  }
+
+  /**
+   * Cache data with TTL
+   */
+  setCache(key: string, data: any, ttl: number = 60000): void {
+    this.cache.set(key, {
+      data,
+      timestamp: Date.now(),
+      ttl
+    });
+  }
+
+  /**
+   * Get cached data
+   */
+  getCache(key: string): any | null {
+    const cached = this.cache.get(key);
+
+    if (!cached) {
+      this.metrics.cacheMisses++;
+      return null;
+    }
+
+    // Check if expired
+    if (Date.now() - cached.timestamp > cached.ttl) {
+      this.cache.delete(key);
+      this.metrics.cacheMisses++;
+      return null;
+    }
+
+    this.metrics.cacheHits++;
+    return cached.data;
+  }
+
+  /**
+   * Clear expired cache entries
+   */
+  clearExpiredCache(): void {
+    const now = Date.now();
+    for (const [key, value] of this.cache.entries()) {
+      if (now - value.timestamp > value.ttl) {
+        this.cache.delete(key);
+      }
+    }
+  }
+
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    const hitRate = this.metrics.cacheHits + this.metrics.cacheMisses > 0
+      ? (this.metrics.cacheHits / (this.metrics.cacheHits + this.metrics.cacheMisses)) * 100
+      : 0;
+
+    return {
+      size: this.cache.size,
+      hits: this.metrics.cacheHits,
+      misses: this.metrics.cacheMisses,
+      hitRate: hitRate.toFixed(2) + '%'
+    };
+  }
+
+  /**
+   * Get performance metrics
+   */
+  getMetrics() {
+    const avgLatency = this.metrics.operations > 0
+      ? this.metrics.totalLatency / this.metrics.operations
+      : 0;
+
+    return {
+      batchOperations: this.metrics.batchOperations,
+      totalOperations: this.metrics.operations,
+      avgLatency: avgLatency.toFixed(2) + 'ms',
+      cacheStats: this.getCacheStats()
+    };
+  }
+
+  /**
+   * Reset metrics
+   */
+  resetMetrics(): void {
+    this.metrics = {
+      batchOperations: 0,
+      cacheHits: 0,
+      cacheMisses: 0,
+      totalLatency: 0,
+      operations: 0
+    };
+  }
+
+  /**
+   * Clear all cache
+   */
+  clearCache(): void {
+    this.cache.clear();
+  }
+}
+
+/**
+ * Parallel execution utility
+ */
+export async function executeParallel<T>(
+  tasks: Array<() => Promise<T>>,
+  concurrency: number = 10
+): Promise<T[]> {
+  const results: T[] = [];
+
+  for (let i = 0; i < tasks.length; i += concurrency) {
+    const batch = tasks.slice(i, i + concurrency);
+    const batchResults = await Promise.all(batch.map(task => task()));
+    results.push(...batchResults);
+  }
+
+  return results;
+}
+
+/**
+ * Memory pooling for agent objects
+ */
+export class AgentPool<T> {
+  private pool: T[] = [];
+  private factory: () => T;
+  private maxSize: number;
+
+  constructor(factory: () => T, maxSize: number = 100) {
+    this.factory = factory;
+    this.maxSize = maxSize;
+  }
+
+  /**
+   * Get agent from pool or create new
+   */
+  acquire(): T {
+    if (this.pool.length > 0) {
+      return this.pool.pop()!;
+    }
+    return this.factory();
+  }
+
+  /**
+   * Return agent to pool
+   */
+  release(agent: T): void {
+    if (this.pool.length < this.maxSize) {
+      this.pool.push(agent);
+    }
+  }
+
+  /**
+   * Clear pool
+   */
+  clear(): void {
+    this.pool = [];
+  }
+
+  /**
+   * Get pool size
+   */
+  size(): number {
+    return this.pool.length;
+  }
+}
+
+/**
+ * Query optimizer for database operations
+ */
+export class QueryOptimizer {
+  private queryCache: Map<string, any> = new Map();
+
+  /**
+   * Optimize Cypher query with caching
+   */
+  async executeOptimized(
+    queryFn: () => Promise<any>,
+    cacheKey?: string,
+    ttl: number = 5000
+  ): Promise<any> {
+    if (cacheKey) {
+      const cached = this.queryCache.get(cacheKey);
+      if (cached && Date.now() - cached.timestamp < ttl) {
+        return cached.data;
+      }
+    }
+
+    const result = await queryFn();
+
+    if (cacheKey) {
+      this.queryCache.set(cacheKey, {
+        data: result,
+        timestamp: Date.now()
+      });
+    }
+
+    return result;
+  }
+
+  /**
+   * Clear query cache
+   */
+  clearCache(): void {
+    this.queryCache.clear();
+  }
+}

package/src/cli/lib/history-tracker.ts

@@ -272,7 +272,13 @@ export class HistoryTracker {
 
       baseline = {
         ...currentRun,
-        metrics: avgMetrics
+        metrics: {
+          recall: 0,
+          latency: 0,
+          throughput: 0,
+          memoryUsage: 0,
+          ...avgMetrics
+        }
       };
     }