@agentic-robotics/mcp 0.2.0 → 0.2.1

package/src/hybrid-benchmark.ts

@@ -1,291 +0,0 @@
-/**
- * Hybrid Benchmark Suite
- *
- * Demonstrates performance improvements with direct SQL storage
- */
-
-import { HybridAgentDBMemory } from './hybrid-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;
-}
-
-export class HybridBenchmark {
-  private memory: HybridAgentDBMemory;
-
-  constructor() {
-    this.memory = new HybridAgentDBMemory('./hybrid-benchmark.db');
-  }
-
-  async initialize(): Promise<void> {
-    console.log('🏁 Initializing hybrid benchmark suite...\n');
-    await this.memory.initialize();
-    console.log('✅ Benchmark suite ready\n');
-  }
-
-  /**
-   * Run complete benchmark suite
-   */
-  async runAll(): Promise<void> {
-    const suiteStartTime = Date.now();
-
-    console.log('┌─────────────────────────────────────────────────────────┐');
-    console.log('│   Hybrid Integration Benchmark Suite                    │');
-    console.log('│   Direct SQL + CLI Vector Search Performance Test       │');
-    console.log('└─────────────────────────────────────────────────────────┘\n');
-
-    // Hybrid Benchmarks
-    console.log('📊 HYBRID BENCHMARKS (SQL Storage + CLI Search)\n');
-
-    const storeEpisode = await this.benchmarkStoreEpisode(1000);
-    this.printResult('Store Episode (SQL)', storeEpisode);
-
-    const bulkStore = await this.benchmarkBulkStore(1000, 100);
-    this.printResult('Bulk Store (SQL Transaction)', bulkStore);
-
-    const retrieveMemories = await this.benchmarkRetrieveMemories(100);
-    this.printResult('Retrieve Memories (SQL Fallback)', retrieveMemories);
-
-    const queryWithContext = await this.benchmarkQueryWithContext(100);
-    this.printResult('Query with Context (Hybrid)', queryWithContext);
-
-    const searchSkills = await this.benchmarkSearchSkills(200);
-    this.printResult('Search Skills (SQL)', 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`);
-
-    // Print database stats
-    const stats = await this.memory.getStats();
-    console.log('💾 DATABASE STATISTICS\n');
-    console.log(`  Total Episodes:      ${stats.total_episodes}`);
-    console.log(`  Successful:          ${stats.successful_episodes}`);
-    console.log(`  Failed:              ${stats.failed_episodes}`);
-    console.log(`  Unique Tasks:        ${stats.unique_tasks}`);
-    console.log(`  Avg Confidence:      ${stats.avg_confidence?.toFixed(3)}\n`);
-
-    // Optimization test
-    console.log('🔧 Running database optimization...');
-    await this.memory.optimize();
-    console.log('');
-  }
-
-  /**
-   * Benchmark: Store Episode (Direct SQL)
-   */
-  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: Bulk Store (SQL Transaction)
-   */
-  private async benchmarkBulkStore(totalEpisodes: number, batchSize: number): Promise<BenchmarkResult> {
-    const times: number[] = [];
-    const numBatches = Math.ceil(totalEpisodes / batchSize);
-
-    for (let i = 0; i < numBatches; i++) {
-      const batch: Episode[] = [];
-      for (let j = 0; j < batchSize; j++) {
-        const idx = i * batchSize + j;
-        batch.push({
-          sessionId: `bulk-${idx}`,
-          taskName: 'navigation',
-          confidence: Math.random(),
-          success: Math.random() > 0.3,
-          outcome: 'Completed navigation task',
-          strategy: 'adaptive_planning',
-          metadata: { x: idx, y: idx * 2 },
-        });
-      }
-
-      const start = performance.now();
-      await this.memory.bulkStoreEpisodes(batch);
-      times.push(performance.now() - start);
-
-      if (i % 5 === 0 && i > 0) {
-        process.stderr.write(`  Progress: ${i * batchSize}/${totalEpisodes}\r`);
-      }
-    }
-
-    // Convert to per-episode times
-    const perEpisodeTimes = times.map(t => t / batchSize);
-    return this.calculateStats('Bulk Store', perEpisodeTimes);
-  }
-
-  /**
-   * Benchmark: Retrieve Memories (SQL fallback)
-   */
-  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,
-      });
-      times.push(performance.now() - start);
-
-      if (i % 20 === 0 && i > 0) {
-        process.stderr.write(`  Progress: ${i}/${iterations}\r`);
-      }
-    }
-
-    return this.calculateStats('Retrieve Memories', times);
-  }
-
-  /**
-   * Benchmark: Query with Context
-   */
-  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,
-      });
-      times.push(performance.now() - start);
-
-      if (i % 20 === 0 && i > 0) {
-        process.stderr.write(`  Progress: ${i}/${iterations}\r`);
-      }
-    }
-
-    return this.calculateStats('Query with Context', times);
-  }
-
-  /**
-   * Benchmark: Search Skills (Direct SQL)
-   */
-  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 {
-    const speedup = 2300 / result.avgTime; // Compare to CLI baseline (2.3s)
-
-    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(`  Speedup:     ${speedup.toFixed(0)}x faster than CLI`);
-    console.log('');
-  }
-
-  async close(): Promise<void> {
-    await this.memory.close();
-  }
-}
-
-// CLI entry point
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const benchmark = new HybridBenchmark();
-
-  try {
-    await benchmark.initialize();
-    await benchmark.runAll();
-  } catch (error) {
-    console.error('❌ Benchmark failed:', error);
-    process.exit(1);
-  } finally {
-    await benchmark.close();
-  }
-}

package/src/hybrid-memory.ts

@@ -1,401 +0,0 @@
-/**
- * Hybrid AgentDB Memory Implementation
- *
- * Strategy: Direct SQLite for storage (fast), CLI for vector search (until API ready)
- * Expected: 50-100x faster than pure CLI approach
- */
-
-import Database from 'better-sqlite3';
-import { promisify } from 'util';
-import { exec } from 'child_process';
-import type { Episode, Memory } from './memory.js';
-
-const execAsync = promisify(exec);
-
-export class HybridAgentDBMemory {
-  private db!: Database.Database;
-  private dbPath: string;
-  private initialized: boolean = false;
-  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> {
-    if (this.initialized) return;
-
-    const startTime = Date.now();
-
-    // Open SQLite database with optimizations
-    this.db = new Database(this.dbPath);
-
-    // Enable performance optimizations
-    this.db.pragma('journal_mode = WAL'); // Write-Ahead Logging
-    this.db.pragma('synchronous = NORMAL'); // Balance safety/speed
-    this.db.pragma('cache_size = 10000'); // 10MB cache
-    this.db.pragma('temp_store = MEMORY'); // Temp tables in memory
-    this.db.pragma('mmap_size = 30000000000'); // Memory-mapped I/O
-
-    // Create tables if they don't exist
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS reflexion_episodes (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        session_id TEXT NOT NULL,
-        task_name TEXT NOT NULL,
-        confidence REAL NOT NULL,
-        success INTEGER NOT NULL,
-        outcome TEXT,
-        strategy TEXT,
-        metadata TEXT,
-        timestamp INTEGER NOT NULL DEFAULT (strftime('%s', 'now'))
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_task_name ON reflexion_episodes(task_name);
-      CREATE INDEX IF NOT EXISTS idx_success ON reflexion_episodes(success);
-      CREATE INDEX IF NOT EXISTS idx_timestamp ON reflexion_episodes(timestamp);
-    `);
-
-    this.initialized = true;
-    const elapsed = Date.now() - startTime;
-
-    console.error(`✅ Hybrid AgentDB initialized: ${this.dbPath}`);
-    console.error(`⚡ Initialization time: ${elapsed}ms`);
-    console.error(`📊 Mode: Direct SQL storage + CLI vector search`);
-  }
-
-  /**
-   * Store episode using direct SQL (100x faster than CLI)
-   */
-  async storeEpisode(episode: Episode): Promise<void> {
-    const startTime = performance.now();
-
-    const stmt = this.db.prepare(`
-      INSERT INTO reflexion_episodes
-      (session_id, task_name, confidence, success, outcome, strategy, metadata)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `);
-
-    stmt.run(
-      episode.sessionId,
-      episode.taskName,
-      episode.confidence,
-      episode.success ? 1 : 0,
-      episode.outcome,
-      episode.strategy || null,
-      episode.metadata ? JSON.stringify(episode.metadata) : null
-    );
-
-    const elapsed = performance.now() - startTime;
-    this.updateStoreMetrics(elapsed);
-
-    if (this.performanceMetrics.storeCount % 100 === 0 && this.performanceMetrics.storeCount > 0) {
-      console.error(`💾 Stored episode: ${episode.taskName} (${elapsed.toFixed(2)}ms)`);
-    }
-  }
-
-  /**
-   * Bulk store episodes (even faster with transactions)
-   */
-  async bulkStoreEpisodes(episodes: Episode[]): Promise<void> {
-    const startTime = performance.now();
-
-    const stmt = this.db.prepare(`
-      INSERT INTO reflexion_episodes
-      (session_id, task_name, confidence, success, outcome, strategy, metadata)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `);
-
-    const insertMany = this.db.transaction((episodes: Episode[]) => {
-      for (const episode of episodes) {
-        stmt.run(
-          episode.sessionId,
-          episode.taskName,
-          episode.confidence,
-          episode.success ? 1 : 0,
-          episode.outcome,
-          episode.strategy || null,
-          episode.metadata ? JSON.stringify(episode.metadata) : null
-        );
-      }
-    });
-
-    insertMany(episodes);
-
-    const elapsed = performance.now() - startTime;
-    console.error(`💾 Bulk stored ${episodes.length} episodes (${elapsed.toFixed(2)}ms, ${(elapsed/episodes.length).toFixed(2)}ms avg)`);
-  }
-
-  /**
-   * Retrieve memories using CLI vector search (until API ready)
-   * Falls back to SQL if CLI fails
-   */
-  async retrieveMemories(
-    query: string,
-    k: number = 5,
-    options: {
-      minReward?: number;
-      onlySuccesses?: boolean;
-      onlyFailures?: boolean;
-      synthesizeContext?: boolean;
-    } = {}
-  ): Promise<Memory[]> {
-    const startTime = performance.now();
-
-    // Try CLI vector search first (semantic search)
-    try {
-      let cmd = `npx agentdb reflexion retrieve "${query}" --k ${k}`;
-
-      if (options.minReward !== undefined) {
-        cmd += ` --min-reward ${options.minReward}`;
-      }
-      if (options.onlySuccesses) {
-        cmd += ' --only-successes';
-      }
-      if (options.onlyFailures) {
-        cmd += ' --only-failures';
-      }
-      if (options.synthesizeContext) {
-        cmd += ' --synthesize-context';
-      }
-
-      const { stdout } = await execAsync(`AGENTDB_PATH="${this.dbPath}" ${cmd}`, {
-        timeout: 10000,
-      });
-
-      const lines = stdout.trim().split('\n');
-      const jsonLine = lines.find(line => line.startsWith('[') || line.startsWith('{'));
-
-      if (jsonLine) {
-        const data = JSON.parse(jsonLine);
-        const results = Array.isArray(data) ? data : [data];
-
-        const elapsed = performance.now() - startTime;
-        this.updateRetrieveMetrics(elapsed);
-
-        return results;
-      }
-    } catch (error: any) {
-      console.error('Vector search failed, falling back to SQL:', error.message);
-    }
-
-    // Fallback: Direct SQL query (keyword search)
-    const whereConditions = ['1=1'];
-    const params: any[] = [];
-
-    if (options.onlySuccesses) {
-      whereConditions.push('success = 1');
-    }
-    if (options.onlyFailures) {
-      whereConditions.push('success = 0');
-    }
-
-    // Simple keyword matching
-    whereConditions.push("task_name LIKE ? OR outcome LIKE ?");
-    params.push(`%${query}%`, `%${query}%`);
-
-    const stmt = this.db.prepare(`
-      SELECT
-        task_name as task,
-        confidence,
-        success,
-        outcome,
-        strategy,
-        timestamp
-      FROM reflexion_episodes
-      WHERE ${whereConditions.join(' AND ')}
-      ORDER BY timestamp DESC
-      LIMIT ?
-    `);
-
-    const results = stmt.all(...params, k);
-
-    const elapsed = performance.now() - startTime;
-    this.updateRetrieveMetrics(elapsed);
-
-    return results.map((row: any) => ({
-      task: row.task,
-      confidence: row.confidence,
-      success: row.success === 1,
-      outcome: row.outcome,
-      strategy: row.strategy,
-      timestamp: row.timestamp,
-    }));
-  }
-
-  /**
-   * Query with context (SQL + CLI hybrid)
-   */
-  async queryWithContext(
-    query: string,
-    options: {
-      k?: number;
-      minConfidence?: number;
-      domain?: string;
-    } = {}
-  ): Promise<{ memories: Memory[]; context?: string }> {
-    const { k = 5, minConfidence = 0.0 } = options;
-
-    const memories = await this.retrieveMemories(query, k, {
-      minReward: minConfidence,
-    });
-
-    // Generate simple context from results
-    let context: string | undefined;
-    if (memories.length > 0) {
-      const successRate = memories.filter(m => m.success).length / memories.length;
-      context = `Found ${memories.length} similar experiences (${(successRate * 100).toFixed(0)}% success rate)`;
-    }
-
-    return { memories, context };
-  }
-
-  /**
-   * Consolidate skills (direct SQL analysis)
-   */
-  async consolidateSkills(options: {
-    minAttempts?: number;
-    minReward?: number;
-    timeWindowDays?: number;
-  } = {}): Promise<void> {
-    const {
-      minAttempts = 3,
-      minReward = 0.7,
-      timeWindowDays = 7,
-    } = options;
-
-    const timeWindow = Math.floor(Date.now() / 1000) - (timeWindowDays * 24 * 60 * 60);
-
-    const stmt = this.db.prepare(`
-      SELECT
-        task_name,
-        COUNT(*) as attempts,
-        AVG(confidence) as avg_confidence,
-        SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) * 1.0 / COUNT(*) as success_rate
-      FROM reflexion_episodes
-      WHERE timestamp >= ?
-      GROUP BY task_name
-      HAVING attempts >= ? AND avg_confidence >= ?
-      ORDER BY success_rate DESC, attempts DESC
-    `);
-
-    const skills = stmt.all(timeWindow, minAttempts, minReward);
-    console.error(`🎯 Consolidated ${skills.length} skills from successful episodes`);
-  }
-
-  /**
-   * Search skills (direct SQL)
-   */
-  async searchSkills(
-    query: string,
-    options: {
-      k?: number;
-      minSuccessRate?: number;
-      sortBy?: 'success_rate' | 'avg_reward' | 'attempts';
-    } = {}
-  ): Promise<any[]> {
-    const { k = 5, minSuccessRate = 0.0, sortBy = 'success_rate' } = options;
-
-    const orderByMap = {
-      'success_rate': 'success_rate DESC',
-      'avg_reward': 'avg_confidence DESC',
-      'attempts': 'attempts DESC',
-    };
-
-    const stmt = this.db.prepare(`
-      SELECT
-        task_name as name,
-        outcome as description,
-        SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) * 1.0 / COUNT(*) as success_rate,
-        AVG(confidence) as avg_reward,
-        COUNT(*) as attempts,
-        MAX(timestamp) as last_used
-      FROM reflexion_episodes
-      WHERE task_name LIKE ? OR outcome LIKE ?
-      GROUP BY task_name
-      HAVING success_rate >= ?
-      ORDER BY ${orderByMap[sortBy]}
-      LIMIT ?
-    `);
-
-    return stmt.all(`%${query}%`, `%${query}%`, minSuccessRate, k);
-  }
-
-  /**
-   * Optimize database
-   */
-  async optimize(): Promise<void> {
-    console.error('🔧 Optimizing database...');
-    this.db.pragma('optimize');
-    this.db.pragma('wal_checkpoint(TRUNCATE)');
-    this.db.exec('VACUUM');
-    this.db.exec('ANALYZE');
-    console.error('✅ Database optimized');
-  }
-
-  /**
-   * Get performance metrics
-   */
-  getMetrics() {
-    return { ...this.performanceMetrics };
-  }
-
-  /**
-   * Get database statistics
-   */
-  async getStats(): Promise<any> {
-    const stats = this.db.prepare(`
-      SELECT
-        COUNT(*) as total_episodes,
-        SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) as successful_episodes,
-        SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) as failed_episodes,
-        COUNT(DISTINCT task_name) as unique_tasks,
-        AVG(confidence) as avg_confidence
-      FROM reflexion_episodes
-    `).get() || {};
-
-    return {
-      ...stats,
-      performance: this.performanceMetrics,
-      database: {
-        path: this.dbPath,
-        pageSize: this.db.pragma('page_size', { simple: true }),
-        pageCount: this.db.pragma('page_count', { simple: true }),
-        journalMode: this.db.pragma('journal_mode', { simple: true }),
-      },
-    };
-  }
-
-  async close(): Promise<void> {
-    if (this.db) {
-      this.db.close();
-    }
-    this.initialized = false;
-  }
-
-  // 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);
-  }
-}

package/src/index.ts

@@ -1,10 +0,0 @@
-/**
- * ROS3 MCP Server
- *
- * Exposes robotics operations as a simplified server
- * with AgentDB reflexion memory integration.
- */
-
-export { ROS3McpServer } from './server.js';
-export { ROS3Interface } from './interface.js';
-export { AgentDBMemory } from './memory.js';