@agentic-robotics/mcp 0.1.3 → 0.2.1

package/src/flow-orchestrator.ts

@@ -1,415 +0,0 @@
-/**
- * Agentic Flow Orchestration Integration
- *
- * Integrates agentic-flow's 66 agents and 213 MCP tools for
- * multi-robot coordination and complex task execution
- */
-
-import { spawn } from 'child_process';
-import { promisify } from 'util';
-import { exec } from 'child_process';
-
-const execAsync = promisify(exec);
-
-export interface AgentTask {
-  id: string;
-  type: string;
-  priority: 'low' | 'medium' | 'high' | 'critical';
-  params: Record<string, any>;
-  timeout?: number;
-  retries?: number;
-}
-
-export interface AgentResult {
-  taskId: string;
-  success: boolean;
-  result: any;
-  executionTime: number;
-  agentsUsed: string[];
-  toolsUsed: string[];
-  reasoning?: string;
-}
-
-export interface SwarmConfig {
-  numAgents?: number;
-  strategy?: 'parallel' | 'sequential' | 'adaptive' | 'swarm';
-  mcpTools?: string[];
-  reasoningEnabled?: boolean;
-  learningEnabled?: boolean;
-}
-
-export interface OrchestrationMetrics {
-  totalTasks: number;
-  successfulTasks: number;
-  failedTasks: number;
-  avgExecutionTime: number;
-  agentUtilization: Record<string, number>;
-  toolUsage: Record<string, number>;
-}
-
-export class FlowOrchestrator {
-  private config: SwarmConfig;
-  private metrics: OrchestrationMetrics;
-  private initialized: boolean = false;
-
-  constructor(config: SwarmConfig = {}) {
-    this.config = {
-      numAgents: config.numAgents || 66,
-      strategy: config.strategy || 'adaptive',
-      mcpTools: config.mcpTools || [],
-      reasoningEnabled: config.reasoningEnabled ?? true,
-      learningEnabled: config.learningEnabled ?? true,
-    };
-
-    this.metrics = {
-      totalTasks: 0,
-      successfulTasks: 0,
-      failedTasks: 0,
-      avgExecutionTime: 0,
-      agentUtilization: {},
-      toolUsage: {},
-    };
-  }
-
-  async initialize(): Promise<void> {
-    if (this.initialized) return;
-
-    const startTime = Date.now();
-
-    try {
-      // Initialize agentic-flow with configuration
-      const cmd = [
-        'npx agentic-flow init',
-        `--agents ${this.config.numAgents}`,
-        `--strategy ${this.config.strategy}`,
-        this.config.reasoningEnabled ? '--enable-reasoning' : '',
-        this.config.learningEnabled ? '--enable-learning' : '',
-      ].filter(Boolean).join(' ');
-
-      await execAsync(cmd);
-
-      const initTime = Date.now() - startTime;
-      console.error(`🌊 Agentic Flow initialized (${this.config.numAgents} agents, ${initTime}ms)`);
-      this.initialized = true;
-    } catch (error: any) {
-      console.error('⚠️ Flow initialization warning:', error.message);
-      this.initialized = true;
-    }
-  }
-
-  /**
-   * Execute a single task using agentic-flow orchestration
-   */
-  async executeTask(task: AgentTask): Promise<AgentResult> {
-    const startTime = Date.now();
-    this.metrics.totalTasks++;
-
-    try {
-      const cmd = [
-        'npx agentic-flow execute',
-        `--task-type "${task.type}"`,
-        `--priority ${task.priority}`,
-        `--params '${JSON.stringify(task.params)}'`,
-        task.timeout ? `--timeout ${task.timeout}` : '',
-        task.retries ? `--retries ${task.retries}` : '',
-        this.config.reasoningEnabled ? '--enable-reasoning' : '',
-        '--format json',
-      ].filter(Boolean).join(' ');
-
-      const { stdout } = await execAsync(cmd, { timeout: task.timeout || 30000 });
-
-      const lines = stdout.trim().split('\n');
-      const jsonLine = lines.find(line => line.startsWith('{'));
-
-      if (jsonLine) {
-        const data = JSON.parse(jsonLine);
-
-        const executionTime = Date.now() - startTime;
-        this.metrics.successfulTasks++;
-        this.updateMetrics(data, executionTime);
-
-        console.error(`✅ Task ${task.id} completed in ${executionTime}ms`);
-
-        return {
-          taskId: task.id,
-          success: true,
-          result: data.result,
-          executionTime,
-          agentsUsed: data.agents_used || [],
-          toolsUsed: data.tools_used || [],
-          reasoning: data.reasoning,
-        };
-      }
-
-      throw new Error('No valid JSON response from agentic-flow');
-    } catch (error: any) {
-      this.metrics.failedTasks++;
-      const executionTime = Date.now() - startTime;
-
-      console.error(`❌ Task ${task.id} failed: ${error.message}`);
-
-      return {
-        taskId: task.id,
-        success: false,
-        result: { error: error.message },
-        executionTime,
-        agentsUsed: [],
-        toolsUsed: [],
-      };
-    }
-  }
-
-  /**
-   * Execute multiple tasks in parallel using swarm intelligence
-   */
-  async executeSwarm(tasks: AgentTask[]): Promise<AgentResult[]> {
-    const startTime = Date.now();
-
-    console.error(`🐝 Executing swarm with ${tasks.length} tasks`);
-
-    try {
-      // Use agentic-flow's swarm coordination
-      const tasksJson = JSON.stringify(tasks);
-      const cmd = [
-        'npx agentic-flow swarm',
-        `--tasks '${tasksJson}'`,
-        `--strategy ${this.config.strategy}`,
-        `--num-agents ${this.config.numAgents}`,
-        this.config.reasoningEnabled ? '--enable-reasoning' : '',
-        '--format json',
-      ].filter(Boolean).join(' ');
-
-      const { stdout } = await execAsync(cmd, { timeout: 60000 });
-
-      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 swarmTime = Date.now() - startTime;
-        console.error(`🎯 Swarm completed ${results.length} tasks in ${swarmTime}ms`);
-
-        return results.map((r, i) => ({
-          taskId: tasks[i].id,
-          success: r.success ?? true,
-          result: r.result,
-          executionTime: r.execution_time || swarmTime / results.length,
-          agentsUsed: r.agents_used || [],
-          toolsUsed: r.tools_used || [],
-          reasoning: r.reasoning,
-        }));
-      }
-
-      throw new Error('No valid JSON response from swarm execution');
-    } catch (error: any) {
-      console.error(`❌ Swarm execution failed: ${error.message}`);
-
-      // Return individual failures
-      return tasks.map(task => ({
-        taskId: task.id,
-        success: false,
-        result: { error: error.message },
-        executionTime: 0,
-        agentsUsed: [],
-        toolsUsed: [],
-      }));
-    }
-  }
-
-  /**
-   * Coordinate multiple robots using agentic-flow
-   */
-  async coordinateRobots(
-    robots: string[],
-    mission: {
-      type: string;
-      objectives: string[];
-      constraints?: Record<string, any>;
-    }
-  ): Promise<{
-    success: boolean;
-    assignments: Record<string, string[]>;
-    executionPlan: any;
-    estimatedTime: number;
-  }> {
-    const startTime = Date.now();
-
-    try {
-      const cmd = [
-        'npx agentic-flow coordinate',
-        `--robots '${JSON.stringify(robots)}'`,
-        `--mission-type "${mission.type}"`,
-        `--objectives '${JSON.stringify(mission.objectives)}'`,
-        mission.constraints ? `--constraints '${JSON.stringify(mission.constraints)}'` : '',
-        '--format json',
-      ].filter(Boolean).join(' ');
-
-      const { stdout } = await execAsync(cmd, { timeout: 30000 });
-
-      const lines = stdout.trim().split('\n');
-      const jsonLine = lines.find(line => line.startsWith('{'));
-
-      if (jsonLine) {
-        const data = JSON.parse(jsonLine);
-
-        const coordTime = Date.now() - startTime;
-        console.error(`🤝 Robot coordination completed in ${coordTime}ms`);
-
-        return {
-          success: true,
-          assignments: data.assignments || {},
-          executionPlan: data.execution_plan || {},
-          estimatedTime: data.estimated_time || 0,
-        };
-      }
-
-      throw new Error('No valid JSON response from coordination');
-    } catch (error: any) {
-      console.error(`❌ Coordination failed: ${error.message}`);
-
-      return {
-        success: false,
-        assignments: {},
-        executionPlan: {},
-        estimatedTime: 0,
-      };
-    }
-  }
-
-  /**
-   * Use ReasoningBank for complex decision making
-   */
-  async reasonAboutTask(
-    context: string,
-    options: {
-      useMemory?: boolean;
-      synthesizeStrategy?: boolean;
-      explainReasoning?: boolean;
-    } = {}
-  ): Promise<{
-    decision: string;
-    reasoning: string;
-    confidence: number;
-    alternatives: string[];
-  }> {
-    const startTime = Date.now();
-
-    try {
-      const cmd = [
-        'npx agentic-flow reason',
-        `--context "${context}"`,
-        options.useMemory ? '--use-memory' : '',
-        options.synthesizeStrategy ? '--synthesize-strategy' : '',
-        options.explainReasoning ? '--explain-reasoning' : '',
-        '--format json',
-      ].filter(Boolean).join(' ');
-
-      const { stdout } = await execAsync(cmd, { timeout: 15000 });
-
-      const lines = stdout.trim().split('\n');
-      const jsonLine = lines.find(line => line.startsWith('{'));
-
-      if (jsonLine) {
-        const data = JSON.parse(jsonLine);
-
-        const reasonTime = Date.now() - startTime;
-        console.error(`🧠 Reasoning completed in ${reasonTime}ms`);
-
-        return {
-          decision: data.decision || '',
-          reasoning: data.reasoning || '',
-          confidence: data.confidence || 0,
-          alternatives: data.alternatives || [],
-        };
-      }
-
-      throw new Error('No valid JSON response from reasoning');
-    } catch (error: any) {
-      console.error(`❌ Reasoning failed: ${error.message}`);
-
-      return {
-        decision: '',
-        reasoning: error.message,
-        confidence: 0,
-        alternatives: [],
-      };
-    }
-  }
-
-  /**
-   * Get available MCP tools from agentic-flow
-   */
-  async getAvailableTools(): Promise<string[]> {
-    try {
-      const { stdout } = await execAsync('npx agentic-flow list-tools --format json');
-
-      const lines = stdout.trim().split('\n');
-      const jsonLine = lines.find(line => line.startsWith('['));
-
-      if (jsonLine) {
-        const tools = JSON.parse(jsonLine);
-        console.error(`🔧 Found ${tools.length}/213 MCP tools available`);
-        return tools;
-      }
-
-      return [];
-    } catch (error: any) {
-      console.error('⚠️ Could not list tools:', error.message);
-      return [];
-    }
-  }
-
-  /**
-   * Get metrics and statistics
-   */
-  getMetrics(): OrchestrationMetrics {
-    return {
-      ...this.metrics,
-      avgExecutionTime: this.metrics.totalTasks > 0
-        ? this.metrics.avgExecutionTime / this.metrics.totalTasks
-        : 0,
-    };
-  }
-
-  /**
-   * Update internal metrics
-   */
-  private updateMetrics(data: any, executionTime: number): void {
-    // Update execution time
-    this.metrics.avgExecutionTime += executionTime;
-
-    // Track agent utilization
-    if (data.agents_used) {
-      for (const agent of data.agents_used) {
-        this.metrics.agentUtilization[agent] = (this.metrics.agentUtilization[agent] || 0) + 1;
-      }
-    }
-
-    // Track tool usage
-    if (data.tools_used) {
-      for (const tool of data.tools_used) {
-        this.metrics.toolUsage[tool] = (this.metrics.toolUsage[tool] || 0) + 1;
-      }
-    }
-  }
-
-  /**
-   * Reset metrics
-   */
-  resetMetrics(): void {
-    this.metrics = {
-      totalTasks: 0,
-      successfulTasks: 0,
-      failedTasks: 0,
-      avgExecutionTime: 0,
-      agentUtilization: {},
-      toolUsage: {},
-    };
-  }
-
-  async close(): Promise<void> {
-    this.initialized = false;
-  }
-}

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();
-  }
-}