0xray 3.1.0 → 3.2.0

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

@@ -9,267 +9,249 @@
  * 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 * as fs from "fs";
 import * as path from "path";
-import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
-class CodeAnalyzerServer {
-    server;
-    tools = [
-        // ===== CODE ANALYSIS =====
-        {
-            name: "analyze_code",
-            description: "Perform comprehensive static analysis on source code files",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    files: {
-                        type: "array",
-                        items: { type: "string" },
-                        description: "Files or directories to analyze",
-                    },
-                    language: {
-                        type: "string",
-                        description: "Programming language (typescript, javascript, python, etc.)",
+class CodeAnalyzerServer extends XrayKnowledgeSkillBase {
+    constructor() {
+        super("code-analyzer", "3.1.0");
+        this.tools = [
+            // ===== CODE ANALYSIS =====
+            {
+                name: "analyze_code",
+                description: "Perform comprehensive static analysis on source code files",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        files: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Files or directories to analyze",
+                        },
+                        language: {
+                            type: "string",
+                            description: "Programming language (typescript, javascript, python, etc.)",
+                        },
                     },
+                    required: ["files"],
                 },
-                required: ["files"],
             },
-        },
-        {
-            name: "calculate_complexity",
-            description: "Calculate cyclomatic complexity and other code metrics",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    code: {
-                        type: "string",
-                        description: "Source code to analyze",
-                    },
-                    language: {
-                        type: "string",
-                        description: "Programming language",
+            {
+                name: "calculate_complexity",
+                description: "Calculate cyclomatic complexity and other code metrics",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        code: {
+                            type: "string",
+                            description: "Source code to analyze",
+                        },
+                        language: {
+                            type: "string",
+                            description: "Programming language",
+                        },
                     },
+                    required: ["code"],
                 },
-                required: ["code"],
             },
-        },
-        {
-            name: "detect_code_smells",
-            description: "Detect code smells, anti-patterns, and potential issues",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    files: {
-                        type: "array",
-                        items: { type: "string" },
-                        description: "Files to analyze",
-                    },
-                    thresholds: {
-                        type: "object",
-                        description: "Detection thresholds",
-                        properties: {
-                            maxFunctionLength: { type: "number" },
-                            maxNestingDepth: { type: "number" },
-                            maxParameters: { type: "number" },
+            {
+                name: "detect_code_smells",
+                description: "Detect code smells, anti-patterns, and potential issues",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        files: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Files to analyze",
+                        },
+                        thresholds: {
+                            type: "object",
+                            description: "Detection thresholds",
+                            properties: {
+                                maxFunctionLength: { type: "number" },
+                                maxNestingDepth: { type: "number" },
+                                maxParameters: { type: "number" },
+                            },
                         },
                     },
+                    required: ["files"],
                 },
-                required: ["files"],
             },
-        },
-        {
-            name: "extract_metrics",
-            description: "Extract detailed code metrics (lines, functions, classes, etc.)",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    filePath: {
-                        type: "string",
-                        description: "File or directory to analyze",
-                    },
-                    includeHistory: {
-                        type: "boolean",
-                        default: false,
-                        description: "Include historical metrics if available",
+            {
+                name: "extract_metrics",
+                description: "Extract detailed code metrics (lines, functions, classes, etc.)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        filePath: {
+                            type: "string",
+                            description: "File or directory to analyze",
+                        },
+                        includeHistory: {
+                            type: "boolean",
+                            default: false,
+                            description: "Include historical metrics if available",
+                        },
                     },
+                    required: ["filePath"],
                 },
-                required: ["filePath"],
             },
-        },
-        // ===== EXPLORE FEATURES =====
-        {
-            name: "explore_codebase",
-            description: "Explore codebase structure and find files matching patterns. Fast file search.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    scope: {
-                        type: "string",
-                        enum: ["full", "directory", "file"],
-                        description: "Scope of exploration",
-                    },
-                    patterns: {
-                        type: "array",
-                        items: { type: "string" },
-                        description: "Glob patterns to match (e.g., '**/*.ts', 'src/**/*.js')",
-                    },
-                    basePath: {
-                        type: "string",
-                        description: "Base directory to search from (defaults to current directory)",
-                    },
-                    maxResults: {
-                        type: "number",
-                        default: 50,
-                        description: "Maximum number of files to return",
+            // ===== EXPLORE FEATURES =====
+            {
+                name: "explore_codebase",
+                description: "Explore codebase structure and find files matching patterns. Fast file search.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        scope: {
+                            type: "string",
+                            enum: ["full", "directory", "file"],
+                            description: "Scope of exploration",
+                        },
+                        patterns: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Glob patterns to match (e.g., '**/*.ts', 'src/**/*.js')",
+                        },
+                        basePath: {
+                            type: "string",
+                            description: "Base directory to search from (defaults to current directory)",
+                        },
+                        maxResults: {
+                            type: "number",
+                            default: 50,
+                            description: "Maximum number of files to return",
+                        },
                     },
+                    required: ["scope", "patterns"],
                 },
-                required: ["scope", "patterns"],
             },
-        },
-        {
-            name: "find_patterns",
-            description: "Find code patterns, functions, classes, or specific text across the codebase",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    pattern: {
-                        type: "string",
-                        description: "Regex or text pattern to search for",
-                    },
-                    fileTypes: {
-                        type: "array",
-                        items: { type: "string" },
-                        description: "File extensions to search (e.g., ['.ts', '.js'])",
-                    },
-                    basePath: {
-                        type: "string",
-                        description: "Base directory to search from",
-                    },
-                    maxMatches: {
-                        type: "number",
-                        default: 100,
-                        description: "Maximum number of matches to return",
+            {
+                name: "find_patterns",
+                description: "Find code patterns, functions, classes, or specific text across the codebase",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        pattern: {
+                            type: "string",
+                            description: "Regex or text pattern to search for",
+                        },
+                        fileTypes: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "File extensions to search (e.g., ['.ts', '.js'])",
+                        },
+                        basePath: {
+                            type: "string",
+                            description: "Base directory to search from",
+                        },
+                        maxMatches: {
+                            type: "number",
+                            default: 100,
+                            description: "Maximum number of matches to return",
+                        },
                     },
+                    required: ["pattern"],
                 },
-                required: ["pattern"],
             },
-        },
-        {
-            name: "find_function",
-            description: "Locate specific function definitions across the codebase",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    functionName: {
-                        type: "string",
-                        description: "Name of the function to find",
-                    },
-                    fileTypes: {
-                        type: "array",
-                        items: { type: "string" },
-                        description: "File types to search",
+            {
+                name: "find_function",
+                description: "Locate specific function definitions across the codebase",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        functionName: {
+                            type: "string",
+                            description: "Name of the function to find",
+                        },
+                        fileTypes: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "File types to search",
+                        },
                     },
+                    required: ["functionName"],
                 },
-                required: ["functionName"],
             },
-        },
-        {
-            name: "get_file_structure",
-            description: "Get directory structure and file tree for a given path",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    path: {
-                        type: "string",
-                        description: "Directory path to explore",
-                    },
-                    maxDepth: {
-                        type: "number",
-                        default: 3,
-                        description: "Maximum depth to traverse",
-                    },
-                    includeFiles: {
-                        type: "boolean",
-                        default: true,
-                        description: "Include files in the output",
+            {
+                name: "get_file_structure",
+                description: "Get directory structure and file tree for a given path",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Directory path to explore",
+                        },
+                        maxDepth: {
+                            type: "number",
+                            default: 3,
+                            description: "Maximum depth to traverse",
+                        },
+                        includeFiles: {
+                            type: "boolean",
+                            default: true,
+                            description: "Include files in the output",
+                        },
                     },
+                    required: ["path"],
                 },
-                required: ["path"],
             },
-        },
-        // ===== DEPENDENCY ANALYSIS =====
-        {
-            name: "analyze_dependencies",
-            description: "Analyze import/export dependencies and generate dependency graph",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    rootDir: {
-                        type: "string",
-                        description: "Root directory to analyze",
-                    },
-                    maxDepth: {
-                        type: "number",
-                        default: 3,
-                        description: "Maximum depth for dependency traversal",
+            // ===== DEPENDENCY ANALYSIS =====
+            {
+                name: "analyze_dependencies",
+                description: "Analyze import/export dependencies and generate dependency graph",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        rootDir: {
+                            type: "string",
+                            description: "Root directory to analyze",
+                        },
+                        maxDepth: {
+                            type: "number",
+                            default: 3,
+                            description: "Maximum depth for dependency traversal",
+                        },
                     },
+                    required: ["rootDir"],
                 },
-                required: ["rootDir"],
             },
-        },
-        // ===== DUPLICATE DETECTION =====
-        {
-            name: "find_duplicates",
-            description: "Find duplicate or similar code patterns in the codebase",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    directory: {
-                        type: "string",
-                        description: "Directory to search",
-                    },
-                    minLength: {
-                        type: "number",
-                        default: 10,
-                        description: "Minimum line count for duplicate detection",
+            // ===== DUPLICATE DETECTION =====
+            {
+                name: "find_duplicates",
+                description: "Find duplicate or similar code patterns in the codebase",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        directory: {
+                            type: "string",
+                            description: "Directory to search",
+                        },
+                        minLength: {
+                            type: "number",
+                            default: 10,
+                            description: "Minimum line count for duplicate detection",
+                        },
                     },
+                    required: ["directory"],
                 },
-                required: ["directory"],
             },
-        },
-    ];
-    constructor() {
-        this.server = new Server({ name: "code-analyzer", version: "1.22.67" }, { 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,
-                };
-            }
-        });
+        ];
+        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 +571,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]}`) {
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
     new CodeAnalyzerServer().run().catch(() => { });
 }
 export default CodeAnalyzerServer;