0xray 3.1.1 → 3.3.0

package/src/mcps/performance-analysis.server.ts

@@ -4,17 +4,12 @@
  * 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";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface AnalysisMetrics {
   runtime?: RuntimeMetrics;
@@ -57,23 +52,73 @@ interface ResourceMetrics {
   recommendations: string[];
 }
 
-class XrayPerformanceAnalysisServer {
-  private server: Server;
+class XrayPerformanceAnalysisServer extends XrayKnowledgeSkillBase {
   private startTime: number;
 
   constructor() {
-    this.server = new Server(
+    super("performance-analysis", "3.1.0");
+
+    this.startTime = Date.now();
+
+    this.tools = [
       {
-        name: "performance-analysis", version: "3.1.0",
+        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",
+            },
+          },
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        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 as Record<string, unknown> | undefined),
+      "bottleneck-detection": async (args) => this.handleBottleneckDetection(args as Record<string, unknown> | undefined),
+    };
 
-    this.startTime = Date.now();
     this.setupToolHandlers();
     frameworkLogger.log(
       "mcp-performance-analysis",
@@ -82,81 +127,6 @@ class XrayPerformanceAnalysisServer {
     );
   }
 
-  private 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",
-                },
-              },
-            },
-          },
-          {
-            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}`);
-      }
-    });
-  }
-
   private async handlePerformanceAnalysis(args: Record<string, unknown> | undefined) {
     const scope = (args?.scope as string) || "full";
     const duration = (args?.duration as number) || 30;
@@ -691,19 +661,6 @@ ${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

package/src/mcps/processor-pipeline.server.ts

@@ -4,16 +4,11 @@
  * Advanced processor pipeline with codex validation, compliance monitoring, and framework enforcement
  */
 
-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 * as fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { CodexLoader } from "../enforcement/loaders/codex-loader.js";
 import type { RuleDefinition, RuleValidationContext } from "../enforcement/types.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface PreProcessorArgs {
   content: string;
@@ -88,8 +83,7 @@ interface FrameworkComplianceResult {
   approved: boolean;
 }
 
-class XrayProcessorPipelineServer {
-  private server: Server;
+class XrayProcessorPipelineServer extends XrayKnowledgeSkillBase {
   private codexLoader: CodexLoader;
   private codexRules: RuleDefinition[] = [];
   private codexTerms: string[] = [
@@ -105,17 +99,80 @@ class XrayProcessorPipelineServer {
   ];
 
   constructor() {
+    super("processor-pipeline", "3.1.0");
     this.codexLoader = new CodexLoader();
-    this.server = new Server(
+
+    this.tools = [
+      {
+        name: "execute-pre-processors",
+        description:
+          "Run pre-execution processors on content with codex validation",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: { type: "string" },
+            context: { type: "object" },
+            validateCodex: { type: "boolean", default: true },
+            strictMode: { type: "boolean", default: false },
+          },
+          required: ["content"],
+        },
+      },
+      {
+        name: "execute-post-processors",
+        description:
+          "Run post-execution processors on results with compliance monitoring",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: { type: "string" },
+            results: { type: "object" },
+            enforceCompliance: { type: "boolean", default: true },
+            auditTrail: { type: "boolean", default: true },
+          },
+          required: ["content"],
+        },
+      },
       {
-        name: "processor-pipeline", version: "3.1.0",
+        name: "codex-validation",
+        description:
+          "Validate content against Universal Development Codex terms",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: { type: "string" },
+            terms: {
+              type: "array",
+              items: { type: "string" },
+              default: ["all"],
+            },
+            strict: { type: "boolean", default: false },
+          },
+          required: ["content"],
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        name: "framework-compliance-check",
+        description:
+          "Check framework compliance and generate enforcement actions",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: { type: "string" },
+            operation: { type: "string" },
+            context: { type: "object" },
+          },
+          required: ["content", "operation"],
         },
       },
-    );
+    ];
+
+    this.handlers = {
+      "execute-pre-processors": async (args) => this.handlePreProcessors(args as PreProcessorArgs),
+      "execute-post-processors": async (args) => this.handlePostProcessors(args as PostProcessorArgs),
+      "codex-validation": async (args) => this.handleCodexValidation(args as CodexValidationArgs),
+      "framework-compliance-check": async (args) => this.handleComplianceCheck(args as ComplianceCheckArgs),
+    };
 
     this.setupToolHandlers();
     this.loadCodexRules();
@@ -143,96 +200,6 @@ class XrayProcessorPipelineServer {
     }
   }
 
-  private setupToolHandlers() {
-    // List available tools
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "execute-pre-processors",
-            description:
-              "Run pre-execution processors on content with codex validation",
-            inputSchema: {
-              type: "object",
-              properties: {
-                content: { type: "string" },
-                context: { type: "object" },
-                validateCodex: { type: "boolean", default: true },
-                strictMode: { type: "boolean", default: false },
-              },
-              required: ["content"],
-            },
-          },
-          {
-            name: "execute-post-processors",
-            description:
-              "Run post-execution processors on results with compliance monitoring",
-            inputSchema: {
-              type: "object",
-              properties: {
-                content: { type: "string" },
-                results: { type: "object" },
-                enforceCompliance: { type: "boolean", default: true },
-                auditTrail: { type: "boolean", default: true },
-              },
-              required: ["content"],
-            },
-          },
-          {
-            name: "codex-validation",
-            description:
-              "Validate content against Universal Development Codex terms",
-            inputSchema: {
-              type: "object",
-              properties: {
-                content: { type: "string" },
-                terms: {
-                  type: "array",
-                  items: { type: "string" },
-                  default: ["all"],
-                },
-                strict: { type: "boolean", default: false },
-              },
-              required: ["content"],
-            },
-          },
-          {
-            name: "framework-compliance-check",
-            description:
-              "Check framework compliance and generate enforcement actions",
-            inputSchema: {
-              type: "object",
-              properties: {
-                content: { type: "string" },
-                operation: { type: "string" },
-                context: { type: "object" },
-              },
-              required: ["content", "operation"],
-            },
-          },
-        ],
-      };
-    });
-
-    // Handle tool calls
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-
-      switch (name) {
-        case "execute-pre-processors":
-          return await this.handlePreProcessors(args as unknown as PreProcessorArgs);
-        case "execute-post-processors":
-          return await this.handlePostProcessors(args as unknown as PostProcessorArgs);
-        case "codex-validation":
-          return await this.handleCodexValidation(args as unknown as CodexValidationArgs);
-        case "framework-compliance-check":
-          return await this.handleComplianceCheck(args as unknown as ComplianceCheckArgs);
-        default:
-          throw new Error(`Unknown tool: ${name}`);
-      }
-    });
-  }
-
   private async handlePreProcessors(args: PreProcessorArgs) {
     const content = args.content;
     const context = args.context || {};
@@ -763,11 +730,6 @@ ${complianceResults.actions.map((a: string) => `• 🔧 ${a}`).join("\n") || "N
     return results;
   }
 
-  async run() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    // Silent start - no console output
-  }
 }
 
 // Start the server if run directly