0xray 2.0.0

package/src/mcps/simulation/__tests__/simulation-engine.test.ts

@@ -0,0 +1,275 @@
+/**
+ * Simulation Engine Tests
+ *
+ * Comprehensive test suite for the SimulationEngine class.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { SimulationEngine, SimulatorFunction } from '../simulation-engine.js';
+import { MCPToolResult } from '../../types/index.js';
+
+describe('SimulationEngine', () => {
+  let engine: SimulationEngine;
+
+  beforeEach(() => {
+    engine = new SimulationEngine();
+  });
+
+  describe('registerSimulator', () => {
+    it('should register a simulator', () => {
+      const simulator: SimulatorFunction = () => ({
+        content: [{ type: 'text', text: 'Test' }],
+      });
+
+      engine.registerSimulator('server1', 'tool1', simulator);
+
+      expect(engine.canSimulate('server1', 'tool1')).toBe(true);
+    });
+
+    it('should allow multiple simulators per server', () => {
+      engine.registerSimulator('server1', 'tool1', () => ({
+        content: [{ type: 'text', text: 'Tool 1' }],
+      }));
+      engine.registerSimulator('server1', 'tool2', () => ({
+        content: [{ type: 'text', text: 'Tool 2' }],
+      }));
+
+      expect(engine.canSimulate('server1', 'tool1')).toBe(true);
+      expect(engine.canSimulate('server1', 'tool2')).toBe(true);
+    });
+
+    it('should allow same tool name on different servers', () => {
+      engine.registerSimulator('server1', 'tool1', () => ({
+        content: [{ type: 'text', text: 'Server 1' }],
+      }));
+      engine.registerSimulator('server2', 'tool1', () => ({
+        content: [{ type: 'text', text: 'Server 2' }],
+      }));
+
+      expect(engine.canSimulate('server1', 'tool1')).toBe(true);
+      expect(engine.canSimulate('server2', 'tool1')).toBe(true);
+    });
+  });
+
+  describe('registerServerSimulators', () => {
+    it('should register multiple simulators at once', () => {
+      const simulators: Record<string, SimulatorFunction> = {
+        tool1: () => ({ content: [{ type: 'text', text: 'Tool 1' }] }),
+        tool2: () => ({ content: [{ type: 'text', text: 'Tool 2' }] }),
+        tool3: () => ({ content: [{ type: 'text', text: 'Tool 3' }] }),
+      };
+
+      engine.registerServerSimulators('server1', simulators);
+
+      expect(engine.canSimulate('server1', 'tool1')).toBe(true);
+      expect(engine.canSimulate('server1', 'tool2')).toBe(true);
+      expect(engine.canSimulate('server1', 'tool3')).toBe(true);
+    });
+  });
+
+  describe('canSimulate', () => {
+    it('should return true for registered simulator', () => {
+      engine.registerSimulator('server1', 'tool1', () => ({
+        content: [{ type: 'text', text: 'Test' }],
+      }));
+
+      expect(engine.canSimulate('server1', 'tool1')).toBe(true);
+    });
+
+    it('should return false for unregistered tool', () => {
+      engine.registerSimulator('server1', 'tool1', () => ({
+        content: [{ type: 'text', text: 'Test' }],
+      }));
+
+      expect(engine.canSimulate('server1', 'tool2')).toBe(false);
+    });
+
+    it('should return false for unregistered server', () => {
+      expect(engine.canSimulate('nonexistent', 'tool1')).toBe(false);
+    });
+  });
+
+  describe('simulate', () => {
+    it('should execute simulator and return result', async () => {
+      const mockResult: MCPToolResult = {
+        content: [{ type: 'text', text: 'Simulated Result' }],
+      };
+
+      engine.registerSimulator('server1', 'tool1', () => mockResult);
+
+      const result = await engine.simulate('server1', 'tool1', {});
+
+      expect(result).toEqual(mockResult);
+    });
+
+    it('should pass args to simulator', async () => {
+      const simulator = vi.fn().mockReturnValue({
+        content: [{ type: 'text', text: 'Test' }],
+      });
+
+      engine.registerSimulator('server1', 'tool1', simulator);
+      await engine.simulate('server1', 'tool1', { key: 'value' });
+
+      expect(simulator).toHaveBeenCalledWith({ key: 'value' });
+    });
+
+    it('should handle async simulators', async () => {
+      const mockResult: MCPToolResult = {
+        content: [{ type: 'text', text: 'Async Result' }],
+      };
+
+      engine.registerSimulator('server1', 'tool1', async () => mockResult);
+
+      const result = await engine.simulate('server1', 'tool1', {});
+
+      expect(result).toEqual(mockResult);
+    });
+
+    it('should throw error for unregistered simulator', async () => {
+      await expect(engine.simulate('server1', 'tool1', {})).rejects.toThrow(
+        'No simulator registered for server1/tool1'
+      );
+    });
+  });
+
+  describe('getServerTools', () => {
+    it('should return all tool names for a server', () => {
+      engine.registerSimulator('server1', 'tool1', () => ({
+        content: [{ type: 'text', text: 'Test' }],
+      }));
+      engine.registerSimulator('server1', 'tool2', () => ({
+        content: [{ type: 'text', text: 'Test' }],
+      }));
+
+      const tools = engine.getServerTools('server1');
+
+      expect(tools).toContain('tool1');
+      expect(tools).toContain('tool2');
+      expect(tools).toHaveLength(2);
+    });
+
+    it('should return empty array for unregistered server', () => {
+      expect(engine.getServerTools('nonexistent')).toEqual([]);
+    });
+  });
+
+  describe('getRegisteredServers', () => {
+    it('should return all registered server names', () => {
+      engine.registerSimulator('server1', 'tool1', () => ({
+        content: [{ type: 'text', text: 'Test' }],
+      }));
+      engine.registerSimulator('server2', 'tool1', () => ({
+        content: [{ type: 'text', text: 'Test' }],
+      }));
+
+      const servers = engine.getRegisteredServers();
+
+      expect(servers).toContain('server1');
+      expect(servers).toContain('server2');
+      expect(servers).toHaveLength(2);
+    });
+
+    it('should return empty array when no servers registered', () => {
+      expect(engine.getRegisteredServers()).toEqual([]);
+    });
+  });
+
+  describe('unregisterSimulator', () => {
+    it('should remove specific simulator', () => {
+      engine.registerSimulator('server1', 'tool1', () => ({
+        content: [{ type: 'text', text: 'Test' }],
+      }));
+
+      const result = engine.unregisterSimulator('server1', 'tool1');
+
+      expect(result).toBe(true);
+      expect(engine.canSimulate('server1', 'tool1')).toBe(false);
+    });
+
+    it('should return false for non-existent tool', () => {
+      engine.registerSimulator('server1', 'tool1', () => ({
+        content: [{ type: 'text', text: 'Test' }],
+      }));
+
+      const result = engine.unregisterSimulator('server1', 'tool2');
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false for non-existent server', () => {
+      const result = engine.unregisterSimulator('nonexistent', 'tool1');
+
+      expect(result).toBe(false);
+    });
+
+    it('should clean up empty server entries', () => {
+      engine.registerSimulator('server1', 'tool1', () => ({
+        content: [{ type: 'text', text: 'Test' }],
+      }));
+
+      engine.unregisterSimulator('server1', 'tool1');
+
+      expect(engine.getRegisteredServers()).toEqual([]);
+    });
+  });
+
+  describe('unregisterServer', () => {
+    it('should remove all simulators for a server', () => {
+      engine.registerSimulator('server1', 'tool1', () => ({
+        content: [{ type: 'text', text: 'Test' }],
+      }));
+      engine.registerSimulator('server1', 'tool2', () => ({
+        content: [{ type: 'text', text: 'Test' }],
+      }));
+
+      const result = engine.unregisterServer('server1');
+
+      expect(result).toBe(true);
+      expect(engine.canSimulate('server1', 'tool1')).toBe(false);
+      expect(engine.canSimulate('server1', 'tool2')).toBe(false);
+    });
+
+    it('should return false for non-existent server', () => {
+      const result = engine.unregisterServer('nonexistent');
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('clear', () => {
+    it('should remove all simulators', () => {
+      engine.registerSimulator('server1', 'tool1', () => ({
+        content: [{ type: 'text', text: 'Test' }],
+      }));
+      engine.registerSimulator('server2', 'tool1', () => ({
+        content: [{ type: 'text', text: 'Test' }],
+      }));
+
+      engine.clear();
+
+      expect(engine.getRegisteredServers()).toEqual([]);
+      expect(engine.canSimulate('server1', 'tool1')).toBe(false);
+      expect(engine.canSimulate('server2', 'tool1')).toBe(false);
+    });
+  });
+
+  describe('getSimulatorCount', () => {
+    it('should return total count of simulators', () => {
+      engine.registerSimulator('server1', 'tool1', () => ({
+        content: [{ type: 'text', text: 'Test' }],
+      }));
+      engine.registerSimulator('server1', 'tool2', () => ({
+        content: [{ type: 'text', text: 'Test' }],
+      }));
+      engine.registerSimulator('server2', 'tool1', () => ({
+        content: [{ type: 'text', text: 'Test' }],
+      }));
+
+      expect(engine.getSimulatorCount()).toBe(3);
+    });
+
+    it('should return 0 when no simulators registered', () => {
+      expect(engine.getSimulatorCount()).toBe(0);
+    });
+  });
+});

package/src/mcps/simulation/index.ts

@@ -0,0 +1,23 @@
+/**
+ * Simulation Module Barrel Export
+ *
+ * Centralized export for all MCP simulation functionality.
+ *
+ * @example
+ * ```typescript
+ * import { SimulationEngine, getAllServerSimulations } from './simulation/index.js';
+ * ```
+ */
+
+export { SimulationEngine, type SimulatorFunction } from './simulation-engine.js';
+export {
+  getAllServerSimulations,
+  codeReviewSimulations,
+  securityAuditSimulations,
+  performanceOptimizationSimulations,
+  testingStrategySimulations,
+  researcherSimulations,
+  frameworkHelpSimulations,
+  skillInvocationSimulations,
+  type ServerSimulations,
+} from './server-simulations.js';

package/src/mcps/simulation/server-simulations.ts

@@ -0,0 +1,241 @@
+/**
+ * Server Simulations
+ *
+ * Pre-built simulation implementations for all MCP servers.
+ * Extracted from mcp-client.ts as part of Phase 5 refactoring.
+ */
+
+import { MCPToolResult } from '../types/index.js';
+import { SimulatorFunction } from './simulation-engine.js';
+
+export interface ServerSimulations {
+  [serverName: string]: Record<string, SimulatorFunction>;
+}
+
+/**
+ * Code Review server simulations
+ */
+export const codeReviewSimulations: Record<string, SimulatorFunction> = {
+  analyze_code_quality: (): MCPToolResult => ({
+    content: [
+      {
+        type: 'text',
+        text: `Code Review Analysis Complete:\n- Quality Score: ${Math.floor(Math.random() * 20) + 80}/100\n- Issues Found: ${Math.floor(Math.random() * 5)}\n- Recommendations: ${Math.floor(Math.random() * 3) + 1} improvements suggested`,
+      },
+    ],
+  }),
+};
+
+/**
+ * Security Audit server simulations
+ */
+export const securityAuditSimulations: Record<string, SimulatorFunction> = {
+  scan_vulnerabilities: (): MCPToolResult => ({
+    content: [
+      {
+        type: 'text',
+        text: `Security Audit Complete:\n- Vulnerabilities Found: ${Math.floor(Math.random() * 3)}\n- Severity: ${['Low', 'Medium', 'High'][Math.floor(Math.random() * 3)]}\n- Compliance: ${Math.random() > 0.3 ? 'Passed' : 'Failed'}`,
+      },
+    ],
+  }),
+};
+
+/**
+ * Performance Optimization server simulations
+ */
+export const performanceOptimizationSimulations: Record<string, SimulatorFunction> = {
+  analyze_performance: (): MCPToolResult => ({
+    content: [
+      {
+        type: 'text',
+        text: `Performance Analysis Complete:\n- Bottlenecks Identified: ${Math.floor(Math.random() * 3)}\n- Optimization Potential: ${Math.floor(Math.random() * 30) + 10}%\n- Recommendations: ${Math.floor(Math.random() * 4) + 2} improvements`,
+      },
+    ],
+  }),
+};
+
+/**
+ * Testing Strategy server simulations
+ */
+export const testingStrategySimulations: Record<string, SimulatorFunction> = {
+  analyze_test_coverage: (): MCPToolResult => ({
+    content: [
+      {
+        type: 'text',
+        text: `Testing Strategy Analysis:\n- Coverage: ${Math.floor(Math.random() * 40) + 60}%\n- Gaps Identified: ${Math.floor(Math.random() * 5)}\n- Test Cases Recommended: ${Math.floor(Math.random() * 10) + 5}`,
+      },
+    ],
+  }),
+};
+
+/**
+ * Researcher server simulations
+ */
+export const researcherSimulations: Record<string, SimulatorFunction> = {
+  analyze_codebase: (): MCPToolResult => ({
+    content: [
+      {
+        type: 'text',
+        text: `Codebase Analysis Complete:\n- Files Analyzed: ${Math.floor(Math.random() * 500) + 100}\n- Languages Detected: ${Math.floor(Math.random() * 3) + 2}\n- Complexity Score: ${Math.floor(Math.random() * 50) + 50}/100\n- Architecture Patterns: ${Math.floor(Math.random() * 5) + 3} identified`,
+      },
+    ],
+  }),
+};
+
+/**
+ * Framework Help server simulations
+ */
+export const frameworkHelpSimulations: Record<string, SimulatorFunction> = {
+  strray_get_capabilities: (): MCPToolResult => ({
+    content: [
+      {
+        type: 'text',
+        text: `**0xRay Framework Capabilities:**
+
+**42 Specialized Agents:**
+- enforcer: Codex compliance & error prevention
+- architect: System design & technical decisions
+- orchestrator: Multi-agent workflow coordination
+- bug-triage-specialist: Error investigation & surgical fixes
+- code-reviewer: Quality assessment & standards validation
+- security-auditor: Vulnerability detection & compliance
+- refactorer: Technical debt elimination & code consolidation
+- testing-lead: Testing strategy & coverage optimization
+
+**23 Skills (Lazy Loading):**
+- project-analysis, testing-strategy, code-review, security-audit, performance-optimization, refactoring-strategies, ui-ux-design, documentation-generation, and more
+
+**System Tools:**
+- framework-reporting-system: Generate comprehensive reports
+- complexity-analyzer: Analyze code complexity and delegation decisions
+- codex-injector: Apply development standards and quality enforcement
+
+**Enterprise Features:**
+- 99.6% error prevention through codex compliance
+- 90% resource reduction (0 baseline processes)
+- Multi-agent orchestration with intelligent delegation`,
+      },
+    ],
+  }),
+
+  strray_get_commands: (): MCPToolResult => ({
+    content: [
+      {
+        type: 'text',
+        text: `**0xRay Framework Commands:**
+
+**Agent Commands:**
+@enforcer - Codex compliance & error prevention
+@architect - System design & technical decisions
+@orchestrator - Multi-agent workflow coordination
+@bug-triage-specialist - Error investigation & surgical fixes
+@code-reviewer - Quality assessment & standards validation
+@security-auditor - Vulnerability detection & compliance
+@refactorer - Technical debt elimination & code consolidation
+@testing-lead - Testing strategy & coverage optimization
+@researcher - Codebase exploration & documentation search
+
+**System Commands:**
+framework-reporting-system - Generate comprehensive framework reports
+
+**Getting Started:**
+1. Use @enforcer for code quality validation
+2. Use @orchestrator for complex development tasks
+3. Check framework-reporting-system for activity reports`,
+      },
+    ],
+  }),
+
+  strray_explain_capability: (): MCPToolResult => ({
+    content: [
+      {
+        type: 'text',
+        text: `**Enforcer Agent**
+Automatically validates code against the Universal Development Codex.
+Prevents common errors, enforces coding standards, and ensures production-ready code.
+
+**Capabilities:**
+- Type safety validation (no any/unknown types)
+- Architecture compliance checking
+- Error prevention (90% runtime error reduction)
+- Code quality enforcement
+
+**Usage:** @enforcer analyze this code for violations`,
+      },
+    ],
+  }),
+};
+
+/**
+ * Skill Invocation server simulations
+ */
+export const skillInvocationSimulations: Record<string, SimulatorFunction> = {
+  'invoke-skill': (args): MCPToolResult => {
+    const skillArgs = args as { skillName?: string; toolName?: string };
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Generic skill invocation completed for ${skillArgs.skillName || 'unknown'}:${skillArgs.toolName || 'unknown'}`,
+        },
+      ],
+    };
+  },
+
+  'skill-code-review': (): MCPToolResult => ({
+    content: [
+      {
+        type: 'text',
+        text: 'code-review skill invoked successfully',
+      },
+    ],
+  }),
+
+  'skill-security-audit': (): MCPToolResult => ({
+    content: [
+      {
+        type: 'text',
+        text: 'security-audit skill invoked successfully',
+      },
+    ],
+  }),
+
+  'skill-performance-optimization': (): MCPToolResult => ({
+    content: [
+      {
+        type: 'text',
+        text: 'performance-optimization skill invoked successfully',
+      },
+    ],
+  }),
+
+  'skill-testing-strategy': (): MCPToolResult => ({
+    content: [
+      {
+        type: 'text',
+        text: 'testing-strategy skill invoked successfully',
+      },
+    ],
+  }),
+
+  'skill-project-analysis': (): MCPToolResult => ({
+    content: [
+      {
+        type: 'text',
+        text: 'project-analysis skill invoked successfully',
+      },
+    ],
+  }),
+};
+
+export function getAllServerSimulations(): ServerSimulations {
+  return {
+    'code-review': codeReviewSimulations,
+    'security-audit': securityAuditSimulations,
+    'performance-optimization': performanceOptimizationSimulations,
+    'testing-strategy': testingStrategySimulations,
+    'researcher': researcherSimulations,
+    'framework-help': frameworkHelpSimulations,
+    'skill-invocation': skillInvocationSimulations,
+  };
+}

package/src/mcps/simulation/simulation-engine.ts

@@ -0,0 +1,126 @@
+/**
+ * Simulation Engine
+ *
+ * Provides fallback simulation for MCP tools when real servers are unavailable.
+ * Part of Phase 5 refactoring - Simulation Layer extraction.
+ */
+
+import { MCPToolResult, ISimulationEngine } from '../types/index.js';
+
+export type SimulatorFunction = (args: unknown) => MCPToolResult | Promise<MCPToolResult>;
+
+export class SimulationEngine implements ISimulationEngine {
+  private simulators: Map<string, Map<string, SimulatorFunction>> = new Map();
+
+  /**
+   * Register a simulator for a specific server and tool
+   */
+  registerSimulator(
+    serverName: string,
+    toolName: string,
+    simulator: SimulatorFunction
+  ): void {
+    if (!this.simulators.has(serverName)) {
+      this.simulators.set(serverName, new Map());
+    }
+    this.simulators.get(serverName)!.set(toolName, simulator);
+  }
+
+  /**
+   * Register multiple simulators for a server
+   */
+  registerServerSimulators(
+    serverName: string,
+    simulators: Record<string, SimulatorFunction>
+  ): void {
+    for (const [toolName, simulator] of Object.entries(simulators)) {
+      this.registerSimulator(serverName, toolName, simulator);
+    }
+  }
+
+  /**
+   * Check if a simulator exists for a server/tool combination
+   */
+  canSimulate(serverName: string, toolName: string): boolean {
+    return this.simulators.get(serverName)?.has(toolName) || false;
+  }
+
+  /**
+   * Execute a simulation
+   */
+  async simulate(
+    serverName: string,
+    toolName: string,
+    args: unknown
+  ): Promise<MCPToolResult> {
+    const simulator = this.simulators.get(serverName)?.get(toolName);
+    if (!simulator) {
+      throw new Error(`No simulator registered for ${serverName}/${toolName}`);
+    }
+
+    const result = simulator(args);
+    return Promise.resolve(result);
+  }
+
+  /**
+   * Get all registered simulator names for a server
+   */
+  getServerTools(serverName: string): string[] {
+    const serverSimulators = this.simulators.get(serverName);
+    if (!serverSimulators) {
+      return [];
+    }
+    return Array.from(serverSimulators.keys());
+  }
+
+  /**
+   * Get all registered server names
+   */
+  getRegisteredServers(): string[] {
+    return Array.from(this.simulators.keys());
+  }
+
+  /**
+   * Unregister a specific simulator
+   */
+  unregisterSimulator(serverName: string, toolName: string): boolean {
+    const serverSimulators = this.simulators.get(serverName);
+    if (!serverSimulators) {
+      return false;
+    }
+
+    const result = serverSimulators.delete(toolName);
+
+    // Clean up empty server entries
+    if (serverSimulators.size === 0) {
+      this.simulators.delete(serverName);
+    }
+
+    return result;
+  }
+
+  /**
+   * Unregister all simulators for a server
+   */
+  unregisterServer(serverName: string): boolean {
+    return this.simulators.delete(serverName);
+  }
+
+  /**
+   * Clear all registered simulators
+   */
+  clear(): void {
+    this.simulators.clear();
+  }
+
+  /**
+   * Get total count of registered simulators
+   */
+  getSimulatorCount(): number {
+    let count = 0;
+    for (const serverSimulators of this.simulators.values()) {
+      count += serverSimulators.size;
+    }
+    return count;
+  }
+}