0xray 2.0.0 → 2.1.0

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/server.js

@@ -8,7 +8,7 @@ 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';
-import { StringRayStateManager } from '../../state/state-manager.js';
+import { XrayStateManager } from '../../state/state-manager.js';
 import { MultiAgentOrchestrationCoordinator } from '../../orchestrator/multi-agent-orchestration-coordinator.js';
 import { TaskHandler } from './handlers/task-handler.js';
 import { ComplexityHandler } from './handlers/complexity-handler.js';
@@ -29,7 +29,7 @@ export class OrchestratorServer {
     coordinator;
     constructor() {
         // Initialize actual coordinator
-        const stateManager = new StringRayStateManager();
+        const stateManager = new XrayStateManager();
         this.coordinator = new MultiAgentOrchestrationCoordinator(stateManager);
         // Initialize handlers
         this.taskHandler = new TaskHandler();

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 XrayPerformanceAnalysisServer {
+    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 { XrayPerformanceAnalysisServer };

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

@@ -11,12 +11,12 @@ import { execSync } from "child_process";
 import fs from "fs";
 import os from "os";
 import path from "path";
-class StringRayPerformanceAnalysisServer {
+class XrayPerformanceAnalysisServer {
     server;
     startTime;
     constructor() {
         this.server = new Server({
-            name: "performance-analysis", version: "1.22.67",
+            name: "performance-analysis", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},
@@ -513,7 +513,7 @@ ${results.recommendations.map((r) => `• 💡 ${r}`).join("\n") || "No recommen
 }
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-    const server = new StringRayPerformanceAnalysisServer();
+    const server = new XrayPerformanceAnalysisServer();
     server.run().catch((error) => frameworkLogger.log("mcps/performance-analysis", "run", "error", { error: String(error) }));
 }
-export { StringRayPerformanceAnalysisServer };
+export { XrayPerformanceAnalysisServer };

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 XrayProcessorPipelineServer {
+    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 { XrayProcessorPipelineServer };

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

@@ -8,7 +8,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { CodexLoader } from "../enforcement/loaders/codex-loader.js";
-class StringRayProcessorPipelineServer {
+class XrayProcessorPipelineServer {
     server;
     codexLoader;
     codexRules = [];
@@ -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: {},
@@ -555,7 +555,7 @@ ${complianceResults.actions.map((a) => `• 🔧 ${a}`).join("\n") || "None requ
 }
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-    const server = new StringRayProcessorPipelineServer();
+    const server = new XrayProcessorPipelineServer();
     server.run().catch((error) => frameworkLogger.log("mcps/processor-pipeline", "run", "error", { error: String(error) }));
 }
-export { StringRayProcessorPipelineServer };
+export { XrayProcessorPipelineServer };

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 XrayLibrarianServer 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 XrayLibrarianServer {
+    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 { XrayLibrarianServer };

package/dist/mcps/researcher.server.js

@@ -4,7 +4,7 @@
  * 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
+ * NOTE: Class is named XrayLibrarianServer but the MCP server name is
  * "researcher" for backwards compatibility with existing tool references.
  */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -13,11 +13,11 @@ import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextpro
 import * as fs from "fs";
 import * as path from "path";
 import { frameworkLogger } from "../core/framework-logger.js";
-class StringRayLibrarianServer {
+class XrayLibrarianServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "researcher", version: "1.22.67",
+            name: "researcher", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},
@@ -498,7 +498,7 @@ class StringRayLibrarianServer {
 }
 // Run the server if this file is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-    const server = new StringRayLibrarianServer();
+    const server = new XrayLibrarianServer();
     server.run().catch((error) => frameworkLogger.log("mcps/researcher", "run", "error", { error: String(error) }));
 }
-export { StringRayLibrarianServer };
+export { XrayLibrarianServer };

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 XraySecurityScanServer {
+    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 { XraySecurityScanServer };

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

@@ -11,11 +11,11 @@ import fs from "fs";
 import path from "path";
 import { detectProjectLanguage, LANGUAGE_CONFIGS, } from "../utils/language-detector.js";
 import { frameworkLogger } from "../core/framework-logger.js";
-class StringRaySecurityScanServer {
+class XraySecurityScanServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "security-scan", version: "1.22.67",
+            name: "security-scan", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},
@@ -525,7 +525,7 @@ ${results.recommendations.map((r) => `• ${r}`).join("\n") || "No recommendatio
 }
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-    const server = new StringRaySecurityScanServer();
+    const server = new XraySecurityScanServer();
     server.run().catch((error) => frameworkLogger.log("mcps/security-scan", "run", "error", { error: String(error) }));
 }
-export { StringRaySecurityScanServer };
+export { XraySecurityScanServer };

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;

package/dist/mcps/simulation/server-simulations.js

@@ -73,7 +73,7 @@ export const researcherSimulations = {
  * Framework Help server simulations
  */
 export const frameworkHelpSimulations = {
-    strray_get_capabilities: () => ({
+    xray_get_capabilities: () => ({
         content: [
             {
                 type: 'text',
@@ -104,7 +104,7 @@ export const frameworkHelpSimulations = {
             },
         ],
     }),
-    strray_get_commands: () => ({
+    xray_get_commands: () => ({
         content: [
             {
                 type: 'text',
@@ -131,7 +131,7 @@ framework-reporting-system - Generate comprehensive framework reports
             },
         ],
     }),
-    strray_explain_capability: () => ({
+    xray_explain_capability: () => ({
         content: [
             {
                 type: 'text',