0xray 4.0.11 → 4.0.13

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

@@ -1,10 +0,0 @@
-/**
- * 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/orchestrator.server.js

@@ -1,20 +0,0 @@
-/**
- * 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
- */
-import * as fs from 'fs';
-import { frameworkLogger } from '../core/framework-logger.js';
-export { OrchestratorServer, createOrchestratorServer } from './orchestrator/server.js';
-// Run if called directly
-if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
-    const { createOrchestratorServer } = await import('./orchestrator/server.js');
-    const server = createOrchestratorServer();
-    server.start().catch((error) => {
-        frameworkLogger.log("mcps/orchestrator", "start", "error", { error: String(error) });
-        process.exit(1);
-    });
-}

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

@@ -1,25 +0,0 @@
-/**
- * 0xRay Performance Analysis MCP Server
- *
- * Comprehensive metrics analysis for framework integration and optimization
- */
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
-declare class XrayPerformanceAnalysisServer extends XrayKnowledgeSkillBase {
-    private startTime;
-    constructor();
-    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;
-}
-export { XrayPerformanceAnalysisServer };

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

@@ -1,488 +0,0 @@
-/**
- * 0xRay Performance Analysis MCP Server
- *
- * Comprehensive metrics analysis for framework integration and optimization
- */
-import { frameworkLogger, generateJobId } from "../core/framework-logger.js";
-import { execSync } from "child_process";
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
-class XrayPerformanceAnalysisServer extends XrayKnowledgeSkillBase {
-    startTime;
-    constructor() {
-        super("performance-analysis", "3.1.0");
-        this.startTime = Date.now();
-        this.tools = [
-            {
-                name: "performance-analysis",
-                description: "Comprehensive metrics analysis for framework integration and optimization",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        scope: {
-                            type: "string",
-                            enum: [
-                                "full",
-                                "runtime",
-                                "build",
-                                "resources",
-                                "bottlenecks",
-                            ],
-                            default: "full",
-                            description: "Scope of performance analysis",
-                        },
-                        duration: {
-                            type: "number",
-                            default: 30,
-                            description: "Analysis duration in seconds",
-                        },
-                        detailed: {
-                            type: "boolean",
-                            default: false,
-                            description: "Include detailed metrics and recommendations",
-                        },
-                    },
-                },
-            },
-            {
-                name: "bottleneck-detection",
-                description: "Identify performance bottlenecks in framework operations",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        operation: {
-                            type: "string",
-                            description: "Specific operation to analyze",
-                        },
-                        threshold: {
-                            type: "number",
-                            default: 1000,
-                            description: "Performance threshold in milliseconds",
-                        },
-                    },
-                },
-            },
-        ];
-        this.handlers = {
-            "performance-analysis": async (args) => this.handlePerformanceAnalysis(args),
-            "bottleneck-detection": async (args) => this.handleBottleneckDetection(args),
-        };
-        this.setupToolHandlers();
-        frameworkLogger.log("mcp-performance-analysis", "server-initialized", "info");
-    }
-    async handlePerformanceAnalysis(args) {
-        const scope = args?.scope || "full";
-        const duration = args?.duration || 30;
-        const detailed = args?.detailed || false;
-        const jobId = generateJobId("mcp-performance-analysis");
-        await frameworkLogger.log("mcp-performance-analysis", "analysis-started", "info", {
-            scope,
-            duration,
-            detailed,
-        }, undefined, // sessionId
-        jobId);
-        const analysisResults = {
-            metrics: {},
-            bottlenecks: [],
-            recommendations: [],
-            summary: "",
-            passed: true,
-        };
-        try {
-            const startTime = Date.now();
-            // 1. Runtime Performance Analysis
-            if (scope === "runtime" || scope === "full") {
-                const runtimeMetrics = await this.analyzeRuntimePerformance(duration);
-                analysisResults.metrics.runtime = runtimeMetrics;
-                analysisResults.bottlenecks.push(...runtimeMetrics.bottlenecks);
-                analysisResults.recommendations.push(...runtimeMetrics.recommendations);
-            }
-            // 2. Build Performance Analysis
-            if (scope === "build" || scope === "full") {
-                const buildMetrics = await this.analyzeBuildPerformance();
-                analysisResults.metrics.build = buildMetrics;
-                analysisResults.bottlenecks.push(...buildMetrics.bottlenecks);
-                analysisResults.recommendations.push(...buildMetrics.recommendations);
-            }
-            // 3. Resource Usage Analysis
-            if (scope === "resources" || scope === "full") {
-                const resourceMetrics = await this.analyzeResourceUsage();
-                analysisResults.metrics.resources = resourceMetrics;
-                analysisResults.bottlenecks.push(...resourceMetrics.bottlenecks);
-                analysisResults.recommendations.push(...resourceMetrics.recommendations);
-            }
-            // 4. Bottleneck Detection
-            if (scope === "bottlenecks" || scope === "full") {
-                const bottleneckResults = await this.detectBottlenecks();
-                analysisResults.bottlenecks.push(...bottleneckResults.bottlenecks);
-                analysisResults.recommendations.push(...bottleneckResults.recommendations);
-            }
-            const totalTime = Date.now() - startTime;
-            analysisResults.metrics.analysis_time = `${totalTime}ms`;
-            // Check performance thresholds
-            analysisResults.passed = this.checkPerformanceThresholds(analysisResults);
-            // Generate summary
-            analysisResults.summary =
-                this.generatePerformanceSummary(analysisResults);
-        }
-        catch (error) {
-            frameworkLogger.log("mcps/performance-analysis", "analysis", "error", { error: String(error) });
-            analysisResults.passed = false;
-            analysisResults.bottlenecks.push(`Analysis error: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        const response = `📊 0xRay Performance Analysis Results
-
-${analysisResults.summary}
-
-**Analysis Time:** ${analysisResults.metrics.analysis_time || "N/A"}
-
-**Runtime Metrics:**
-${this.formatMetrics(analysisResults.metrics.runtime)}
-
-**Build Metrics:**
-${this.formatMetrics(analysisResults.metrics.build)}
-
-**Resource Metrics:**
-${this.formatMetrics(analysisResults.metrics.resources)}
-
-**Bottlenecks Detected:** ${analysisResults.bottlenecks.length}
-${analysisResults.bottlenecks.length > 0 ? analysisResults.bottlenecks.map((b) => `• 🚧 ${b}`).join("\n") : "None"}
-
-**Recommendations:**
-${analysisResults.recommendations.length > 0 ? analysisResults.recommendations.map((r) => `• 💡 ${r}`).join("\n") : "No recommendations"}
-
-**Overall Status:** ${analysisResults.passed ? "✅ PERFORMANCE ACCEPTABLE" : "❌ PERFORMANCE ISSUES DETECTED"}`;
-        if (detailed) {
-            const detailedReport = await this.generateDetailedReport(analysisResults);
-            return {
-                content: [
-                    { type: "text", text: response },
-                    { type: "text", text: `\n📊 Detailed Report:\n${detailedReport}` },
-                ],
-            };
-        }
-        return {
-            content: [{ type: "text", text: response }],
-        };
-    }
-    async handleBottleneckDetection(args) {
-        const operation = args?.operation || "general";
-        const threshold = args?.threshold || 1000;
-        const jobId = generateJobId("mcp-performance-analysis-bottleneck");
-        await frameworkLogger.log("mcp-performance-analysis", "bottleneck-detection", "info", { operation, threshold }, undefined, // sessionId
-        jobId);
-        try {
-            const results = await this.analyzeSpecificBottlenecks(operation, threshold);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `🔍 Bottleneck Detection Results for "${operation}"
-
-**Threshold:** ${threshold}ms
-
-**Bottlenecks Found:** ${results.bottlenecks.length}
-${results.bottlenecks.map((b) => `• 🚧 ${b}`).join("\n") || "None detected"}
-
-**Performance Impact:** ${results.impact}
-
-**Recommendations:**
-${results.recommendations.map((r) => `• 💡 ${r}`).join("\n") || "No recommendations"}
-
-**Status:** ${results.critical ? "❌ CRITICAL BOTTLENECKS" : "✅ NO CRITICAL ISSUES"}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `❌ Bottleneck detection failed: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    async analyzeRuntimePerformance(duration) {
-        const results = {
-            responseTime: 0,
-            throughput: 0,
-            memoryUsage: 0,
-            cpuUsage: 0,
-            bottlenecks: [],
-            recommendations: [],
-        };
-        try {
-            // Measure memory usage
-            const memUsage = process.memoryUsage();
-            results.memoryUsage = Math.round(memUsage.heapUsed / 1024 / 1024); // MB
-            if (results.memoryUsage > 256) {
-                results.bottlenecks.push(`High memory usage: ${results.memoryUsage}MB > 256MB threshold`);
-                results.recommendations.push("Optimize memory usage through garbage collection and object pooling");
-            }
-            // CPU usage (simplified)
-            const cpuUsage = os.loadavg()[0] || 0;
-            results.cpuUsage = Math.round(cpuUsage * 100) / 100;
-            if (cpuUsage > 0.8) {
-                results.bottlenecks.push(`High CPU usage: ${results.cpuUsage} > 80% threshold`);
-                results.recommendations.push("Optimize CPU-intensive operations and consider load balancing");
-            }
-            // Framework initialization time (if applicable)
-            if (fs.existsSync("src/index.ts")) {
-                const initStart = Date.now();
-                // Simulate initialization check
-                await new Promise((resolve) => setTimeout(resolve, 10));
-                const initTime = Date.now() - initStart;
-                if (initTime > 100) {
-                    results.bottlenecks.push(`Slow initialization: ${initTime}ms > 100ms threshold`);
-                    results.recommendations.push("Optimize framework initialization and lazy loading");
-                }
-            }
-        }
-        catch (error) {
-            results.bottlenecks.push(`Runtime analysis error: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        return results;
-    }
-    async analyzeBuildPerformance() {
-        const results = {
-            buildTime: 0,
-            bundleSize: 0,
-            compressionRatio: 0,
-            bottlenecks: [],
-            recommendations: [],
-        };
-        try {
-            // Check bundle size
-            if (fs.existsSync("dist")) {
-                try {
-                    const { execSync } = await import("child_process");
-                    const sizeOutput = execSync('du -sh dist/ 2>/dev/null || echo "0"', {
-                        encoding: "utf8",
-                    });
-                    const sizeStr = sizeOutput.trim().split("	")[0] || "0";
-                    if (sizeStr.includes("M")) {
-                        results.bundleSize = parseFloat(sizeStr);
-                    }
-                    else if (sizeStr.includes("K")) {
-                        results.bundleSize = parseFloat(sizeStr) / 1024;
-                    }
-                    if (results.bundleSize > 2.0) {
-                        results.bottlenecks.push(`Large bundle size: ${results.bundleSize}MB > 2MB threshold`);
-                        results.recommendations.push("Implement code splitting and tree shaking to reduce bundle size");
-                    }
-                }
-                catch (error) {
-                    // Size check failed
-                }
-            }
-            else {
-                results.recommendations.push("No build output found - run build process to analyze performance");
-            }
-        }
-        catch (error) {
-            results.bottlenecks.push(`Build analysis error: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        return results;
-    }
-    async analyzeResourceUsage() {
-        const results = {
-            totalMemory: 0,
-            freeMemory: 0,
-            diskUsage: 0,
-            networkLatency: 0,
-            bottlenecks: [],
-            recommendations: [],
-        };
-        try {
-            // System memory
-            const totalMem = os.totalmem();
-            const freeMem = os.freemem();
-            results.totalMemory = Math.round(totalMem / 1024 / 1024 / 1024); // GB
-            results.freeMemory = Math.round(freeMem / 1024 / 1024 / 1024); // GB
-            const memUsagePercent = ((totalMem - freeMem) / totalMem) * 100;
-            if (memUsagePercent > 90) {
-                results.bottlenecks.push(`High system memory usage: ${Math.round(memUsagePercent)}%`);
-                results.recommendations.push("Monitor memory-intensive processes and consider memory optimization");
-            }
-            // Disk usage (simplified)
-            const diskUsage = this.getDiskUsage();
-            if (diskUsage > 90) {
-                results.bottlenecks.push(`High disk usage: ${diskUsage}%`);
-                results.recommendations.push("Clean up unnecessary files and archives");
-            }
-        }
-        catch (error) {
-            results.bottlenecks.push(`Resource analysis error: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        return results;
-    }
-    async detectBottlenecks() {
-        const results = {
-            bottlenecks: [],
-            recommendations: [],
-        };
-        try {
-            // Check for common bottlenecks
-            const issues = await this.identifyCommonBottlenecks();
-            results.bottlenecks.push(...issues.bottlenecks);
-            results.recommendations.push(...issues.recommendations);
-        }
-        catch (error) {
-            results.bottlenecks.push(`Bottleneck detection error: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        return results;
-    }
-    async analyzeSpecificBottlenecks(operation, threshold) {
-        const results = {
-            bottlenecks: [],
-            recommendations: [],
-            impact: "Low",
-            critical: false,
-        };
-        try {
-            // Analyze specific operation bottlenecks
-            const startTime = Date.now();
-            // Simulate operation timing
-            await new Promise((resolve) => setTimeout(resolve, Math.random() * 100));
-            const operationTime = Date.now() - startTime;
-            if (operationTime > threshold) {
-                results.bottlenecks.push(`${operation} exceeds threshold: ${operationTime}ms > ${threshold}ms`);
-                results.impact = operationTime > threshold * 2 ? "High" : "Medium";
-                results.critical = operationTime > threshold * 3;
-                results.recommendations.push(`Optimize ${operation} performance - current time: ${operationTime}ms`);
-            }
-        }
-        catch (error) {
-            results.bottlenecks.push(`Operation analysis error: ${error instanceof Error ? error.message : String(error)}`);
-            results.critical = true;
-        }
-        return results;
-    }
-    getDiskUsage() {
-        try {
-            // Simplified disk usage check
-            const output = execSync("df / | tail -1 | awk '{print $5}' | sed 's/%//'", { encoding: "utf8" });
-            return parseInt(output.trim()) || 0;
-        }
-        catch (error) {
-            return 0;
-        }
-    }
-    async identifyCommonBottlenecks() {
-        const results = {
-            bottlenecks: [],
-            recommendations: [],
-        };
-        // Check for large files
-        const largeFiles = this.findLargeFiles();
-        if (largeFiles.length > 0) {
-            results.bottlenecks.push(`Large files detected: ${largeFiles.length} files > 10MB`);
-            results.recommendations.push("Consider compressing or splitting large files");
-        }
-        // Check for too many dependencies
-        if (fs.existsSync("package.json")) {
-            try {
-                const packageJson = JSON.parse(fs.readFileSync("package.json", "utf8"));
-                const depCount = Object.keys(packageJson.dependencies || {}).length;
-                if (depCount > 100) {
-                    results.bottlenecks.push(`High dependency count: ${depCount} packages`);
-                    results.recommendations.push("Audit and remove unnecessary dependencies");
-                }
-            }
-            catch (error) {
-                // Skip dependency check
-            }
-        }
-        return results;
-    }
-    findLargeFiles() {
-        const largeFiles = [];
-        function scanDir(dir) {
-            try {
-                const items = fs.readdirSync(dir);
-                for (const item of items) {
-                    const fullPath = path.join(dir, item);
-                    const stat = fs.statSync(fullPath);
-                    if (stat.isDirectory() &&
-                        !item.startsWith(".") &&
-                        item !== "node_modules") {
-                        scanDir(fullPath);
-                    }
-                    else if (stat.isFile() && stat.size > 10 * 1024 * 1024) {
-                        // 10MB
-                        largeFiles.push(fullPath);
-                    }
-                }
-            }
-            catch (error) {
-                // Skip directories we can't read
-            }
-        }
-        scanDir(".");
-        return largeFiles;
-    }
-    checkPerformanceThresholds(results) {
-        // Check if any critical thresholds are exceeded
-        const bottlenecks = results.bottlenecks || [];
-        const criticalIndicators = [
-            "High memory usage",
-            "High CPU usage",
-            "Large bundle size",
-            "Slow initialization",
-        ];
-        return !bottlenecks.some((b) => criticalIndicators.some((indicator) => b.includes(indicator)));
-    }
-    generatePerformanceSummary(results) {
-        const bottleneckCount = results.bottlenecks.length;
-        const recommendationCount = results.recommendations.length;
-        const status = results.passed ? "✅ ACCEPTABLE" : "❌ ISSUES DETECTED";
-        return `**Performance Summary:** ${status}
-- Bottlenecks: ${bottleneckCount}
-- Recommendations: ${recommendationCount}
-- Analysis Duration: ${results.metrics.analysis_time}`;
-    }
-    formatMetrics(metrics) {
-        if (!metrics)
-            return "Not analyzed";
-        const formatted = Object.entries(metrics)
-            .filter(([key, value]) => !Array.isArray(value))
-            .map(([key, value]) => `• ${key}: ${value}`)
-            .join("\n");
-        return formatted || "No metrics collected";
-    }
-    async generateDetailedReport(results) {
-        let report = "## Detailed Performance Report\n\n";
-        // Runtime details
-        if (results.metrics.runtime) {
-            report += "### Runtime Performance\n";
-            report += `- Memory Usage: ${results.metrics.runtime.memoryUsage}MB\n`;
-            report += `- CPU Usage: ${results.metrics.runtime.cpuUsage}\n`;
-            report += `- Bottlenecks: ${results.metrics.runtime.bottlenecks.length}\n\n`;
-        }
-        // Build details
-        if (results.metrics.build) {
-            report += "### Build Performance\n";
-            report += `- Bundle Size: ${results.metrics.build.bundleSize}MB\n`;
-            report += `- Build Time: ${results.metrics.build.buildTime}ms\n\n`;
-        }
-        // Resource details
-        if (results.metrics.resources) {
-            report += "### Resource Usage\n";
-            report += `- Total Memory: ${results.metrics.resources.totalMemory}GB\n`;
-            report += `- Free Memory: ${results.metrics.resources.freeMemory}GB\n`;
-            report += `- Disk Usage: ${results.metrics.resources.diskUsage}%\n\n`;
-        }
-        return report;
-    }
-}
-// Start the server if run directly
-if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
-    const server = new XrayPerformanceAnalysisServer();
-    server.run().catch((error) => frameworkLogger.log("mcps/performance-analysis", "run", "error", { error: String(error) }));
-}
-export { XrayPerformanceAnalysisServer };

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

@@ -1,29 +0,0 @@
-/**
- * 0xRay Processor Pipeline MCP Server
- *
- * Advanced processor pipeline with codex validation, compliance monitoring, and framework enforcement
- */
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
-declare class XrayProcessorPipelineServer extends XrayKnowledgeSkillBase {
-    private codexLoader;
-    private codexRules;
-    private codexTerms;
-    constructor();
-    private loadCodexRules;
-    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;
-}
-export { XrayProcessorPipelineServer };