0xray 2.0.0 → 2.1.0

package/dist/mcps/knowledge-skills/tech-writer.server.js

@@ -10,11 +10,11 @@ import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextpro
 import * as fs from "fs";
 import * as path from "path";
 import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
-class StringRayDocumentationGenerationServer {
+class XrayDocumentationGenerationServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "documentation-generation", version: "1.22.67",
+            name: "documentation-generation", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},
@@ -727,7 +727,7 @@ class StringRayDocumentationGenerationServer {
             openapi: "3.0.0",
             info: {
                 title: "API Documentation",
-                version: "1.22.67",
+                version: "2.0.0",
                 description: "Generated API documentation",
             },
             servers: [
@@ -1185,7 +1185,7 @@ class StringRayDocumentationGenerationServer {
 }
 // Run the server if this file is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-    const server = new StringRayDocumentationGenerationServer();
+    const server = new XrayDocumentationGenerationServer();
     server.run().catch(() => { });
 }
-export { StringRayDocumentationGenerationServer };
+export { XrayDocumentationGenerationServer };

package/dist/mcps/knowledge-skills/testing-best-practices.server.d.ts

@@ -0,0 +1,36 @@
+/**
+ * xray Testing Best Practices MCP Server
+ *
+ * Knowledge skill for comprehensive testing strategies, TDD/BDD implementation,
+ * test coverage optimization, and automated testing workflows
+ */
+declare class XrayTestingBestPracticesServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private analyzeTestCoverage;
+    private designTestStrategy;
+    private implementTDDWorkflow;
+    private optimizeTestPerformance;
+    private setupCICDTesting;
+    private performCoverageAnalysis;
+    private createTestStrategy;
+    private createTDDWorkflow;
+    private analyzeTestPerformance;
+    private createCIPipeline;
+    private prioritizeGaps;
+    private createCoverageImprovementPlan;
+    private createImplementationRoadmap;
+    private recommendTestingTools;
+    private provideTDDExamples;
+    private recommendTDDResources;
+    private createPerformanceOptimizationPlan;
+    private setupPerformanceMonitoring;
+    private generateCIConfigTemplates;
+    private createCITroubleshootingGuide;
+    private getPriorityIcon;
+    private getImpactIcon;
+    private getTestTypeIcon;
+    run(): Promise<void>;
+}
+export { XrayTestingBestPracticesServer };

package/dist/mcps/knowledge-skills/testing-best-practices.server.js

@@ -8,11 +8,11 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-class StringRayTestingBestPracticesServer {
+class XrayTestingBestPracticesServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "testing-best-practices", version: "1.22.67",
+            name: "testing-best-practices", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},
@@ -860,7 +860,7 @@ class StringRayTestingBestPracticesServer {
 }
 // Run the server if this file is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-    const server = new StringRayTestingBestPracticesServer();
+    const server = new XrayTestingBestPracticesServer();
     server.run().catch(() => { });
 }
-export { StringRayTestingBestPracticesServer };
+export { XrayTestingBestPracticesServer };

package/dist/mcps/knowledge-skills/testing-strategy.server.d.ts

@@ -0,0 +1,47 @@
+/**
+ * xray Testing Strategy MCP Server
+ *
+ * Knowledge skill for test planning, coverage optimization,
+ * and testing methodology recommendations
+ */
+declare class XrayTestingStrategyServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private analyzeTestCoverage;
+    private designTestStrategy;
+    private identifyTestGaps;
+    private optimizeTestCoverage;
+    private generateTestFile;
+    private performTestCoverageAnalysis;
+    private generateTestStrategy;
+    private analyzeTestGaps;
+    private createCoverageOptimizationPlan;
+    private findTestFiles;
+    private findSourceFiles;
+    private findFiles;
+    private calculateCoverage;
+    private categorizeTests;
+    private detectTestFrameworks;
+    private analyzeTestPatterns;
+    private identifyCoverageGaps;
+    private generateCoverageRecommendations;
+    private estimateBaseTestCounts;
+    private generateStrategyRecommendations;
+    private createImplementationPlan;
+    private generateExpectedTestFile;
+    private inferTestType;
+    private calculateTestPriority;
+    private estimateTestComplexity;
+    private calculateGapCoverage;
+    private generateGapRecommendations;
+    private estimateOptimizationEffort;
+    private identifyPriorityAreas;
+    private createOptimizationPhases;
+    private estimateOptimizationTimeline;
+    private calculateOptimizationROI;
+    private generateMilestones;
+    private shouldIgnorePath;
+    run(): Promise<void>;
+}
+export default XrayTestingStrategyServer;

package/dist/mcps/knowledge-skills/testing-strategy.server.js

@@ -12,11 +12,11 @@ import * as path from "path";
 import { frameworkLogger } from "../../core/framework-logger.js";
 import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
 import { detectProjectLanguage, LANGUAGE_CONFIGS, } from "../../utils/language-detector.js";
-class StringRayTestingStrategyServer {
+class XrayTestingStrategyServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "testing-strategy", version: "1.22.67",
+            name: "testing-strategy", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},
@@ -821,7 +821,7 @@ describe("${pathModule.basename(sourceFile, ".ts")}", () => {${testCases}
 }
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-    const server = new StringRayTestingStrategyServer();
+    const server = new XrayTestingStrategyServer();
     server.run().catch(() => { });
 }
-export default StringRayTestingStrategyServer;
+export default XrayTestingStrategyServer;

package/dist/mcps/knowledge-skills/ui-ux-design.server.d.ts

@@ -0,0 +1,69 @@
+/**
+ * xray UI/UX Design MCP Server
+ *
+ * Knowledge skill for user interface and user experience design,
+ * component patterns, accessibility compliance, and design system guidance
+ */
+declare class XrayUIUXDesignServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private analyzeUIComponent;
+    private designComponent;
+    private auditAccessibility;
+    private generateDesignSystem;
+    private extractComponentName;
+    private analyzeComponentCode;
+    private checkAccessibilityIssues;
+    private checkResponsiveIssues;
+    private checkUsabilityIssues;
+    private checkPerformanceIssues;
+    private checkSemanticIssues;
+    private calculateAccessibilityScore;
+    private calculateUsabilityScore;
+    private generateUIRecommendations;
+    private identifyDesignPatterns;
+    private generateComponentDesign;
+    private generateComponentCode;
+    private generateReactComponent;
+    private generateVueComponent;
+    private generateAngularComponent;
+    private addAccessibilityFeatures;
+    private checkWCAGCompliance;
+    /**
+     * Parse color value and convert to RGB
+     */
+    private parseColor;
+    /**
+     * Calculate relative luminance (WCAG formula)
+     */
+    private getLuminance;
+    private getLuminanceComponent;
+    /**
+     * Calculate contrast ratio between two colors
+     */
+    private calculateContrastRatio;
+    /**
+     * Analyze color contrast in CSS
+     */
+    private analyzeColorContrast;
+    /**
+     * Specifically analyze hero section for contrast issues
+     */
+    private analyzeHeroSectionContrast;
+    /**
+     * Extract CSS for hero section
+     */
+    private extractHeroCSS;
+    private calculateWCAGScore;
+    private generateAccessibilityRecommendations;
+    private createDesignSystem;
+    private generateDesignTokens;
+    private generateDesignSystemDocs;
+    private getSeverityIcon;
+    private validateMobileDesign;
+    private analyzeVisualHierarchy;
+    private recommendImages;
+    run(): Promise<void>;
+}
+export { XrayUIUXDesignServer };

package/dist/mcps/knowledge-skills/ui-ux-design.server.js

@@ -8,11 +8,11 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { frameworkLogger } from "../../core/framework-logger.js";
-class StringRayUIUXDesignServer {
+class XrayUIUXDesignServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "ui-ux-design", version: "1.22.67",
+            name: "ui-ux-design", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},
@@ -1475,7 +1475,7 @@ Available: ${Object.keys(system.components).length} component types
     async run() {
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
-        await frameworkLogger.log("ui-ux-design.server", "-strray-ui-ux-design-mcp-server-running-", "info", { message: "xray UI/UX Design MCP Server running..." });
+        await frameworkLogger.log("ui-ux-design.server", "-xray-ui-ux-design-mcp-server-running-", "info", { message: "xray UI/UX Design MCP Server running..." });
         const cleanup = async (signal) => {
             await frameworkLogger.log("ui-ux-design.server", "-received-signal-shutting-down-gracefully-", "info", { message: `Received ${signal}, shutting down gracefully...` });
             // Set a timeout to force exit if graceful shutdown fails
@@ -1488,7 +1488,7 @@ Available: ${Object.keys(system.components).length} component types
                     await this.server.close();
                 }
                 clearTimeout(timeout);
-                await frameworkLogger.log("ui-ux-design.server", "-strray-mcp-server-shut-down-gracefully-", "info", { message: "xray MCP Server shut down gracefully" });
+                await frameworkLogger.log("ui-ux-design.server", "-xray-mcp-server-shut-down-gracefully-", "info", { message: "xray MCP Server shut down gracefully" });
                 process.exit(0);
             }
             catch (error) {
@@ -1532,7 +1532,7 @@ Available: ${Object.keys(system.components).length} component types
 }
 // Run the server if this file is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-    const server = new StringRayUIUXDesignServer();
+    const server = new XrayUIUXDesignServer();
     server.run().catch((error) => frameworkLogger.log("mcps/ui-ux-design", "run", "error", { error: String(error) }));
 }
-export { StringRayUIUXDesignServer };
+export { XrayUIUXDesignServer };

package/dist/mcps/lint.server.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 0xRay Lint MCP Server
+ *
+ * Comprehensive ESLint validation and automated code quality checking
+ */
+declare class XrayLintServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private handleLint;
+    private handleLintCheck;
+    private runEslint;
+    private checkLintRules;
+    private generateLintSummary;
+    run(): Promise<void>;
+}
+export { XrayLintServer };

package/dist/mcps/lint.server.js

@@ -9,18 +9,18 @@ import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextpro
 import { execFileSync } from "child_process";
 import fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
-class StringRayLintServer {
+class XrayLintServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "lint", version: "1.22.67",
+            name: "lint", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},
             },
         });
         this.setupToolHandlers();
-        void frameworkLogger.log("lint.server", "-strray-lint-mcp-server-initialized-", "info", { message: "0xRay Lint MCP Server initialized" });
+        void frameworkLogger.log("lint.server", "-xray-lint-mcp-server-initialized-", "info", { message: "0xRay Lint MCP Server initialized" });
     }
     setupToolHandlers() {
         // List available tools
@@ -370,12 +370,12 @@ ${checkResults.details.map((d) => `• ${d}`).join("\n")}
     async run() {
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
-        await frameworkLogger.log("lint.server", "-strray-lint-mcp-server-started-", "info", { message: "0xRay Lint MCP Server started" });
+        await frameworkLogger.log("lint.server", "-xray-lint-mcp-server-started-", "info", { message: "0xRay Lint MCP Server started" });
     }
 }
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-    const server = new StringRayLintServer();
+    const server = new XrayLintServer();
     server.run().catch((error) => frameworkLogger.log("mcps/lint", "run", "error", { error: String(error) }));
 }
-export { StringRayLintServer };
+export { XrayLintServer };

package/dist/mcps/mcp-client.d.ts

@@ -0,0 +1,157 @@
+/**
+ * MCP Client Layer
+ *
+ * Enables framework components to call MCP servers programmatically.
+ * Refactored as a lean facade using extracted modules (Phases 1-5).
+ *
+ * Architecture:
+ * - ToolRegistry: Manages tool registration and lookup
+ * - ToolDiscovery: Discovers tools from MCP servers
+ * - ToolExecutor: Executes tools via JSON-RPC
+ * - ToolCache: Caches discovered tools
+ * - SimulationEngine: Provides fallback simulations
+ */
+import { EventEmitter } from 'events';
+import { MCPClientConfig, MCPTool, MCPToolResult } from './types/index.js';
+interface RetryConfig {
+    maxRetries: number;
+    initialDelayMs: number;
+    maxDelayMs: number;
+    backoffMultiplier: number;
+}
+/**
+ * Tool event types for hooks
+ */
+export interface ToolBeforeEvent {
+    toolName: string;
+    serverName: string;
+    args: unknown;
+    timestamp: number;
+}
+export interface ToolAfterEvent extends ToolBeforeEvent {
+    result?: MCPToolResult;
+    error?: string;
+    duration: number;
+    success: boolean;
+}
+/**
+ * MCP Client
+ *
+ * Facade that orchestrates tool discovery, caching, execution, and simulation.
+ */
+export declare class MCPClient extends EventEmitter {
+    private config;
+    private toolRegistry;
+    private toolDiscovery;
+    private toolExecutor;
+    private toolCache;
+    private simulationEngine;
+    private retryConfig;
+    constructor(config: MCPClientConfig, retryConfig?: Partial<RetryConfig>);
+    /**
+     * Execute with exponential backoff retry
+     */
+    private executeWithRetry;
+    /**
+     * Execute a tool using the real MCP transport (ConnectionPool + ToolExecutor).
+     * This is the primary production path.
+     */
+    private executeRealTool;
+    /**
+     * Pure MCP mode — simulation and generic fallbacks are disabled.
+     */
+    private get isPureMcpMode();
+    /**
+     * Register default simulation implementations
+     */
+    private registerDefaultSimulations;
+    /**
+     * Initialize MCP client by discovering and caching tools
+     */
+    initialize(): Promise<void>;
+    /**
+     * Discover available tools for this server
+     */
+    private discoverTools;
+    /**
+     * Get static tool definitions for a server
+     */
+    private getStaticTools;
+    /**
+     * Call a specific MCP server tool
+     */
+    callTool(toolName: string, args?: unknown): Promise<MCPToolResult>;
+    /**
+     * Get list of available tools
+     */
+    getAvailableTools(): MCPTool[];
+    /**
+     * Check if a tool is available
+     */
+    hasTool(toolName: string): boolean;
+    /**
+     * Get tool by name
+     */
+    getTool(toolName: string): MCPTool | undefined;
+    /**
+     * Subscribe to tool.before events
+     */
+    onToolBefore(callback: (event: ToolBeforeEvent) => void): void;
+    /**
+     * Subscribe to tool.after events
+     */
+    onToolAfter(callback: (event: ToolAfterEvent) => void): void;
+    /**
+     * Unsubscribe from tool.before events
+     */
+    offToolBefore(callback: (event: ToolBeforeEvent) => void): void;
+    /**
+     * Unsubscribe from tool.after events
+     */
+    offToolAfter(callback: (event: ToolAfterEvent) => void): void;
+}
+/**
+ * MCP Client Manager
+ *
+ * Manages MCP client instances and provides unified interface
+ * for framework components to access MCP server capabilities.
+ */
+export declare class MCPClientManager {
+    private static instance;
+    private clients;
+    private constructor();
+    static getInstance(): MCPClientManager;
+    /**
+     * Get or create MCP client for a server
+     */
+    getClient(serverName: string): Promise<MCPClient>;
+    /**
+     * Get the event emitter for a specific client
+     * Use this to subscribe to tool.before/tool.after events
+     */
+    getClientEventEmitter(serverName: string): MCPClient | null;
+    /**
+     * Subscribe to tool events across all clients
+     * Note: This creates a subscription for each client - manage subscriptions carefully
+     * @returns Unsubscribe function to call to remove all event listeners
+     */
+    onToolEvent(eventType: 'tool.before' | 'tool.after', callback: (event: ToolBeforeEvent | ToolAfterEvent) => void): Promise<() => void>;
+    /**
+     * Create client configuration for a server
+     */
+    createClientConfig(serverName: string): MCPClientConfig;
+    /**
+     * Call MCP server tool
+     */
+    callServerTool(serverName: string, toolName: string, args?: unknown): Promise<MCPToolResult>;
+    /**
+     * Get all available MCP server tools
+     */
+    getAllAvailableTools(): Promise<Record<string, MCPTool[]>>;
+    /**
+     * Clear all cached clients
+     */
+    clearClients(): void;
+}
+export declare const mcpClientManager: MCPClientManager;
+export {};

package/dist/mcps/mcp-client.js

@@ -267,17 +267,17 @@ export class MCPClient extends EventEmitter {
             ],
             'framework-help': [
                 {
-                    name: 'strray_get_capabilities',
+                    name: 'xray_get_capabilities',
                     description: 'Get 0xRay framework capabilities',
                     inputSchema: { type: 'object', properties: {} },
                 },
                 {
-                    name: 'strray_get_commands',
+                    name: 'xray_get_commands',
                     description: 'Get available 0xRay commands',
                     inputSchema: { type: 'object', properties: {} },
                 },
                 {
-                    name: 'strray_explain_capability',
+                    name: 'xray_explain_capability',
                     description: 'Explain a specific capability',
                     inputSchema: {
                         type: 'object',

package/dist/mcps/model-health-check.server.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 0xRay Model Health Check MCP Server
+ *
+ * Advanced model compatibility validation and dynamic health assessment
+ */
+declare class XrayModelHealthCheckServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private handleModelHealthCheck;
+    private checkModelHealth;
+    private generateCompatibilityMatrix;
+    private generateHealthReport;
+    start(): Promise<void>;
+}
+export default XrayModelHealthCheckServer;

package/dist/mcps/model-health-check.server.js

@@ -8,11 +8,11 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { modelRouter } from "../core/model-router.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { frameworkLogger } from "../core/framework-logger.js";
-class StringRayModelHealthCheckServer {
+class XrayModelHealthCheckServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "model-health-check", version: "1.22.67",
+            name: "model-health-check", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},
@@ -222,7 +222,7 @@ class StringRayModelHealthCheckServer {
 }
 // Start the server if this file is run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-    const server = new StringRayModelHealthCheckServer();
+    const server = new XrayModelHealthCheckServer();
     server.start().catch((error) => frameworkLogger.log("mcps/model-health-check", "run", "error", { error: String(error) }));
 }
-export default StringRayModelHealthCheckServer;
+export default XrayModelHealthCheckServer;

package/dist/mcps/orchestrator/config/agent-capabilities.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Agent Capabilities Configuration
+ *
+ * Centralized agent capability definitions for orchestration decisions
+ */
+import type { AgentCapability } from '../types.js';
+/**
+ * Agent Capabilities Manager
+ * Manages agent capabilities for orchestration decisions
+ */
+export declare class AgentCapabilitiesManager {
+    private capabilities;
+    constructor();
+    /**
+     * Get capabilities for a specific agent
+     */
+    getCapabilities(agentType: string): AgentCapability | undefined;
+    /**
+     * Get all registered agent capabilities
+     */
+    getAllCapabilities(): Map<string, AgentCapability>;
+    /**
+     * Register or update agent capabilities
+     */
+    setCapabilities(agentType: string, capability: AgentCapability): void;
+    /**
+     * Select the best agent for a task based on complexity and capabilities
+     */
+    selectAgentForTask(requiredCapabilities: string[], complexity: number): string | null;
+    /**
+     * Get all available agents for a given complexity level
+     */
+    getAvailableAgents(complexity: number): string[];
+}
+export declare function getAgentCapabilitiesManager(): AgentCapabilitiesManager;

package/dist/mcps/orchestrator/execution/execution-planner.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Execution Planner
+ *
+ * Creates optimized execution plans for orchestration tasks
+ */
+import type { OrchestrationTask, ExecutionPlan, ComplexityAnalysis, TaskValidation } from '../types.js';
+/**
+ * Execution Planner
+ * Plans and optimizes task execution strategies
+ */
+export declare class ExecutionPlanner {
+    private capabilitiesManager;
+    /**
+     * Validate a list of tasks
+     */
+    validateTasks(tasks: OrchestrationTask[]): TaskValidation;
+    /**
+     * Create an execution plan based on tasks and mode
+     */
+    createExecutionPlan(tasks: OrchestrationTask[], executionMode: string): Promise<ExecutionPlan>;
+    /**
+     * Create a parallel execution plan
+     */
+    private createParallelPlan;
+    /**
+     * Create a sequential execution plan
+     */
+    private createSequentialPlan;
+    /**
+     * Create an optimized execution plan considering dependencies and complexity
+     */
+    private createOptimizedPlan;
+    /**
+     * Sort tasks by their dependencies
+     */
+    private sortByDependencies;
+    /**
+     * Assign tasks to agents based on capability
+     */
+    private assignTasksToAgents;
+    /**
+     * Estimate execution duration based on agent assignments
+     */
+    estimateExecutionDuration(agentAssignments: Map<string, OrchestrationTask[]>): number;
+    /**
+     * Analyze task complexity
+     */
+    analyzeTaskComplexity(tasks: OrchestrationTask[]): Promise<ComplexityAnalysis>;
+    /**
+     * Calculate complexity for a single task
+     */
+    calculateTaskComplexity(task: OrchestrationTask): number;
+    /**
+     * Recommend execution strategy based on complexity and task count
+     */
+    private recommendStrategy;
+    /**
+     * Calculate parallel execution potential
+     */
+    private calculateParallelPotential;
+}
+export declare function getExecutionPlanner(): ExecutionPlanner;