0xray 2.1.2 → 2.1.4

package/dist/mcps/lint.server.js

@@ -3,100 +3,64 @@
  *
  * Comprehensive ESLint validation and automated code quality checking
  */
-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 { execFileSync } from "child_process";
 import fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
-class XrayLintServer {
-    server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+class XrayLintServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "lint", version: "2.0.1",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.setupToolHandlers();
-        void frameworkLogger.log("lint.server", "-xray-lint-mcp-server-initialized-", "info", { message: "0xRay Lint MCP Server initialized" });
-    }
-    setupToolHandlers() {
-        // List available tools
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "lint",
-                        description: "Comprehensive ESLint validation and automated code quality checking",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                files: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "Specific files to lint (optional - lints all if empty)",
-                                },
-                                fix: {
-                                    type: "boolean",
-                                    default: false,
-                                    description: "Automatically fix linting issues where possible",
-                                },
-                                strict: {
-                                    type: "boolean",
-                                    default: false,
-                                    description: "Use strict linting rules",
-                                },
-                            },
+        super("lint", "2.0.1");
+        this.tools = [
+            {
+                name: "lint",
+                description: "Comprehensive ESLint validation and automated code quality checking",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        files: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Specific files to lint (optional - lints all if empty)",
                         },
-                    },
-                    {
-                        name: "lint-check",
-                        description: "Check code quality without making changes",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                files: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "Files to check",
-                                },
-                                rules: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "Specific ESLint rules to check",
-                                },
-                            },
+                        fix: {
+                            type: "boolean",
+                            default: false,
+                            description: "Automatically fix linting issues where possible",
+                        },
+                        strict: {
+                            type: "boolean",
+                            default: false,
+                            description: "Use strict linting rules",
                         },
                     },
-                ],
-            };
-        });
-        // Handle tool calls
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            try {
-                switch (name) {
-                    case "lint":
-                        return await this.handleLint(args);
-                    case "lint-check":
-                        return await this.handleLintCheck(args);
-                    default:
-                        throw new Error(`Unknown tool: ${name}`);
-                }
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `❌ Tool execution failed: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            },
+            {
+                name: "lint-check",
+                description: "Check code quality without making changes",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        files: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Files to check",
                         },
-                    ],
-                };
-            }
-        });
+                        rules: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Specific ESLint rules to check",
+                        },
+                    },
+                },
+            },
+        ];
+        this.handlers = {
+            "lint": async (args) => this.handleLint(args),
+            "lint-check": async (args) => this.handleLintCheck(args),
+        };
+        this.setupToolHandlers();
+        void frameworkLogger.log("lint.server", "-xray-lint-mcp-server-initialized-", "info", { message: "0xRay Lint MCP Server initialized" });
     }
     async handleLint(args) {
         const files = args.files || [];
@@ -367,15 +331,10 @@ ${checkResults.details.map((d) => `• ${d}`).join("\n")}
 - Warnings: ${results.issues.warnings}
 - Fixed: ${results.issues.fixed}`;
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        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 XrayLintServer();
-    server.run().catch((error) => frameworkLogger.log("mcps/lint", "run", "error", { error: String(error) }));
+    server.run("lint").catch((error) => frameworkLogger.log("mcps/lint", "run", "error", { error: String(error) }));
 }
 export { XrayLintServer };

package/dist/mcps/mcp-client.js

@@ -98,7 +98,7 @@ export class MCPClient extends EventEmitter {
      * Pure MCP mode — simulation and generic fallbacks are disabled.
      */
     get isPureMcpMode() {
-        return process.env.STRRAY_FORCE_MCP_GOVERNANCE === 'true';
+        return (process.env.XRAY_FORCE_MCP_GOVERNANCE) === 'true';
     }
     /**
      * Register default simulation implementations
@@ -375,7 +375,7 @@ export class MCPClient extends EventEmitter {
             // === LAST RESORT: Generic fallback (disabled in pure mode) ===
             if (this.isPureMcpMode) {
                 throw new Error(`[PURE MCP] No real response for ${serverName}/${toolName}. ` +
-                    `All fallbacks are disabled when STRRAY_FORCE_MCP_GOVERNANCE=true.`);
+                    `All fallbacks are disabled when XRAY_FORCE_MCP_GOVERNANCE=true.`);
             }
             const fallbackResult = {
                 content: [

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

@@ -3,14 +3,12 @@
  *
  * Advanced model compatibility validation and dynamic health assessment
  */
-declare class XrayModelHealthCheckServer {
-    private server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XrayModelHealthCheckServer extends XrayKnowledgeSkillBase {
     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

@@ -3,67 +3,44 @@
  *
  * Advanced model compatibility validation and dynamic health assessment
  */
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-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 XrayModelHealthCheckServer {
-    server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+class XrayModelHealthCheckServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "model-health-check", version: "2.0.1",
-        }, {
-            capabilities: {
-                tools: {},
+        super("model-health-check", "2.0.1");
+        this.tools = [
+            {
+                name: "model-health-check",
+                description: "Advanced model compatibility validation and dynamic health assessment",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        models: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Specific models to check (optional - checks all configured if empty)",
+                        },
+                        compatibility: {
+                            type: "boolean",
+                            default: true,
+                            description: "Include compatibility matrix in results",
+                        },
+                        performance: {
+                            type: "boolean",
+                            default: true,
+                            description: "Include performance metrics in results",
+                        },
+                    },
+                },
             },
-        });
+        ];
+        this.handlers = {
+            "model-health-check": async (args) => this.handleModelHealthCheck((args || {})),
+        };
         this.setupToolHandlers();
         frameworkLogger.log("mcps/model-health-check", "initialize", "info");
     }
-    setupToolHandlers() {
-        // List available tools
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "model-health-check",
-                        description: "Advanced model compatibility validation and dynamic health assessment",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                models: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "Specific models to check (optional - checks all configured if empty)",
-                                },
-                                compatibility: {
-                                    type: "boolean",
-                                    default: true,
-                                    description: "Include compatibility matrix in results",
-                                },
-                                performance: {
-                                    type: "boolean",
-                                    default: true,
-                                    description: "Include performance metrics in results",
-                                },
-                            },
-                        },
-                    },
-                ],
-            };
-        });
-        // Handle tool calls
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "model-health-check":
-                    return await this.handleModelHealthCheck((args || {}));
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
-    }
     async handleModelHealthCheck(args) {
         const models = args.models || [modelRouter.getValidatedModel()];
         const includeCompatibility = args.compatibility !== false;
@@ -214,15 +191,10 @@ class XrayModelHealthCheckServer {
         }
         return report;
     }
-    async start() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        frameworkLogger.log("mcps/model-health-check", "start", "info");
-    }
 }
 // Start the server if this file is run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
     const server = new XrayModelHealthCheckServer();
-    server.start().catch((error) => frameworkLogger.log("mcps/model-health-check", "run", "error", { error: String(error) }));
+    server.run("model-health-check").catch((error) => frameworkLogger.log("mcps/model-health-check", "run", "error", { error: String(error) }));
 }
 export default XrayModelHealthCheckServer;

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

@@ -3,11 +3,10 @@
  *
  * Comprehensive metrics analysis for framework integration and optimization
  */
-declare class XrayPerformanceAnalysisServer {
-    private server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XrayPerformanceAnalysisServer extends XrayKnowledgeSkillBase {
     private startTime;
     constructor();
-    private setupToolHandlers;
     private handlePerformanceAnalysis;
     private handleBottleneckDetection;
     private analyzeRuntimePerformance;
@@ -22,6 +21,5 @@ declare class XrayPerformanceAnalysisServer {
     private generatePerformanceSummary;
     private formatMetrics;
     private generateDetailedReport;
-    run(): Promise<void>;
 }
 export { XrayPerformanceAnalysisServer };

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

@@ -3,98 +3,74 @@
  *
  * Comprehensive metrics analysis for framework integration and optimization
  */
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { frameworkLogger, generateJobId } from "../core/framework-logger.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { execSync } from "child_process";
 import fs from "fs";
 import os from "os";
 import path from "path";
-class XrayPerformanceAnalysisServer {
-    server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+class XrayPerformanceAnalysisServer extends XrayKnowledgeSkillBase {
     startTime;
     constructor() {
-        this.server = new Server({
-            name: "performance-analysis", version: "2.0.1",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
+        super("performance-analysis", "2.0.1");
         this.startTime = Date.now();
-        this.setupToolHandlers();
-        frameworkLogger.log("mcp-performance-analysis", "server-initialized", "info");
-    }
-    setupToolHandlers() {
-        // List available tools
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                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",
-                                },
-                            },
+        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",
-                                },
-                            },
+                },
+            },
+            {
+                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",
                         },
                     },
-                ],
-            };
-        });
-        // Handle tool calls
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "performance-analysis":
-                    return await this.handlePerformanceAnalysis(args);
-                case "bottleneck-detection":
-                    return await this.handleBottleneckDetection(args);
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
+                },
+            },
+        ];
+        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";
@@ -503,17 +479,10 @@ ${results.recommendations.map((r) => `• 💡 ${r}`).join("\n") || "No recommen
         }
         return report;
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        const jobId = generateJobId("mcp-performance-analysis-server");
-        await frameworkLogger.log("mcp-performance-analysis", "server-started", "success", {}, undefined, // sessionId
-        jobId);
-    }
 }
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
     const server = new XrayPerformanceAnalysisServer();
-    server.run().catch((error) => frameworkLogger.log("mcps/performance-analysis", "run", "error", { error: String(error) }));
+    server.run("performance-analysis").catch((error) => frameworkLogger.log("mcps/performance-analysis", "run", "error", { error: String(error) }));
 }
 export { XrayPerformanceAnalysisServer };

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

@@ -3,14 +3,13 @@
  *
  * Advanced processor pipeline with codex validation, compliance monitoring, and framework enforcement
  */
-declare class XrayProcessorPipelineServer {
-    private server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XrayProcessorPipelineServer extends XrayKnowledgeSkillBase {
     private codexLoader;
     private codexRules;
     private codexTerms;
     constructor();
     private loadCodexRules;
-    private setupToolHandlers;
     private handlePreProcessors;
     private handlePostProcessors;
     private handleCodexValidation;
@@ -26,6 +25,5 @@ declare class XrayProcessorPipelineServer {
     private performQualityAssurance;
     private detectContentType;
     private checkFrameworkCompliance;
-    run(): Promise<void>;
 }
 export { XrayProcessorPipelineServer };