@agentic-robotics/mcp 0.2.0 → 0.2.2

package/src/interface.ts

@@ -1,118 +0,0 @@
-/**
- * ROS3 Interface - Mock implementation for demonstration
- * In production, this would interface with the Rust native bindings
- */
-
-export interface Pose {
-  x: number;
-  y: number;
-  z: number;
-  roll: number;
-  pitch: number;
-  yaw: number;
-}
-
-export interface ObjectDetection {
-  class: string;
-  confidence: number;
-  bbox: [number, number, number, number];
-}
-
-export interface LidarData {
-  points: Array<{ x: number; y: number; z: number }>;
-  intensities: number[];
-  timestamp: number;
-}
-
-export class ROS3Interface {
-  constructor() {
-    // Initialize connection to ROS3 runtime
-    console.error('ROS3Interface initialized');
-  }
-
-  async moveToPose(
-    pose: Pose,
-    speed: number = 0.5,
-    frame: 'base' | 'world' = 'world'
-  ): Promise<void> {
-    console.error(`Moving to pose [${pose.x}, ${pose.y}, ${pose.z}] in ${frame} frame at speed ${speed}`);
-
-    // Simulate movement time
-    await new Promise(resolve => setTimeout(resolve, 100));
-  }
-
-  async getLidarData(
-    filter: 'all' | 'obstacles' | 'ground' = 'all',
-    maxPoints: number = 10000
-  ): Promise<LidarData> {
-    console.error(`Getting LIDAR data with filter: ${filter}, max points: ${maxPoints}`);
-
-    // Generate mock point cloud
-    const points = [];
-    const intensities = [];
-    const numPoints = Math.min(1000, maxPoints);
-
-    for (let i = 0; i < numPoints; i++) {
-      points.push({
-        x: Math.random() * 10 - 5,
-        y: Math.random() * 10 - 5,
-        z: Math.random() * 3,
-      });
-      intensities.push(Math.random());
-    }
-
-    return {
-      points,
-      intensities,
-      timestamp: Date.now(),
-    };
-  }
-
-  async detectObjects(
-    camera: 'front' | 'left' | 'right' | 'rear',
-    confidenceThreshold: number = 0.5
-  ): Promise<ObjectDetection[]> {
-    console.error(`Detecting objects from ${camera} camera with threshold ${confidenceThreshold}`);
-
-    // Generate mock detections
-    const classes = ['person', 'car', 'bicycle', 'traffic_light', 'stop_sign'];
-    const detections: ObjectDetection[] = [];
-
-    const numDetections = Math.floor(Math.random() * 5);
-    for (let i = 0; i < numDetections; i++) {
-      const confidence = Math.random() * 0.5 + 0.5;
-      if (confidence >= confidenceThreshold) {
-        detections.push({
-          class: classes[Math.floor(Math.random() * classes.length)],
-          confidence,
-          bbox: [
-            Math.random() * 640,
-            Math.random() * 480,
-            Math.random() * 200,
-            Math.random() * 200,
-          ],
-        });
-      }
-    }
-
-    return detections;
-  }
-
-  async getCurrentPose(): Promise<Pose> {
-    return {
-      x: 0,
-      y: 0,
-      z: 0,
-      roll: 0,
-      pitch: 0,
-      yaw: 0,
-    };
-  }
-
-  async getStatus(): Promise<{ status: string; health: string }> {
-    return {
-      status: 'operational',
-      health: 'good',
-    };
-  }
-}

package/src/memory.ts

@@ -1,315 +0,0 @@
-/**
- * AgentDB Reflexion Memory Integration
- *
- * Enables robot learning from past experiences with secure command execution
- * SECURITY: Uses spawn() with argument arrays to prevent command injection
- */
-
-import { spawn } from 'child_process';
-
-export interface Episode {
-  sessionId: string;
-  taskName: string;
-  confidence: number;
-  success: boolean;
-  outcome: string;
-  strategy?: string;
-  metadata?: Record<string, any>;
-}
-
-export interface Memory {
-  task: string;
-  confidence: number;
-  success: boolean;
-  outcome: string;
-  strategy?: string;
-  timestamp: number;
-}
-
-/**
- * Helper to safely spawn a command and capture output
- * Prevents command injection by using spawn with argument array
- */
-function spawnAsync(
-  command: string,
-  args: string[],
-  env?: Record<string, string>
-): Promise<{ stdout: string; stderr: string; code: number }> {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      env: { ...process.env, ...env },
-      shell: false, // Critical: disable shell interpretation
-    });
-
-    let stdout = '';
-    let stderr = '';
-
-    child.stdout?.on('data', (data) => {
-      stdout += data.toString();
-    });
-
-    child.stderr?.on('data', (data) => {
-      stderr += data.toString();
-    });
-
-    child.on('close', (code) => {
-      resolve({ stdout, stderr, code: code || 0 });
-    });
-
-    child.on('error', (error) => {
-      reject(error);
-    });
-  });
-}
-
-export class AgentDBMemory {
-  private dbPath: string;
-  private initialized: boolean = false;
-
-  constructor(dbPath: string) {
-    // Validate dbPath to prevent path traversal
-    if (!dbPath || dbPath.includes('..') || dbPath.includes(';') || dbPath.includes('|')) {
-      throw new Error('Invalid database path');
-    }
-    this.dbPath = dbPath;
-  }
-
-  async initialize(): Promise<void> {
-    if (this.initialized) return;
-
-    try {
-      // Initialize AgentDB database - use spawn with argument array for security
-      const { stdout, stderr, code } = await spawnAsync('npx', [
-        'agentdb',
-        'init',
-        this.dbPath,
-        '--dimension',
-        '768',
-        '--preset',
-        'medium',
-      ]);
-
-      if (code === 0 || stderr.includes('already exists')) {
-        console.error('AgentDB initialized:', this.dbPath);
-        this.initialized = true;
-      } else {
-        throw new Error(`Initialization failed: ${stderr}`);
-      }
-    } catch (error: any) {
-      // Database might already exist
-      if (error.message?.includes('already exists')) {
-        this.initialized = true;
-      } else {
-        throw new Error(`Failed to initialize AgentDB: ${error.message}`);
-      }
-    }
-  }
-
-  async storeEpisode(episode: Episode): Promise<void> {
-    if (!this.initialized) {
-      throw new Error('AgentDB not initialized. Call initialize() first.');
-    }
-
-    try {
-      // Use spawn with argument array to prevent command injection
-      const { code, stderr } = await spawnAsync(
-        'npx',
-        [
-          'agentdb',
-          'reflexion',
-          'store',
-          episode.sessionId,
-          episode.taskName,
-          episode.confidence.toString(),
-          episode.success.toString(),
-          episode.outcome || '',
-        ],
-        { AGENTDB_PATH: this.dbPath }
-      );
-
-      if (code !== 0) {
-        throw new Error(`Command failed: ${stderr}`);
-      }
-
-      console.error(`Stored episode: ${episode.taskName} (success: ${episode.success})`);
-    } catch (error: any) {
-      const errorMsg = `Failed to store episode "${episode.taskName}": ${error.message}`;
-      console.error('Error storing episode:', errorMsg);
-      throw new Error(errorMsg); // Throw instead of silently failing
-    }
-  }
-
-  async retrieveMemories(
-    query: string,
-    k: number = 5,
-    options: {
-      minReward?: number;
-      onlySuccesses?: boolean;
-      onlyFailures?: boolean;
-      synthesizeContext?: boolean;
-    } = {}
-  ): Promise<Memory[]> {
-    if (!this.initialized) {
-      throw new Error('AgentDB not initialized. Call initialize() first.');
-    }
-
-    // Build safe argument array
-    const args = ['agentdb', 'reflexion', 'retrieve', query, '--k', k.toString()];
-
-    if (options.minReward !== undefined) {
-      args.push('--min-reward', options.minReward.toString());
-    }
-    if (options.onlySuccesses) {
-      args.push('--only-successes');
-    }
-    if (options.onlyFailures) {
-      args.push('--only-failures');
-    }
-    if (options.synthesizeContext) {
-      args.push('--synthesize-context');
-    }
-
-    try {
-      const { stdout, code, stderr } = await spawnAsync('npx', args, {
-        AGENTDB_PATH: this.dbPath,
-      });
-
-      if (code !== 0) {
-        throw new Error(`Command failed: ${stderr}`);
-      }
-
-      // Parse JSON output
-      const lines = stdout.trim().split('\n');
-      const jsonLine = lines.find((line) => line.startsWith('[') || line.startsWith('{'));
-
-      if (jsonLine) {
-        const data = JSON.parse(jsonLine);
-        return Array.isArray(data) ? data : [data];
-      }
-
-      return [];
-    } catch (error: any) {
-      // Throw error instead of silently returning empty array
-      throw new Error(`Failed to retrieve memories for query "${query}": ${error.message}`);
-    }
-  }
-
-  async queryWithContext(
-    query: string,
-    options: {
-      k?: number;
-      minConfidence?: number;
-      domain?: string;
-    } = {}
-  ): Promise<{ memories: Memory[]; context?: string }> {
-    if (!this.initialized) {
-      throw new Error('AgentDB not initialized. Call initialize() first.');
-    }
-
-    const { k = 5, minConfidence = 0.0, domain } = options;
-
-    // Build safe argument array
-    const args = [
-      'agentdb',
-      'query',
-      '--query',
-      query,
-      '--k',
-      k.toString(),
-      '--min-confidence',
-      minConfidence.toString(),
-    ];
-
-    if (domain) {
-      args.push('--domain', domain);
-    }
-
-    args.push('--synthesize-context', '--format', 'json');
-
-    try {
-      const { stdout, code, stderr } = await spawnAsync('npx', args, {
-        AGENTDB_PATH: this.dbPath,
-      });
-
-      if (code !== 0) {
-        throw new Error(`Command failed: ${stderr}`);
-      }
-
-      const lines = stdout.trim().split('\n');
-      const jsonLine = lines.find((line) => line.startsWith('[') || line.startsWith('{'));
-
-      if (jsonLine) {
-        const data = JSON.parse(jsonLine);
-        return {
-          memories: Array.isArray(data) ? data : [data],
-          context: data.context || data.summary,
-        };
-      }
-
-      return { memories: [] };
-    } catch (error: any) {
-      // Throw error instead of silently returning empty array
-      throw new Error(`Failed to query with context "${query}": ${error.message}`);
-    }
-  }
-
-  async consolidateSkills(options: {
-    minAttempts?: number;
-    minReward?: number;
-    timeWindowDays?: number;
-  } = {}): Promise<void> {
-    if (!this.initialized) {
-      throw new Error('AgentDB not initialized. Call initialize() first.');
-    }
-
-    const { minAttempts = 3, minReward = 0.7, timeWindowDays = 7 } = options;
-
-    try {
-      const { code, stderr } = await spawnAsync(
-        'npx',
-        [
-          'agentdb',
-          'skill',
-          'consolidate',
-          minAttempts.toString(),
-          minReward.toString(),
-          timeWindowDays.toString(),
-          'true',
-        ],
-        { AGENTDB_PATH: this.dbPath }
-      );
-
-      if (code !== 0) {
-        throw new Error(`Command failed: ${stderr}`);
-      }
-
-      console.error('Skills consolidated from successful episodes');
-    } catch (error: any) {
-      throw new Error(`Failed to consolidate skills: ${error.message}`);
-    }
-  }
-
-  async getStats(): Promise<any> {
-    if (!this.initialized) {
-      throw new Error('AgentDB not initialized. Call initialize() first.');
-    }
-
-    try {
-      const { stdout, code, stderr } = await spawnAsync('npx', ['agentdb', 'db', 'stats'], {
-        AGENTDB_PATH: this.dbPath,
-      });
-
-      if (code !== 0) {
-        throw new Error(`Command failed: ${stderr}`);
-      }
-
-      return { stats: stdout.trim() };
-    } catch (error: any) {
-      throw new Error(`Failed to get stats: ${error.message}`);
-    }
-  }
-
-  async close(): Promise<void> {
-    this.initialized = false;
-  }
-}

package/src/server.ts

@@ -1,213 +0,0 @@
-/**
- * ROS3 MCP Server implementation - Simplified version
- */
-
-import { ROS3Interface } from './interface.js';
-import { AgentDBMemory } from './memory.js';
-
-export interface ROS3McpServerConfig {
-  name?: string;
-  version?: string;
-  dbPath?: string;
-}
-
-export class ROS3McpServer {
-  private ros3: ROS3Interface;
-  private memory: AgentDBMemory;
-  private name: string;
-  private version: string;
-
-  constructor(config: ROS3McpServerConfig = {}) {
-    const {
-      name = 'ros3-mcp-server',
-      version = '1.0.0',
-      dbPath = './ros3-agentdb.db',
-    } = config;
-
-    this.name = name;
-    this.version = version;
-
-    // Initialize ROS3 interface
-    this.ros3 = new ROS3Interface();
-
-    // Initialize AgentDB memory
-    this.memory = new AgentDBMemory(dbPath);
-  }
-
-  async start(): Promise<void> {
-    // Initialize AgentDB
-    await this.memory.initialize();
-
-    console.error(`${this.name} v${this.version} started`);
-    console.error('AgentDB initialized and ready');
-    console.error('');
-    console.error('Available tools:');
-    console.error('  - move_robot: Move robot to target pose');
-    console.error('  - get_pose: Get current robot pose');
-    console.error('  - get_status: Get robot status');
-    console.error('  - read_lidar: Read LIDAR data');
-    console.error('  - detect_objects: Detect objects from camera');
-    console.error('  - query_memory: Query past experiences');
-    console.error('  - consolidate_skills: Learn from experiences');
-    console.error('  - get_memory_stats: Get memory statistics');
-  }
-
-  async stop(): Promise<void> {
-    await this.memory.close();
-    console.error(`${this.name} stopped`);
-  }
-
-  // Tool implementations
-  async moveRobot(params: {
-    x: number;
-    y: number;
-    z: number;
-    roll: number;
-    pitch: number;
-    yaw: number;
-    speed?: number;
-    frame?: 'base' | 'world';
-  }): Promise<string> {
-    const { x, y, z, roll, pitch, yaw, speed = 0.5, frame = 'world' } = params;
-    const startTime = Date.now();
-
-    try {
-      await this.ros3.moveToPose({ x, y, z, roll, pitch, yaw }, speed, frame);
-      const latency = Date.now() - startTime;
-
-      await this.memory.storeEpisode({
-        sessionId: `motion-${Date.now()}`,
-        taskName: 'move_robot',
-        confidence: 0.9,
-        success: true,
-        outcome: `Moved to [${x}, ${y}, ${z}] in ${latency}ms`,
-        strategy: `speed_${speed}_frame_${frame}`,
-        metadata: { x, y, z, roll, pitch, yaw, speed, frame, latency },
-      });
-
-      return `Robot moved to [${x}, ${y}, ${z}] in ${frame} frame. Completed in ${latency}ms.`;
-    } catch (error: any) {
-      await this.memory.storeEpisode({
-        sessionId: `motion-${Date.now()}`,
-        taskName: 'move_robot',
-        confidence: 0.0,
-        success: false,
-        outcome: `Failed: ${error.message}`,
-        metadata: { x, y, z, roll, pitch, yaw, speed, frame },
-      });
-      throw error;
-    }
-  }
-
-  async getPose(): Promise<string> {
-    const pose = await this.ros3.getCurrentPose();
-    return `Current pose: [${pose.x}, ${pose.y}, ${pose.z}] (roll=${pose.roll}, pitch=${pose.pitch}, yaw=${pose.yaw})`;
-  }
-
-  async getStatus(): Promise<string> {
-    const status = await this.ros3.getStatus();
-    return `Robot status: ${status.status}, Health: ${status.health}`;
-  }
-
-  async readLidar(params: { filter?: string; max_points?: number }): Promise<string> {
-    const { filter = 'all', max_points = 10000 } = params;
-    const startTime = Date.now();
-
-    const cloud = await this.ros3.getLidarData(
-      filter as 'all' | 'obstacles' | 'ground',
-      max_points
-    );
-
-    const latency = Date.now() - startTime;
-
-    await this.memory.storeEpisode({
-      sessionId: `lidar-${Date.now()}`,
-      taskName: 'read_lidar',
-      confidence: 1.0,
-      success: true,
-      outcome: `Retrieved ${cloud.points.length} points in ${latency}ms`,
-      metadata: { filter, max_points, num_points: cloud.points.length, latency },
-    });
-
-    return `LIDAR data: ${cloud.points.length} points (filter: ${filter}, latency: ${latency}ms)`;
-  }
-
-  async detectObjects(params: { camera: string; confidence_threshold?: number }): Promise<string> {
-    const { camera, confidence_threshold = 0.5 } = params;
-    const startTime = Date.now();
-
-    const detections = await this.ros3.detectObjects(
-      camera as 'front' | 'left' | 'right' | 'rear',
-      confidence_threshold
-    );
-
-    const latency = Date.now() - startTime;
-
-    await this.memory.storeEpisode({
-      sessionId: `vision-${Date.now()}`,
-      taskName: 'detect_objects',
-      confidence: 0.9,
-      success: true,
-      outcome: `Detected ${detections.length} objects in ${latency}ms`,
-      metadata: { camera, confidence_threshold, num_detections: detections.length, latency },
-    });
-
-    return `Detected ${detections.length} objects from ${camera} camera:\n${JSON.stringify(detections, null, 2)}`;
-  }
-
-  async queryMemory(params: {
-    query: string;
-    k?: number;
-    only_successes?: boolean;
-    min_confidence?: number;
-  }): Promise<string> {
-    const { query, k = 5, only_successes = false, min_confidence = 0.0 } = params;
-
-    const result = await this.memory.queryWithContext(query, { k, minConfidence: min_confidence });
-
-    const filteredMemories = only_successes
-      ? result.memories.filter((m) => m.success)
-      : result.memories;
-
-    return `Found ${filteredMemories.length} memories for "${query}":\n${JSON.stringify(filteredMemories, null, 2)}`;
-  }
-
-  async consolidateSkills(params?: {
-    min_attempts?: number;
-    min_reward?: number;
-    time_window_days?: number;
-  }): Promise<string> {
-    const { min_attempts = 3, min_reward = 0.7, time_window_days = 7 } = params || {};
-
-    await this.memory.consolidateSkills({
-      minAttempts: min_attempts,
-      minReward: min_reward,
-      timeWindowDays: time_window_days,
-    });
-
-    return `Skills consolidated (min_attempts: ${min_attempts}, min_reward: ${min_reward}, window: ${time_window_days} days)`;
-  }
-
-  async getMemoryStats(): Promise<string> {
-    const stats = await this.memory.getStats();
-    return `AgentDB Statistics:\n${stats.stats}`;
-  }
-
-  // Get server info
-  getInfo() {
-    return {
-      name: this.name,
-      version: this.version,
-      tools: [
-        'move_robot',
-        'get_pose',
-        'get_status',
-        'read_lidar',
-        'detect_objects',
-        'query_memory',
-        'consolidate_skills',
-        'get_memory_stats',
-      ],
-    };
-  }
-}

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ES2022",
-    "lib": ["ES2022"],
-    "moduleResolution": "node",
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "resolveJsonModule": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}