@agentic-robotics/mcp 0.1.3 → 0.2.1

package/src/optimized-benchmark.ts

@@ -1,302 +0,0 @@
-/**
- * Optimized Benchmark Suite
- *
- * Uses JavaScript APIs directly for accurate performance measurement
- */
-
-import { OptimizedAgentDBMemory } from './optimized-memory.js';
-import type { Episode } from './memory.js';
-
-interface BenchmarkResult {
-  name: string;
-  iterations: number;
-  totalTime: number;
-  avgTime: number;
-  minTime: number;
-  maxTime: number;
-  opsPerSec: number;
-  p50: number;
-  p95: number;
-  p99: number;
-}
-
-interface BenchmarkSuite {
-  agentdb: {
-    storeEpisode: BenchmarkResult;
-    retrieveMemories: BenchmarkResult;
-    queryWithContext: BenchmarkResult;
-    consolidateSkills: BenchmarkResult;
-    searchSkills: BenchmarkResult;
-  };
-  overall: {
-    totalTime: number;
-    timestamp: string;
-  };
-}
-
-export class OptimizedBenchmark {
-  private memory: OptimizedAgentDBMemory;
-
-  constructor() {
-    this.memory = new OptimizedAgentDBMemory('./optimized-benchmark.db');
-  }
-
-  async initialize(): Promise<void> {
-    console.log('🏁 Initializing optimized benchmark suite...\n');
-    await this.memory.initialize();
-    console.log('✅ Benchmark suite ready\n');
-  }
-
-  /**
-   * Run complete benchmark suite
-   */
-  async runAll(): Promise<BenchmarkSuite> {
-    const suiteStartTime = Date.now();
-
-    console.log('┌─────────────────────────────────────────────────────────┐');
-    console.log('│   Optimized Integration Benchmark Suite                 │');
-    console.log('│   AgentDB JavaScript API Performance Test               │');
-    console.log('└─────────────────────────────────────────────────────────┘\n');
-
-    // AgentDB Benchmarks with JS API
-    console.log('📊 AGENTDB BENCHMARKS (JS API)\n');
-
-    const storeEpisode = await this.benchmarkStoreEpisode(1000);
-    this.printResult('Store Episode', storeEpisode);
-
-    const retrieveMemories = await this.benchmarkRetrieveMemories(500);
-    this.printResult('Retrieve Memories', retrieveMemories);
-
-    const queryWithContext = await this.benchmarkQueryWithContext(300);
-    this.printResult('Query with Context', queryWithContext);
-
-    const consolidateSkills = await this.benchmarkConsolidateSkills(10);
-    this.printResult('Consolidate Skills', consolidateSkills);
-
-    const searchSkills = await this.benchmarkSearchSkills(200);
-    this.printResult('Search Skills', searchSkills);
-
-    const totalTime = Date.now() - suiteStartTime;
-
-    console.log('\n┌─────────────────────────────────────────────────────────┐');
-    console.log('│   BENCHMARK COMPLETE                                    │');
-    console.log(`│   Total Time: ${(totalTime / 1000).toFixed(2)}s                                 │`);
-    console.log('└─────────────────────────────────────────────────────────┘\n');
-
-    // Print performance metrics
-    const metrics = this.memory.getMetrics();
-    console.log('📈 PERFORMANCE METRICS\n');
-    console.log(`  Store Operations:    ${metrics.storeCount}`);
-    console.log(`  Avg Store Time:      ${metrics.avgStoreTime.toFixed(3)}ms`);
-    console.log(`  Retrieve Operations: ${metrics.retrieveCount}`);
-    console.log(`  Avg Retrieve Time:   ${metrics.avgRetrieveTime.toFixed(3)}ms\n`);
-
-    return {
-      agentdb: {
-        storeEpisode,
-        retrieveMemories,
-        queryWithContext,
-        consolidateSkills,
-        searchSkills,
-      },
-      overall: {
-        totalTime,
-        timestamp: new Date().toISOString(),
-      },
-    };
-  }
-
-  /**
-   * Benchmark: Store Episode (JS API)
-   */
-  private async benchmarkStoreEpisode(iterations: number): Promise<BenchmarkResult> {
-    const times: number[] = [];
-
-    for (let i = 0; i < iterations; i++) {
-      const episode: Episode = {
-        sessionId: `bench-${i}`,
-        taskName: 'navigation',
-        confidence: Math.random(),
-        success: Math.random() > 0.3,
-        outcome: 'Completed navigation task',
-        strategy: 'adaptive_planning',
-        metadata: { x: i, y: i * 2, latency: Math.random() * 100 },
-      };
-
-      const start = performance.now();
-      await this.memory.storeEpisode(episode);
-      times.push(performance.now() - start);
-
-      if (i % 100 === 0 && i > 0) {
-        process.stderr.write(`  Progress: ${i}/${iterations}\r`);
-      }
-    }
-
-    return this.calculateStats('Store Episode', times);
-  }
-
-  /**
-   * Benchmark: Retrieve Memories (JS API)
-   */
-  private async benchmarkRetrieveMemories(iterations: number): Promise<BenchmarkResult> {
-    const times: number[] = [];
-
-    const queries = [
-      'navigation task',
-      'object detection',
-      'path planning',
-      'sensor fusion',
-      'motor control',
-    ];
-
-    for (let i = 0; i < iterations; i++) {
-      const query = queries[i % queries.length];
-
-      const start = performance.now();
-      await this.memory.retrieveMemories(query, 5, {
-        onlySuccesses: true,
-        synthesizeContext: true,
-      });
-      times.push(performance.now() - start);
-
-      if (i % 50 === 0 && i > 0) {
-        process.stderr.write(`  Progress: ${i}/${iterations}\r`);
-      }
-    }
-
-    return this.calculateStats('Retrieve Memories', times);
-  }
-
-  /**
-   * Benchmark: Query with Context (JS API)
-   */
-  private async benchmarkQueryWithContext(iterations: number): Promise<BenchmarkResult> {
-    const times: number[] = [];
-
-    for (let i = 0; i < iterations; i++) {
-      const start = performance.now();
-      await this.memory.queryWithContext('warehouse navigation', {
-        k: 10,
-        minConfidence: 0.5,
-        synthesizeReasoning: true,
-      });
-      times.push(performance.now() - start);
-
-      if (i % 30 === 0 && i > 0) {
-        process.stderr.write(`  Progress: ${i}/${iterations}\r`);
-      }
-    }
-
-    return this.calculateStats('Query with Context', times);
-  }
-
-  /**
-   * Benchmark: Consolidate Skills (JS API)
-   */
-  private async benchmarkConsolidateSkills(iterations: number): Promise<BenchmarkResult> {
-    const times: number[] = [];
-
-    for (let i = 0; i < iterations; i++) {
-      const start = performance.now();
-      await this.memory.consolidateSkills({
-        minAttempts: 3,
-        minReward: 0.7,
-        timeWindowDays: 7,
-        enablePruning: true,
-      });
-      times.push(performance.now() - start);
-
-      if (i % 2 === 0 && i > 0) {
-        process.stderr.write(`  Progress: ${i}/${iterations}\r`);
-      }
-    }
-
-    return this.calculateStats('Consolidate Skills', times);
-  }
-
-  /**
-   * Benchmark: Search Skills (JS API)
-   */
-  private async benchmarkSearchSkills(iterations: number): Promise<BenchmarkResult> {
-    const times: number[] = [];
-
-    for (let i = 0; i < iterations; i++) {
-      const start = performance.now();
-      await this.memory.searchSkills('navigation', {
-        k: 5,
-        minSuccessRate: 0.5,
-        sortBy: 'success_rate',
-      });
-      times.push(performance.now() - start);
-
-      if (i % 20 === 0 && i > 0) {
-        process.stderr.write(`  Progress: ${i}/${iterations}\r`);
-      }
-    }
-
-    return this.calculateStats('Search Skills', times);
-  }
-
-  /**
-   * Calculate statistics from timing data
-   */
-  private calculateStats(name: string, times: number[]): BenchmarkResult {
-    const sorted = [...times].sort((a, b) => a - b);
-    const total = times.reduce((a, b) => a + b, 0);
-
-    return {
-      name,
-      iterations: times.length,
-      totalTime: total,
-      avgTime: total / times.length,
-      minTime: sorted[0],
-      maxTime: sorted[sorted.length - 1],
-      opsPerSec: (times.length / total) * 1000,
-      p50: sorted[Math.floor(sorted.length * 0.50)],
-      p95: sorted[Math.floor(sorted.length * 0.95)],
-      p99: sorted[Math.floor(sorted.length * 0.99)],
-    };
-  }
-
-  /**
-   * Print benchmark result
-   */
-  private printResult(name: string, result: BenchmarkResult): void {
-    console.log(`${name}:`);
-    console.log(`  Iterations:  ${result.iterations.toLocaleString()}`);
-    console.log(`  Avg Time:    ${result.avgTime.toFixed(3)}ms`);
-    console.log(`  Min/Max:     ${result.minTime.toFixed(3)}ms / ${result.maxTime.toFixed(3)}ms`);
-    console.log(`  p50/p95/p99: ${result.p50.toFixed(3)}ms / ${result.p95.toFixed(3)}ms / ${result.p99.toFixed(3)}ms`);
-    console.log(`  Ops/sec:     ${result.opsPerSec.toFixed(0)}`);
-    console.log('');
-  }
-
-  /**
-   * Export results to JSON
-   */
-  async exportResults(suite: BenchmarkSuite, filename: string): Promise<void> {
-    const fs = await import('fs/promises');
-    await fs.writeFile(filename, JSON.stringify(suite, null, 2));
-    console.log(`📁 Results exported to ${filename}`);
-  }
-
-  async close(): Promise<void> {
-    await this.memory.close();
-  }
-}
-
-// CLI entry point
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const benchmark = new OptimizedBenchmark();
-
-  try {
-    await benchmark.initialize();
-    const results = await benchmark.runAll();
-    await benchmark.exportResults(results, './optimized-benchmark-results.json');
-  } catch (error) {
-    console.error('❌ Benchmark failed:', error);
-    process.exit(1);
-  } finally {
-    await benchmark.close();
-  }
-}

package/src/optimized-memory.ts

@@ -1,271 +0,0 @@
-/**
- * Optimized AgentDB Memory Integration
- *
- * Uses AgentDB JavaScript API directly for maximum performance
- * Eliminates CLI process spawning overhead (100x+ faster)
- */
-
-import { ReflexionMemory, SkillLibrary, ReasoningBank, CausalMemoryGraph } from 'agentdb';
-import type { Episode, Memory } from './memory.js';
-
-export interface Skill {
-  name: string;
-  description: string;
-  successRate: number;
-  avgReward: number;
-  attempts: number;
-  lastUsed: number;
-}
-
-export interface CausalReasoning {
-  cause: string;
-  effect: string;
-  confidence: number;
-  evidence: string[];
-}
-
-export class OptimizedAgentDBMemory {
-  private reflexion: ReflexionMemory;
-  private skills: SkillLibrary;
-  private reasoning: ReasoningBank;
-  private causal: CausalMemoryGraph;
-  private dbPath: string;
-  private performanceMetrics: {
-    storeCount: number;
-    retrieveCount: number;
-    avgStoreTime: number;
-    avgRetrieveTime: number;
-  };
-
-  constructor(dbPath: string) {
-    this.dbPath = dbPath;
-    this.performanceMetrics = {
-      storeCount: 0,
-      retrieveCount: 0,
-      avgStoreTime: 0,
-      avgRetrieveTime: 0,
-    };
-  }
-
-  async initialize(): Promise<void> {
-    const startTime = Date.now();
-
-    // Initialize AgentDB components with JS API
-    // These classes handle their own database initialization
-    this.reflexion = new ReflexionMemory();
-    this.skills = new SkillLibrary();
-    this.reasoning = new ReasoningBank();
-    this.causal = new CausalMemoryGraph();
-
-    const elapsed = Date.now() - startTime;
-    console.error(`✅ AgentDB initialized: ${this.dbPath}`);
-    console.error(`⚡ Initialization time: ${elapsed}ms`);
-  }
-
-  /**
-   * Store episode using JS API (100x faster than CLI)
-   */
-  async storeEpisode(episode: Episode): Promise<void> {
-    const startTime = Date.now();
-
-    await this.reflexion.store({
-      sessionId: episode.sessionId,
-      taskName: episode.taskName,
-      confidence: episode.confidence,
-      success: episode.success,
-      outcome: episode.outcome,
-      strategy: episode.strategy,
-      metadata: episode.metadata,
-    });
-
-    const elapsed = Date.now() - startTime;
-    this.updateStoreMetrics(elapsed);
-
-    if (this.performanceMetrics.storeCount % 100 === 0) {
-      console.error(`💾 Stored episode: ${episode.taskName} (${elapsed}ms)`);
-    }
-  }
-
-  /**
-   * Retrieve memories using JS API (150x faster than CLI)
-   */
-  async retrieveMemories(
-    query: string,
-    k: number = 5,
-    options: {
-      minReward?: number;
-      onlySuccesses?: boolean;
-      onlyFailures?: boolean;
-      synthesizeContext?: boolean;
-    } = {}
-  ): Promise<Memory[]> {
-    const startTime = Date.now();
-
-    const results = await this.reflexion.retrieve(query, k, {
-      minReward: options.minReward,
-      onlySuccesses: options.onlySuccesses,
-      onlyFailures: options.onlyFailures,
-      synthesizeContext: options.synthesizeContext,
-    });
-
-    const elapsed = Date.now() - startTime;
-    this.updateRetrieveMetrics(elapsed);
-
-    return results.map((r: any) => ({
-      task: r.taskName || r.task,
-      confidence: r.confidence,
-      success: r.success,
-      outcome: r.outcome,
-      strategy: r.strategy,
-      timestamp: r.timestamp,
-    }));
-  }
-
-  /**
-   * Query with causal reasoning and context synthesis
-   */
-  async queryWithContext(
-    query: string,
-    options: {
-      k?: number;
-      minConfidence?: number;
-      synthesizeReasoning?: boolean;
-    } = {}
-  ): Promise<{
-    memories: Memory[];
-    context?: string;
-    reasoning?: CausalReasoning[];
-  }> {
-    const { k = 5, minConfidence = 0.0, synthesizeReasoning = false } = options;
-
-    const memories = await this.retrieveMemories(query, k, {
-      minReward: minConfidence,
-    });
-
-    let context: string | undefined;
-    let reasoning: CausalReasoning[] | undefined;
-
-    if (synthesizeReasoning && memories.length > 0) {
-      // Use ReasoningBank to synthesize insights
-      const insights = await this.reasoning.synthesize(
-        memories.map((m) => m.outcome)
-      );
-      context = insights.summary;
-
-      // Extract causal relationships
-      const causalLinks = await this.causal.query(query, { k: 3 });
-      reasoning = causalLinks.map((link: any) => ({
-        cause: link.cause,
-        effect: link.effect,
-        confidence: link.confidence,
-        evidence: link.evidence || [],
-      }));
-    }
-
-    return { memories, context, reasoning };
-  }
-
-  /**
-   * Consolidate skills from successful episodes
-   */
-  async consolidateSkills(options: {
-    minAttempts?: number;
-    minReward?: number;
-    timeWindowDays?: number;
-    enablePruning?: boolean;
-  } = {}): Promise<void> {
-    const {
-      minAttempts = 3,
-      minReward = 0.7,
-      timeWindowDays = 7,
-      enablePruning = true,
-    } = options;
-
-    await this.skills.consolidate({
-      minAttempts,
-      minReward,
-      timeWindow: timeWindowDays * 24 * 60 * 60 * 1000,
-      enablePruning,
-    });
-  }
-
-  /**
-   * Search skill library with semantic search
-   */
-  async searchSkills(
-    query: string,
-    options: {
-      k?: number;
-      minSuccessRate?: number;
-      sortBy?: 'success_rate' | 'avg_reward' | 'attempts';
-    } = {}
-  ): Promise<Skill[]> {
-    const { k = 5, minSuccessRate = 0.0, sortBy = 'success_rate' } = options;
-
-    const results = await this.skills.search(query, k, {
-      minSuccessRate,
-      sortBy,
-    });
-
-    return results.map((skill: any) => ({
-      name: skill.name,
-      description: skill.description,
-      successRate: skill.successRate,
-      avgReward: skill.avgReward,
-      attempts: skill.attempts,
-      lastUsed: skill.lastUsed,
-    }));
-  }
-
-  /**
-   * Optimize database (vacuum, reindex, compact)
-   */
-  async optimize(): Promise<void> {
-    await this.reflexion.vacuum();
-    await this.skills.reindex();
-    console.error('🔧 Database optimized');
-  }
-
-  /**
-   * Get performance metrics
-   */
-  getMetrics() {
-    return { ...this.performanceMetrics };
-  }
-
-  /**
-   * Get database statistics
-   */
-  async getStats(): Promise<any> {
-    const reflexionStats = await this.reflexion.getStats();
-    const skillStats = await this.skills.getStats();
-
-    return {
-      reflexion: reflexionStats,
-      skills: skillStats,
-      performance: this.performanceMetrics,
-    };
-  }
-
-  async close(): Promise<void> {
-    await this.reflexion.close();
-    await this.skills.close();
-    await this.reasoning.close();
-    await this.causal.close();
-  }
-
-  // Private helper methods
-  private updateStoreMetrics(elapsed: number): void {
-    const { storeCount, avgStoreTime } = this.performanceMetrics;
-    this.performanceMetrics.storeCount = storeCount + 1;
-    this.performanceMetrics.avgStoreTime =
-      (avgStoreTime * storeCount + elapsed) / (storeCount + 1);
-  }
-
-  private updateRetrieveMetrics(elapsed: number): void {
-    const { retrieveCount, avgRetrieveTime } = this.performanceMetrics;
-    this.performanceMetrics.retrieveCount = retrieveCount + 1;
-    this.performanceMetrics.avgRetrieveTime =
-      (avgRetrieveTime * retrieveCount + elapsed) / (retrieveCount + 1);
-  }
-}