0xray 2.1.2 → 2.1.4

package/dist/mcps/knowledge-skills/code-analyzer.server.d.ts

@@ -9,9 +9,9 @@
  * This is the SINGLE source for code-level analysis.
  * Use project-analysis for project-level (structure, health).
  */
-declare class CodeAnalyzerServer {
-    private server;
-    private tools;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class CodeAnalyzerServer extends XrayKnowledgeSkillBase {
+    private toolDefinitions;
     constructor();
     private handleAnalyzeCode;
     private calculateCodeMetrics;
@@ -26,6 +26,5 @@ declare class CodeAnalyzerServer {
     private handleGetFileStructure;
     private handleAnalyzeDependencies;
     private handleFindDuplicates;
-    run(): Promise<void>;
 }
 export default CodeAnalyzerServer;

package/dist/mcps/knowledge-skills/code-analyzer.server.js

@@ -9,15 +9,12 @@
  * This is the SINGLE source for code-level analysis.
  * Use project-analysis for project-level (structure, health).
  */
-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 { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
 import * as fs from "fs";
 import * as path from "path";
-import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
-class CodeAnalyzerServer {
-    server;
-    tools = [
+class CodeAnalyzerServer extends XrayKnowledgeSkillBase {
+    toolDefinitions = [
         // ===== CODE ANALYSIS =====
         {
             name: "analyze_code",
@@ -242,34 +239,21 @@ class CodeAnalyzerServer {
         },
     ];
     constructor() {
-        this.server = new Server({ name: "code-analyzer", version: "2.0.1" }, { capabilities: { tools: {} } });
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-            tools: this.tools,
-        }));
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args = {} } = request.params;
-            try {
-                switch (name) {
-                    case "analyze_code": return this.handleAnalyzeCode(args);
-                    case "calculate_complexity": return this.handleCalculateComplexity(args);
-                    case "detect_code_smells": return this.handleDetectCodeSmells(args);
-                    case "extract_metrics": return this.handleExtractMetrics(args);
-                    case "explore_codebase": return this.handleExploreCodebase(args);
-                    case "find_patterns": return this.handleFindPatterns(args);
-                    case "find_function": return this.handleFindFunction(args);
-                    case "get_file_structure": return this.handleGetFileStructure(args);
-                    case "analyze_dependencies": return this.handleAnalyzeDependencies(args);
-                    case "find_duplicates": return this.handleFindDuplicates(args);
-                    default: throw new Error(`Unknown tool: ${name}`);
-                }
-            }
-            catch (error) {
-                return {
-                    content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
-                    isError: true,
-                };
-            }
-        });
+        super("code-analyzer", "2.0.1");
+        this.tools = this.toolDefinitions;
+        this.handlers = {
+            "analyze_code": async (args) => this.handleAnalyzeCode(args),
+            "calculate_complexity": async (args) => this.handleCalculateComplexity(args),
+            "detect_code_smells": async (args) => this.handleDetectCodeSmells(args),
+            "extract_metrics": async (args) => this.handleExtractMetrics(args),
+            "explore_codebase": async (args) => this.handleExploreCodebase(args),
+            "find_patterns": async (args) => this.handleFindPatterns(args),
+            "find_function": async (args) => this.handleFindFunction(args),
+            "get_file_structure": async (args) => this.handleGetFileStructure(args),
+            "analyze_dependencies": async (args) => this.handleAnalyzeDependencies(args),
+            "find_duplicates": async (args) => this.handleFindDuplicates(args),
+        };
+        this.setupToolHandlers();
     }
     handleAnalyzeCode(args) {
         const { files = [], language = "typescript" } = args;
@@ -589,17 +573,8 @@ class CodeAnalyzerServer {
         const duplicates = [...blocks.entries()].filter(([_, f]) => f.length > 1).map(([block, files]) => ({ block: block.substring(0, 100) + "...", files, length: block.split("\n").length }));
         return { content: [{ type: "text", text: JSON.stringify({ totalDuplicates: duplicates.length, duplicates }, null, 2) }] };
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        // Use centralized shutdown handler
-        createGracefulShutdown({
-            serverName: "code-analyzer.server",
-            server: this.server,
-        });
-    }
 }
 if (import.meta.url === `file://${process.argv[1]}`) {
-    new CodeAnalyzerServer().run().catch(() => { });
+    new CodeAnalyzerServer().run("code-analyzer.server").catch((err) => { frameworkLogger.log("code-analyzer", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
 }
 export default CodeAnalyzerServer;

package/dist/mcps/knowledge-skills/code-review.server.d.ts

@@ -4,16 +4,15 @@
  * Knowledge skill for automated code review, quality assessment,
  * and best practices validation - provides comprehensive code quality analysis
  */
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 interface AnalyzeProposalArgs {
     proposalTitle?: string;
     proposalDescription?: string;
     evidence?: string[];
     proposalType?: string;
 }
-declare class XrayCodeReviewServer {
-    private server;
+declare class XrayCodeReviewServer extends XrayKnowledgeSkillBase {
     constructor();
-    private setupToolHandlers;
     private analyzeCodeQuality;
     private reviewPullRequest;
     private checkBestPractices;
@@ -41,6 +40,5 @@ declare class XrayCodeReviewServer {
     private checkStandardsCompliance;
     private generateStandardsRecommendations;
     private calculateComplianceScore;
-    run(): Promise<void>;
 }
 export { XrayCodeReviewServer };

package/dist/mcps/knowledge-skills/code-review.server.js

@@ -4,151 +4,126 @@
  * Knowledge skill for automated code review, quality assessment,
  * and best practices validation - provides comprehensive code quality analysis
  */
-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 { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
 import * as fs from "fs";
 import * as path from "path";
-import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
-class XrayCodeReviewServer {
-    server;
+class XrayCodeReviewServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "code-review", version: "2.0.1",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.setupToolHandlers();
-        // Server initialization - removed unnecessary startup logging
-    }
-    setupToolHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "analyze_code_quality",
-                        description: "Analyze code quality metrics, identify issues, and provide improvement suggestions",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                filePath: {
-                                    type: "string",
-                                    description: "Path to the file to analyze",
-                                },
-                                includeMetrics: {
-                                    type: "boolean",
-                                    description: "Include detailed code metrics in the analysis",
-                                    default: true,
-                                },
-                                focusAreas: {
-                                    type: "array",
-                                    items: {
-                                        type: "string",
-                                        enum: [
-                                            "security",
-                                            "performance",
-                                            "maintainability",
-                                            "style",
-                                            "logic",
-                                        ],
-                                    },
-                                    description: "Specific areas to focus the review on",
-                                },
-                            },
-                            required: ["filePath"],
+        super("code-review", "2.0.1");
+        this.tools = [
+            {
+                name: "analyze_code_quality",
+                description: "Analyze code quality metrics, identify issues, and provide improvement suggestions",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        filePath: {
+                            type: "string",
+                            description: "Path to the file to analyze",
                         },
-                    },
-                    {
-                        name: "review_pull_request",
-                        description: "Review a pull request by analyzing changed files and providing comprehensive feedback",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                files: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "List of file paths to review",
-                                },
-                                baseBranch: {
-                                    type: "string",
-                                    description: "Base branch for comparison",
-                                    default: "main",
-                                },
-                                focusAreas: {
-                                    type: "array",
-                                    items: {
-                                        type: "string",
-                                        enum: [
-                                            "security",
-                                            "performance",
-                                            "maintainability",
-                                            "style",
-                                            "logic",
-                                        ],
-                                    },
-                                    description: "Specific areas to focus the review on",
-                                },
+                        includeMetrics: {
+                            type: "boolean",
+                            description: "Include detailed code metrics in the analysis",
+                            default: true,
+                        },
+                        focusAreas: {
+                            type: "array",
+                            items: {
+                                type: "string",
+                                enum: [
+                                    "security",
+                                    "performance",
+                                    "maintainability",
+                                    "style",
+                                    "logic",
+                                ],
                             },
-                            required: ["files"],
+                            description: "Specific areas to focus the review on",
                         },
                     },
-                    {
-                        name: "check_best_practices",
-                        description: "Check adherence to coding best practices and standards",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                filePath: {
-                                    type: "string",
-                                    description: "Path to the file to check",
-                                },
-                                language: {
-                                    type: "string",
-                                    description: "Programming language (typescript, javascript, python, etc.)",
-                                },
-                                standards: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "Specific standards to check (airbnb, google, microsoft, etc.)",
-                                },
+                    required: ["filePath"],
+                },
+            },
+            {
+                name: "review_pull_request",
+                description: "Review a pull request by analyzing changed files and providing comprehensive feedback",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        files: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "List of file paths to review",
+                        },
+                        baseBranch: {
+                            type: "string",
+                            description: "Base branch for comparison",
+                            default: "main",
+                        },
+                        focusAreas: {
+                            type: "array",
+                            items: {
+                                type: "string",
+                                enum: [
+                                    "security",
+                                    "performance",
+                                    "maintainability",
+                                    "style",
+                                    "logic",
+                                ],
                             },
-                            required: ["filePath"],
+                            description: "Specific areas to focus the review on",
                         },
                     },
-                    {
-                        name: "analyze_proposal",
-                        description: "Analyze an inference proposal (pattern/bug/refactor) from a code-review perspective and return a structured governance decision",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                proposalTitle: { type: "string" },
-                                proposalDescription: { type: "string" },
-                                evidence: { type: "array", items: { type: "string" } },
-                                proposalType: { type: "string" },
-                            },
-                            required: ["proposalTitle", "proposalDescription"],
+                    required: ["files"],
+                },
+            },
+            {
+                name: "check_best_practices",
+                description: "Check adherence to coding best practices and standards",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        filePath: {
+                            type: "string",
+                            description: "Path to the file to check",
+                        },
+                        language: {
+                            type: "string",
+                            description: "Programming language (typescript, javascript, python, etc.)",
+                        },
+                        standards: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Specific standards to check (airbnb, google, microsoft, etc.)",
                         },
                     },
-                ],
-            };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "analyze_code_quality":
-                    return await this.analyzeCodeQuality(args);
-                case "review_pull_request":
-                    return await this.reviewPullRequest(args);
-                case "check_best_practices":
-                    return await this.checkBestPractices(args);
-                case "analyze_proposal":
-                    return await this.analyzeProposal(args);
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
+                    required: ["filePath"],
+                },
+            },
+            {
+                name: "analyze_proposal",
+                description: "Analyze an inference proposal (pattern/bug/refactor) from a code-review perspective and return a structured governance decision",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        proposalTitle: { type: "string" },
+                        proposalDescription: { type: "string" },
+                        evidence: { type: "array", items: { type: "string" } },
+                        proposalType: { type: "string" },
+                    },
+                    required: ["proposalTitle", "proposalDescription"],
+                },
+            },
+        ];
+        this.handlers = {
+            "analyze_code_quality": async (args) => this.analyzeCodeQuality(args),
+            "review_pull_request": async (args) => this.reviewPullRequest(args),
+            "check_best_practices": async (args) => this.checkBestPractices(args),
+            "analyze_proposal": async (args) => this.analyzeProposal(args),
+        };
+        this.setupToolHandlers();
     }
     async analyzeCodeQuality(args) {
         const { filePath, includeMetrics = true, focusAreas } = args;
@@ -829,19 +804,10 @@ class XrayCodeReviewServer {
         }, 0);
         return Math.max(0, baseScore - deductions);
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        // Use centralized shutdown handler
-        createGracefulShutdown({
-            serverName: "code-review.server",
-            server: this.server,
-        });
-    }
 }
 // Run the server if this file is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
     const server = new XrayCodeReviewServer();
-    server.run().catch(() => { });
+    server.run("code-review").catch((err) => { frameworkLogger.log("code-review", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
 }
 export { XrayCodeReviewServer };

package/dist/mcps/knowledge-skills/content-creator.server.d.ts

@@ -4,10 +4,8 @@
  * Content-focused SEO for both human readers and AI search engines.
  * Provides keyword optimization, meta descriptions, headlines, and conversion copy.
  */
-declare class SEOCopywriterServer {
-    private server;
-    private tools;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class SEOCopywriterServer extends XrayKnowledgeSkillBase {
     constructor();
-    run(): Promise<void>;
 }
 export { SEOCopywriterServer };