0xray 3.1.1 → 3.2.0

package/dist/mcps/knowledge-skills/ui-ux-design.server.js

@@ -4,250 +4,33 @@
  * Knowledge skill for user interface and user experience design,
  * component patterns, accessibility compliance, and design system guidance
  */
-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";
-class XrayUIUXDesignServer {
-    server;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+class XrayUIUXDesignServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "ui-ux-design", version: "3.1.0",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
+        super("ui-ux-design", "3.1.0");
+        this.tools = [
+            { name: "analyze_ui_component", description: "Analyze UI component for accessibility, usability, and design best practices", inputSchema: { type: "object", properties: { componentCode: { type: "string", description: "React/Vue/Angular component code to analyze" }, framework: { type: "string", enum: ["react", "vue", "angular", "svelte"], description: "UI framework being used" }, checkAccessibility: { type: "boolean", description: "Include WCAG accessibility analysis", default: true }, checkResponsive: { type: "boolean", description: "Include responsive design analysis", default: true } }, required: ["componentCode", "framework"] } },
+            { name: "design_component", description: "Design a UI component with proper accessibility and UX patterns", inputSchema: { type: "object", properties: { componentType: { type: "string", enum: ["button", "input", "modal", "navigation", "card", "form"], description: "Type of component to design" }, requirements: { type: "string", description: "Functional requirements and use cases" }, framework: { type: "string", enum: ["react", "vue", "angular", "svelte"], description: "Target UI framework" }, accessibility: { type: "boolean", description: "Include accessibility features", default: true } }, required: ["componentType", "requirements", "framework"] } },
+            { name: "audit_accessibility", description: "Perform comprehensive accessibility audit using WCAG guidelines", inputSchema: { type: "object", properties: { htmlContent: { type: "string", description: "HTML content to audit for accessibility" }, cssContent: { type: "string", description: "CSS styles to check for accessibility" }, wcagLevel: { type: "string", enum: ["A", "AA", "AAA"], description: "WCAG conformance level to check", default: "AA" } }, required: ["htmlContent"] } },
+            { name: "generate_design_system", description: "Generate a comprehensive design system with colors, typography, and components", inputSchema: { type: "object", properties: { brandGuidelines: { type: "string", description: "Brand colors, fonts, and style guidelines" }, targetAudience: { type: "string", description: "Target user demographics and preferences" }, platform: { type: "string", enum: ["web", "mobile", "desktop"], description: "Target platform" }, includeAccessibility: { type: "boolean", description: "Include accessibility-compliant design tokens", default: true } }, required: ["brandGuidelines", "platform"] } },
+            { name: "validate_mobile_design", description: "Validate mobile-first design principles including touch targets, responsive typography, and thumb zone optimization", inputSchema: { type: "object", properties: { componentCode: { type: "string", description: "Component code to validate for mobile" }, viewportWidth: { type: "number", description: "Minimum viewport width to validate (default: 320)", default: 320 }, framework: { type: "string", enum: ["react", "vue", "angular", "svelte", "css"], description: "UI framework or CSS" } }, required: ["componentCode"] } },
+            { name: "analyze_visual_hierarchy", description: "Analyze visual hierarchy and cognitive load following 'Don't Make Me Think' principles", inputSchema: { type: "object", properties: { designCode: { type: "string", description: "HTML/CSS/React code of the design to analyze" }, pageType: { type: "string", enum: ["landing", "dashboard", "form", "content", "ecommerce"], description: "Type of page being analyzed" } }, required: ["designCode"] } },
+            { name: "recommend_images", description: "Recommend appropriate image libraries, styles, and optimization strategies for the design context", inputSchema: { type: "object", properties: { context: { type: "string", description: "Design context (e.g., 'hero section', 'product gallery', 'team portraits')" }, style: { type: "string", enum: ["photography", "illustration", "3d", "abstract", "minimal"], description: "Preferred visual style" }, budget: { type: "string", enum: ["free", "low", "premium"], description: "Budget constraint", default: "free" } }, required: ["context"] } },
+        ];
+        this.handlers = {
+            analyze_ui_component: async (args) => this.analyzeUIComponent(args),
+            design_component: async (args) => this.designComponent(args),
+            audit_accessibility: async (args) => this.auditAccessibility(args),
+            generate_design_system: async (args) => this.generateDesignSystem(args),
+            validate_mobile_design: async (args) => this.validateMobileDesign(args),
+            analyze_visual_hierarchy: async (args) => this.analyzeVisualHierarchy(args),
+            recommend_images: async (args) => this.recommendImages(args),
+        };
         this.setupToolHandlers();
-        // Server initialization - removed unnecessary startup logging
-    }
-    setupToolHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "analyze_ui_component",
-                        description: "Analyze UI component for accessibility, usability, and design best practices",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                componentCode: {
-                                    type: "string",
-                                    description: "React/Vue/Angular component code to analyze",
-                                },
-                                framework: {
-                                    type: "string",
-                                    enum: ["react", "vue", "angular", "svelte"],
-                                    description: "UI framework being used",
-                                },
-                                checkAccessibility: {
-                                    type: "boolean",
-                                    description: "Include WCAG accessibility analysis",
-                                    default: true,
-                                },
-                                checkResponsive: {
-                                    type: "boolean",
-                                    description: "Include responsive design analysis",
-                                    default: true,
-                                },
-                            },
-                            required: ["componentCode", "framework"],
-                        },
-                    },
-                    {
-                        name: "design_component",
-                        description: "Design a UI component with proper accessibility and UX patterns",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                componentType: {
-                                    type: "string",
-                                    enum: [
-                                        "button",
-                                        "input",
-                                        "modal",
-                                        "navigation",
-                                        "card",
-                                        "form",
-                                    ],
-                                    description: "Type of component to design",
-                                },
-                                requirements: {
-                                    type: "string",
-                                    description: "Functional requirements and use cases",
-                                },
-                                framework: {
-                                    type: "string",
-                                    enum: ["react", "vue", "angular", "svelte"],
-                                    description: "Target UI framework",
-                                },
-                                accessibility: {
-                                    type: "boolean",
-                                    description: "Include accessibility features",
-                                    default: true,
-                                },
-                            },
-                            required: ["componentType", "requirements", "framework"],
-                        },
-                    },
-                    {
-                        name: "audit_accessibility",
-                        description: "Perform comprehensive accessibility audit using WCAG guidelines",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                htmlContent: {
-                                    type: "string",
-                                    description: "HTML content to audit for accessibility",
-                                },
-                                cssContent: {
-                                    type: "string",
-                                    description: "CSS styles to check for accessibility",
-                                },
-                                wcagLevel: {
-                                    type: "string",
-                                    enum: ["A", "AA", "AAA"],
-                                    description: "WCAG conformance level to check",
-                                    default: "AA",
-                                },
-                            },
-                            required: ["htmlContent"],
-                        },
-                    },
-                    {
-                        name: "generate_design_system",
-                        description: "Generate a comprehensive design system with colors, typography, and components",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                brandGuidelines: {
-                                    type: "string",
-                                    description: "Brand colors, fonts, and style guidelines",
-                                },
-                                targetAudience: {
-                                    type: "string",
-                                    description: "Target user demographics and preferences",
-                                },
-                                platform: {
-                                    type: "string",
-                                    enum: ["web", "mobile", "desktop"],
-                                    description: "Target platform",
-                                },
-                                includeAccessibility: {
-                                    type: "boolean",
-                                    description: "Include accessibility-compliant design tokens",
-                                    default: true,
-                                },
-                            },
-                            required: ["brandGuidelines", "platform"],
-                        },
-                    },
-                    {
-                        name: "validate_mobile_design",
-                        description: "Validate mobile-first design principles including touch targets, responsive typography, and thumb zone optimization",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                componentCode: {
-                                    type: "string",
-                                    description: "Component code to validate for mobile",
-                                },
-                                viewportWidth: {
-                                    type: "number",
-                                    description: "Minimum viewport width to validate (default: 320)",
-                                    default: 320,
-                                },
-                                framework: {
-                                    type: "string",
-                                    enum: ["react", "vue", "angular", "svelte", "css"],
-                                    description: "UI framework or CSS",
-                                },
-                            },
-                            required: ["componentCode"],
-                        },
-                    },
-                    {
-                        name: "analyze_visual_hierarchy",
-                        description: "Analyze visual hierarchy and cognitive load following 'Don't Make Me Think' principles",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                designCode: {
-                                    type: "string",
-                                    description: "HTML/CSS/React code of the design to analyze",
-                                },
-                                pageType: {
-                                    type: "string",
-                                    enum: [
-                                        "landing",
-                                        "dashboard",
-                                        "form",
-                                        "content",
-                                        "ecommerce",
-                                    ],
-                                    description: "Type of page being analyzed",
-                                },
-                            },
-                            required: ["designCode"],
-                        },
-                    },
-                    {
-                        name: "recommend_images",
-                        description: "Recommend appropriate image libraries, styles, and optimization strategies for the design context",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                context: {
-                                    type: "string",
-                                    description: "Design context (e.g., 'hero section', 'product gallery', 'team portraits')",
-                                },
-                                style: {
-                                    type: "string",
-                                    enum: [
-                                        "photography",
-                                        "illustration",
-                                        "3d",
-                                        "abstract",
-                                        "minimal",
-                                    ],
-                                    description: "Preferred visual style",
-                                },
-                                budget: {
-                                    type: "string",
-                                    enum: ["free", "low", "premium"],
-                                    description: "Budget constraint",
-                                    default: "free",
-                                },
-                            },
-                            required: ["context"],
-                        },
-                    },
-                ],
-            };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "analyze_ui_component":
-                    return await this.analyzeUIComponent(args);
-                case "design_component":
-                    return await this.designComponent(args);
-                case "audit_accessibility":
-                    return await this.auditAccessibility(args);
-                case "generate_design_system":
-                    return await this.generateDesignSystem(args);
-                case "validate_mobile_design":
-                    return await this.validateMobileDesign(args);
-                case "analyze_visual_hierarchy":
-                    return await this.analyzeVisualHierarchy(args);
-                case "recommend_images":
-                    return await this.recommendImages(args);
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
     }
+    // setupToolHandlers removed — handled by XrayKnowledgeSkillBase via this.tools + this.handlers
     async analyzeUIComponent(args) {
         const { componentCode, framework, checkAccessibility = true, checkResponsive = true, } = args;
         try {
@@ -1473,63 +1256,6 @@ Available: ${Object.keys(system.components).length} component types
             ],
         };
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        await frameworkLogger.log("ui-ux-design.server", "-xray-ui-ux-design-mcp-server-running-", "info", { message: "xray UI/UX Design MCP Server running..." });
-        const cleanup = async (signal) => {
-            await frameworkLogger.log("ui-ux-design.server", "-received-signal-shutting-down-gracefully-", "info", { message: `Received ${signal}, shutting down gracefully...` });
-            // Set a timeout to force exit if graceful shutdown fails
-            const timeout = setTimeout(() => {
-                frameworkLogger.log("mcps/ui-ux-design", "shutdown", "error", { message: "Graceful shutdown timeout, forcing exit..." });
-                process.exit(1);
-            }, 5000); // 5 second timeout
-            try {
-                if (this.server && typeof this.server.close === "function") {
-                    await this.server.close();
-                }
-                clearTimeout(timeout);
-                await frameworkLogger.log("ui-ux-design.server", "-xray-mcp-server-shut-down-gracefully-", "info", { message: "xray MCP Server shut down gracefully" });
-                process.exit(0);
-            }
-            catch (error) {
-                clearTimeout(timeout);
-                frameworkLogger.log("mcps/ui-ux-design", "shutdown", "error", { message: `Error during server shutdown: ${String(error)}` });
-                process.exit(1);
-            }
-        };
-        // Handle multiple shutdown signals
-        process.on("SIGINT", () => cleanup("SIGINT"));
-        process.on("SIGTERM", () => cleanup("SIGTERM"));
-        process.on("SIGHUP", () => cleanup("SIGHUP"));
-        // Monitor parent process (opencode) and shutdown if it dies
-        const checkParent = async () => {
-            try {
-                process.kill(process.ppid, 0); // Check if parent is alive
-                setTimeout(checkParent, 1000); // Check again in 1 second
-            }
-            catch (error) {
-                // Parent process died, shut down gracefully
-                await frameworkLogger.log("ui-ux-design.server", "-parent-process-opencode-died-shutting-down-mcp-se", "info", {
-                    message: "Parent process (opencode) died, shutting down MCP server...",
-                });
-                cleanup("parent-process-death");
-            }
-        };
-        // Start monitoring parent process
-        setTimeout(checkParent, 2000); // Start checking after 2 seconds
-        // Handle uncaught exceptions and unhandled rejections
-        process.on("uncaughtException", (error) => {
-            frameworkLogger.log("mcps/ui-ux-design", "uncaughtException", "error", { error: String(error) });
-            cleanup("uncaughtException");
-        });
-        process.on("unhandledRejection", (reason, promise) => {
-            frameworkLogger.log("mcps/ui-ux-design", "unhandledRejection", "error", { error: String(reason) });
-            cleanup("unhandledRejection");
-        });
-        process.on("SIGINT", cleanup);
-        process.on("SIGTERM", cleanup);
-    }
 }
 // Run the server if this file is executed directly
 if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {

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: "3.1.0",
-        }, {
-            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", "3.1.0");
+        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,11 +331,6 @@ ${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://${fs.realpathSync(process.argv[1])}`) {

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

@@ -3,68 +3,45 @@
  *
  * 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 fs from "fs";
 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: "3.1.0",
-        }, {
-            capabilities: {
-                tools: {},
+        super("model-health-check", "3.1.0");
+        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;
@@ -215,15 +192,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://${fs.realpathSync(process.argv[1])}`) {
     const server = new XrayModelHealthCheckServer();
-    server.start().catch((error) => frameworkLogger.log("mcps/model-health-check", "run", "error", { error: String(error) }));
+    server.run().catch((error) => frameworkLogger.log("mcps/model-health-check", "run", "error", { error: String(error) }));
 }
 export default XrayModelHealthCheckServer;