0xray 2.0.0 → 2.0.1

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 StringRayModelHealthCheckServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private handleModelHealthCheck;
+    private checkModelHealth;
+    private generateCompatibilityMatrix;
+    private generateHealthReport;
+    start(): Promise<void>;
+}
+export default StringRayModelHealthCheckServer;

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

@@ -12,7 +12,7 @@ class StringRayModelHealthCheckServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "model-health-check", version: "1.22.67",
+            name: "model-health-check", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},

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;

package/dist/mcps/orchestrator/handlers/complexity-handler.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Complexity Handler
+ *
+ * Handles complexity analysis requests
+ */
+import type { OrchestrationTask } from '../types.js';
+/**
+ * Complexity Handler
+ * Processes analyze-complexity requests
+ */
+export declare class ComplexityHandler {
+    private planner;
+    /**
+     * Handle analyze-complexity request
+     */
+    handleAnalyzeComplexity(args: {
+        tasks: OrchestrationTask[];
+    }): Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+    /**
+     * Generate recommendations based on complexity analysis
+     */
+    private generateRecommendations;
+    /**
+     * Format complexity response
+     */
+    private formatComplexityResponse;
+}

package/dist/mcps/orchestrator/handlers/status-handler.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Status Handler
+ *
+ * Handles orchestration status requests
+ */
+import type { OrchestrationResult } from '../types.js';
+interface HistoryItem {
+    sessionId: string;
+    description: string;
+    tasks: number;
+    result: OrchestrationResult;
+    timestamp: string;
+}
+interface StatusHandlerDeps {
+    activeTasks: Map<string, unknown>;
+    taskHistory: HistoryItem[];
+}
+/**
+ * Status Handler
+ * Processes get-orchestration-status requests
+ */
+export declare class StatusHandler {
+    /**
+     * Handle get-orchestration-status request
+     */
+    handleGetOrchestrationStatus(args: {
+        sessionId?: string;
+        detailed?: boolean;
+    }, deps: StatusHandlerDeps): Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+    /**
+     * Handle cancel-orchestration request
+     */
+    handleCancelOrchestration(args: {
+        sessionId?: string;
+        taskId?: string;
+        force?: boolean;
+    }, deps: StatusHandlerDeps): Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+    /**
+     * Handle optimize-orchestration request
+     */
+    handleOptimizeOrchestration(args: {
+        history?: boolean;
+        recommendations?: boolean;
+    }): Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+    /**
+     * Get overall orchestration status
+     */
+    private getOverallStatus;
+    /**
+     * Format status response
+     */
+    private formatStatusResponse;
+}
+export {};

package/dist/mcps/orchestrator/handlers/task-handler.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Task Handler
+ *
+ * Handles task orchestration requests
+ */
+import type { OrchestrationResult, OrchestrationTask } from '../types.js';
+export interface TaskHandlerDeps {
+    taskHistory: OrchestrationHistoryItem[];
+    activeTasks: Map<string, unknown>;
+}
+interface OrchestrationHistoryItem {
+    sessionId: string;
+    description: string;
+    tasks: number;
+    result: OrchestrationResult;
+    timestamp: string;
+}
+/**
+ * Task Handler
+ * Processes orchestrate-task requests
+ */
+export declare class TaskHandler {
+    private planner;
+    /**
+     * Handle orchestrate-task request
+     */
+    handleOrchestrateTask(args: {
+        description: string;
+        tasks?: OrchestrationTask[];
+        sessionId?: string;
+        executionMode?: string;
+        timeout?: number;
+    }, deps: TaskHandlerDeps): Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+    /**
+     * Execute the orchestration plan.
+     * For known MCP skill servers (code-review, security-audit, researcher, etc.),
+     * we actually call the target tool. For other agents we record the assignment.
+     */
+    private executePlan;
+    private mapAgentToTool;
+    private extractTextFromMcpResult;
+    /**
+     * Format orchestration response
+     */
+    private formatOrchestrationResponse;
+}
+export {};

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

@@ -0,0 +1,38 @@
+/**
+ * Orchestrator MCP Server - Facade
+ *
+ * Main entry point for the orchestrator MCP server
+ * Provides a clean API while hiding internal complexity
+ */
+/**
+ * Orchestrator MCP Server
+ * Enterprise-grade orchestration with advanced task management and agent coordination
+ */
+export declare class OrchestratorServer {
+    private server;
+    private activeTasks;
+    private taskHistory;
+    private taskHandler;
+    private complexityHandler;
+    private statusHandler;
+    private coordinator;
+    constructor();
+    /**
+     * Initialize tool definitions
+     */
+    private initializeTools;
+    /**
+     * Set up tool request handlers
+     */
+    private setupToolHandlers;
+    private handleGovernAndApply;
+    /**
+     * Start the server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the server
+     */
+    stop(): Promise<void>;
+}
+export declare function createOrchestratorServer(): OrchestratorServer;

package/dist/mcps/orchestrator/types.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Orchestrator MCP Server Types
+ *
+ * Type definitions for the orchestrator MCP server module
+ */
+export interface AgentCapability {
+    capabilities: string[];
+    complexityThreshold: number;
+    concurrentTasks: number;
+}
+export interface OrchestrationTask {
+    id: string;
+    description: string;
+    type: string;
+    priority?: 'critical' | 'high' | 'medium' | 'low';
+    dependencies?: string[];
+    estimatedComplexity?: number;
+}
+export interface ExecutionPlan {
+    tasks: OrchestrationTask[];
+    strategy: 'parallel' | 'sequential' | 'optimized';
+    agentAssignments: Map<string, OrchestrationTask[]>;
+    estimatedDuration: number;
+}
+export interface OrchestrationResult {
+    sessionId: string;
+    success: boolean;
+    completedTasks: number;
+    failedTasks: number;
+    duration: number;
+    agentUtilization: Record<string, number>;
+    agentOutputs?: Record<string, string>;
+    bottlenecks: string[];
+    recommendations: string[];
+}
+export interface ComplexityAnalysis {
+    overallComplexity: number;
+    recommendedStrategy: string;
+    taskComplexity: Array<{
+        complexity: number;
+        category: string;
+    }>;
+    agentAssignments: Array<{
+        agent: string;
+        taskCount: number;
+        utilization: number;
+    }>;
+    estimatedDuration: number;
+    parallelPotential: number;
+}
+export interface TaskValidation {
+    valid: boolean;
+    errors: string[];
+}
+export interface OrchestrationStatus {
+    activeSessions: number;
+    totalTasks: number;
+    agentUtilization: Record<string, number>;
+    recentSessions: Array<{
+        sessionId: string;
+        status: string;
+        tasks: number;
+        duration: number;
+    }>;
+}
+export interface TaskExecutionContext {
+    sessionId: string;
+    task: OrchestrationTask;
+    assignedAgent: string;
+    startTime: number;
+}
+/** Result of actually executing one task via an agent/MCP server */
+export interface TaskExecutionResult {
+    taskId: string;
+    agent: string;
+    success: boolean;
+    output: string;
+    durationMs: number;
+}

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

@@ -0,0 +1,10 @@
+/**
+ * 0xRay Orchestrator MCP Server
+ *
+ * This is a re-export from the new modular structure.
+ * For the full implementation, see: src/mcps/orchestrator/
+ *
+ * @deprecated Use src/mcps/orchestrator/server.ts instead
+ */
+export { OrchestratorServer, createOrchestratorServer } from './orchestrator/server.js';
+export type { AgentCapability, OrchestrationTask, ExecutionPlan, OrchestrationResult, ComplexityAnalysis, TaskValidation, OrchestrationStatus, TaskExecutionContext, } from './orchestrator/types.js';

package/dist/mcps/performance-analysis.server.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 0xRay Performance Analysis MCP Server
+ *
+ * Comprehensive metrics analysis for framework integration and optimization
+ */
+declare class StringRayPerformanceAnalysisServer {
+    private server;
+    private startTime;
+    constructor();
+    private setupToolHandlers;
+    private handlePerformanceAnalysis;
+    private handleBottleneckDetection;
+    private analyzeRuntimePerformance;
+    private analyzeBuildPerformance;
+    private analyzeResourceUsage;
+    private detectBottlenecks;
+    private analyzeSpecificBottlenecks;
+    private getDiskUsage;
+    private identifyCommonBottlenecks;
+    private findLargeFiles;
+    private checkPerformanceThresholds;
+    private generatePerformanceSummary;
+    private formatMetrics;
+    private generateDetailedReport;
+    run(): Promise<void>;
+}
+export { StringRayPerformanceAnalysisServer };

package/dist/mcps/performance-analysis.server.js

@@ -16,7 +16,7 @@ class StringRayPerformanceAnalysisServer {
     startTime;
     constructor() {
         this.server = new Server({
-            name: "performance-analysis", version: "1.22.67",
+            name: "performance-analysis", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},

package/dist/mcps/processor-pipeline.server.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 0xRay Processor Pipeline MCP Server
+ *
+ * Advanced processor pipeline with codex validation, compliance monitoring, and framework enforcement
+ */
+declare class StringRayProcessorPipelineServer {
+    private server;
+    private codexLoader;
+    private codexRules;
+    private codexTerms;
+    constructor();
+    private loadCodexRules;
+    private setupToolHandlers;
+    private handlePreProcessors;
+    private handlePostProcessors;
+    private handleCodexValidation;
+    private handleComplianceCheck;
+    private sanitizeInput;
+    private validateAgainstCodex;
+    private checkCodexTerm;
+    private enrichWithContext;
+    private performSecurityChecks;
+    private validateResults;
+    private enforceCompliance;
+    private generateAuditTrail;
+    private performQualityAssurance;
+    private detectContentType;
+    private checkFrameworkCompliance;
+    run(): Promise<void>;
+}
+export { StringRayProcessorPipelineServer };

package/dist/mcps/processor-pipeline.server.js

@@ -26,7 +26,7 @@ class StringRayProcessorPipelineServer {
     constructor() {
         this.codexLoader = new CodexLoader();
         this.server = new Server({
-            name: "processor-pipeline", version: "1.22.67",
+            name: "processor-pipeline", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},

package/dist/mcps/protocol/protocol-constants.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Protocol Constants
+ *
+ * MCP protocol constants and configuration values.
+ * Extracted to enable reuse and single source of truth.
+ */
+/**
+ * MCP Protocol Version
+ * Current MCP protocol specification version
+ */
+export declare const MCP_PROTOCOL_VERSION = "2024-11-05";
+/**
+ * JSON-RPC Protocol Version
+ * Standard JSON-RPC version used by MCP
+ */
+export declare const JSONRPC_VERSION = "2.0";
+/**
+ * MCP Method Names
+ * Standard MCP protocol method identifiers
+ */
+export declare const MCP_METHODS: {
+    readonly INITIALIZE: "initialize";
+    readonly TOOLS_LIST: "tools/list";
+    readonly TOOLS_CALL: "tools/call";
+};
+/**
+ * Default Timeout Values
+ * Millisecond timeouts for various MCP operations
+ */
+export declare const DEFAULT_TIMEOUTS: {
+    readonly CONNECTION: 30000;
+    readonly REQUEST: 60000;
+    readonly INITIALIZATION: 10000;
+};
+/**
+ * Error Codes
+ * Standard JSON-RPC error codes used by MCP
+ */
+export declare const ERROR_CODES: {
+    readonly PARSE_ERROR: -32700;
+    readonly INVALID_REQUEST: -32600;
+    readonly METHOD_NOT_FOUND: -32601;
+    readonly INVALID_PARAMS: -32602;
+    readonly INTERNAL_ERROR: -32603;
+    readonly SERVER_ERROR: -32000;
+};

package/dist/mcps/registry.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.22.67",
+  "version": "2.0.0",
   "description": "0xRay Community MCPs Registry - curated API-focused MCP servers",
   "sources": [
     {

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

@@ -0,0 +1,31 @@
+/**
+ * 0xRay Librarian MCP Server
+ *
+ * Knowledge skill for codebase documentation lookup, implementation examples,
+ * and multi-repo analysis - serves as the universal documentation reference
+ *
+ * NOTE: Class is named StringRayLibrarianServer but the MCP server name is
+ * "researcher" for backwards compatibility with existing tool references.
+ */
+import { type CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+interface AnalyzeProposalArgs {
+    proposalTitle?: string;
+    proposalDescription?: string;
+    evidence?: string[];
+    proposalType?: string;
+}
+declare class StringRayLibrarianServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private searchCodebase;
+    private findImplementation;
+    private getDocumentation;
+    /**
+     * Governance-oriented proposal analysis from the researcher / librarian perspective.
+     * Uses corpus patterns, historical recurrence, and architecture knowledge.
+     */
+    analyzeProposal(args: AnalyzeProposalArgs): Promise<CallToolResult>;
+    run(): Promise<void>;
+}
+export { StringRayLibrarianServer };

package/dist/mcps/researcher.server.js

@@ -17,7 +17,7 @@ class StringRayLibrarianServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "researcher", version: "1.22.67",
+            name: "researcher", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},

package/dist/mcps/security-scan.server.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 0xRay Security Scan MCP Server
+ *
+ * Automated security vulnerability scanning with dependency and code analysis
+ */
+declare class StringRaySecurityScanServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private handleSecurityScan;
+    private handleDependencyAudit;
+    private detectPackageManager;
+    private scanDependencies;
+    private scanCodeSecurity;
+    private findCodeFiles;
+    private analyzeFileForSecurity;
+    private generateSecuritySummary;
+    run(): Promise<void>;
+}
+export { StringRaySecurityScanServer };

package/dist/mcps/security-scan.server.js

@@ -15,7 +15,7 @@ class StringRaySecurityScanServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "security-scan", version: "1.22.67",
+            name: "security-scan", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},

package/dist/mcps/simulation/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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/dist/mcps/simulation/server-simulations.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Server Simulations
+ *
+ * Pre-built simulation implementations for all MCP servers.
+ * Extracted from mcp-client.ts as part of Phase 5 refactoring.
+ */
+import { SimulatorFunction } from './simulation-engine.js';
+export interface ServerSimulations {
+    [serverName: string]: Record<string, SimulatorFunction>;
+}
+/**
+ * Code Review server simulations
+ */
+export declare const codeReviewSimulations: Record<string, SimulatorFunction>;
+/**
+ * Security Audit server simulations
+ */
+export declare const securityAuditSimulations: Record<string, SimulatorFunction>;
+/**
+ * Performance Optimization server simulations
+ */
+export declare const performanceOptimizationSimulations: Record<string, SimulatorFunction>;
+/**
+ * Testing Strategy server simulations
+ */
+export declare const testingStrategySimulations: Record<string, SimulatorFunction>;
+/**
+ * Researcher server simulations
+ */
+export declare const researcherSimulations: Record<string, SimulatorFunction>;
+/**
+ * Framework Help server simulations
+ */
+export declare const frameworkHelpSimulations: Record<string, SimulatorFunction>;
+/**
+ * Skill Invocation server simulations
+ */
+export declare const skillInvocationSimulations: Record<string, SimulatorFunction>;
+export declare function getAllServerSimulations(): ServerSimulations;