0xray 3.1.0 → 3.2.0

package/dist/mcps/knowledge-skills/testing-strategy.server.js

@@ -4,160 +4,31 @@
  * Knowledge skill for test planning, coverage optimization,
  * and testing methodology recommendations
  */
-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 * as path from "path";
 import { frameworkLogger } from "../../core/framework-logger.js";
-import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 import { detectProjectLanguage, LANGUAGE_CONFIGS, } from "../../utils/language-detector.js";
-class XrayTestingStrategyServer {
-    server;
+class XrayTestingStrategyServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "testing-strategy", version: "1.22.67",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
+        super("testing-strategy", "3.1.0");
+        this.tools = [
+            { name: "analyze-test-coverage", description: "Analyze current test coverage and identify gaps", inputSchema: { type: "object", properties: { projectRoot: { type: "string" }, includeBreakdown: { type: "boolean", default: true }, coverageThreshold: { type: "number", default: 80 } }, required: ["projectRoot"] } },
+            { name: "design-test-strategy", description: "Design comprehensive testing strategy for the project", inputSchema: { type: "object", properties: { projectRoot: { type: "string" }, projectType: { type: "string", enum: ["web", "api", "mobile", "desktop"] }, complexity: { type: "string", enum: ["simple", "medium", "complex"] }, timeline: { type: "string", enum: ["agile", "waterfall", "continuous"] } }, required: ["projectRoot"] } },
+            { name: "identify-test-gaps", description: "Identify untested code and recommend test cases", inputSchema: { type: "object", properties: { projectRoot: { type: "string" }, sourceFiles: { type: "array", items: { type: "string" } }, existingTests: { type: "array", items: { type: "string" } } }, required: ["projectRoot"] } },
+            { name: "optimize-test-coverage", description: "Analyze and optimize test coverage patterns", inputSchema: { type: "object", properties: { projectRoot: { type: "string" }, currentCoverage: { type: "number" }, targetCoverage: { type: "number", default: 85 }, focusAreas: { type: "array", items: { type: "string" } } }, required: ["projectRoot"] } },
+            { name: "generate-test-file", description: "Generate test file for a source file with exports", inputSchema: { type: "object", properties: { sourceFile: { type: "string", description: "Path to source file" }, sourceContent: { type: "string", description: "Source file content" }, exports: { type: "array", items: { type: "object", properties: { name: { type: "string" }, type: { type: "string" } } }, description: "Exported functions/classes to test" }, testFilePath: { type: "string", description: "Path for generated test file" }, directory: { type: "string", description: "Project directory" } }, required: ["sourceFile", "sourceContent", "exports", "testFilePath"] } },
+        ];
+        this.handlers = {
+            "analyze-test-coverage": async (args) => this.analyzeTestCoverage(args),
+            "design-test-strategy": async (args) => this.designTestStrategy(args),
+            "identify-test-gaps": async (args) => this.identifyTestGaps(args),
+            "optimize-test-coverage": async (args) => this.optimizeTestCoverage(args),
+            "generate-test-file": async (args) => this.generateTestFile(args),
+        };
         this.setupToolHandlers();
-        // Server initialization - removed unnecessary startup logging
-    }
-    setupToolHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "analyze-test-coverage",
-                        description: "Analyze current test coverage and identify gaps",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                projectRoot: { type: "string" },
-                                includeBreakdown: { type: "boolean", default: true },
-                                coverageThreshold: { type: "number", default: 80 },
-                            },
-                            required: ["projectRoot"],
-                        },
-                    },
-                    {
-                        name: "design-test-strategy",
-                        description: "Design comprehensive testing strategy for the project",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                projectRoot: { type: "string" },
-                                projectType: {
-                                    type: "string",
-                                    enum: ["web", "api", "mobile", "desktop"],
-                                },
-                                complexity: {
-                                    type: "string",
-                                    enum: ["simple", "medium", "complex"],
-                                },
-                                timeline: {
-                                    type: "string",
-                                    enum: ["agile", "waterfall", "continuous"],
-                                },
-                            },
-                            required: ["projectRoot"],
-                        },
-                    },
-                    {
-                        name: "identify-test-gaps",
-                        description: "Identify untested code and recommend test cases",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                projectRoot: { type: "string" },
-                                sourceFiles: { type: "array", items: { type: "string" } },
-                                existingTests: { type: "array", items: { type: "string" } },
-                            },
-                            required: ["projectRoot"],
-                        },
-                    },
-                    {
-                        name: "optimize-test-coverage",
-                        description: "Analyze and optimize test coverage patterns",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                projectRoot: { type: "string" },
-                                currentCoverage: { type: "number" },
-                                targetCoverage: { type: "number", default: 85 },
-                                focusAreas: { type: "array", items: { type: "string" } },
-                            },
-                            required: ["projectRoot"],
-                        },
-                    },
-                    {
-                        name: "generate-test-file",
-                        description: "Generate test file for a source file with exports",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                sourceFile: {
-                                    type: "string",
-                                    description: "Path to source file",
-                                },
-                                sourceContent: {
-                                    type: "string",
-                                    description: "Source file content",
-                                },
-                                exports: {
-                                    type: "array",
-                                    items: {
-                                        type: "object",
-                                        properties: {
-                                            name: { type: "string" },
-                                            type: { type: "string" },
-                                        },
-                                    },
-                                    description: "Exported functions/classes to test",
-                                },
-                                testFilePath: {
-                                    type: "string",
-                                    description: "Path for generated test file",
-                                },
-                                directory: { type: "string", description: "Project directory" },
-                            },
-                            required: [
-                                "sourceFile",
-                                "sourceContent",
-                                "exports",
-                                "testFilePath",
-                            ],
-                        },
-                    },
-                ],
-            };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            try {
-                switch (name) {
-                    case "analyze-test-coverage":
-                        return await this.analyzeTestCoverage(args);
-                    case "design-test-strategy":
-                        return await this.designTestStrategy(args);
-                    case "identify-test-gaps":
-                        return await this.identifyTestGaps(args);
-                    case "optimize-test-coverage":
-                        return await this.optimizeTestCoverage(args);
-                    case "generate-test-file":
-                        return await this.generateTestFile(args);
-                    default:
-                        throw new Error(`Unknown tool: ${name}`);
-                }
-            }
-            catch (error) {
-                frameworkLogger.log("mcps/testing-strategy", "tool", "error", { tool: name, error: String(error) });
-                throw error;
-            }
-        });
     }
+    // setupToolHandlers removed — handled by XrayKnowledgeSkillBase via this.tools + this.handlers
     async analyzeTestCoverage(args) {
         const { projectRoot, includeBreakdown = true, coverageThreshold = 80, } = args;
         const analysis = this.performTestCoverageAnalysis(projectRoot);
@@ -809,18 +680,9 @@ describe("${pathModule.basename(sourceFile, ".ts")}", () => {${testCases}
         ];
         return ignorePatterns.some((pattern) => pattern.test(filePath));
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        // Use centralized shutdown handler
-        createGracefulShutdown({
-            serverName: "testing-strategy.server",
-            server: this.server,
-        });
-    }
 }
 // Start the server if run directly
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
     const server = new XrayTestingStrategyServer();
     server.run().catch(() => { });
 }

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

@@ -4,249 +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: "1.22.67",
-        }, {
-            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 {
@@ -1472,66 +1256,9 @@ 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://${process.argv[1]}`) {
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
     const server = new XrayUIUXDesignServer();
     server.run().catch((error) => frameworkLogger.log("mcps/ui-ux-design", "run", "error", { error: String(error) }));
 }