0xray 4.0.12 → 4.0.13

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

@@ -1,783 +0,0 @@
-/**
- * xray Code Review MCP Server
- *
- * 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";
-import * as fs from "fs";
-import * as path from "path";
-import { isGovernanceLlmConfigured, tryLLMGovernance, } from "../../governance/llm-governance-provider.js";
-import { formatGovernanceVoteText, localConferVote } from "../../governance/local-confer.js";
-class XrayCodeReviewServer extends XrayKnowledgeSkillBase {
-    constructor() {
-        super("code-review", "3.1.0");
-        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",
-                        },
-                        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"],
-                },
-            },
-            {
-                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",
-                        },
-                    },
-                    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.)",
-                        },
-                    },
-                    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();
-        // Server initialization - removed unnecessary startup logging
-    }
-    async analyzeCodeQuality(args) {
-        const { filePath, includeMetrics = true, focusAreas } = args;
-        try {
-            if (!fs.existsSync(filePath)) {
-                throw new Error(`File not found: ${filePath}`);
-            }
-            const content = fs.readFileSync(filePath, "utf-8");
-            const extension = path.extname(filePath).toLowerCase();
-            const language = this.detectLanguage(extension);
-            const issues = this.analyzeCode(content, language, focusAreas);
-            const metrics = includeMetrics
-                ? this.calculateMetrics(content, language)
-                : null;
-            const suggestions = this.generateSuggestions(issues, metrics, language);
-            const overallScore = this.calculateOverallScore(issues, metrics);
-            const result = {
-                file: filePath,
-                issues,
-                metrics: metrics,
-                suggestions,
-                overallScore,
-            };
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Code Review Results for ${filePath}:\n\n` +
-                            `Overall Score: ${overallScore}/100\n\n` +
-                            `Issues Found: ${issues.length}\n` +
-                            (metrics
-                                ? `Lines of Code: ${metrics.linesOfCode}\n` +
-                                    `Cyclomatic Complexity: ${metrics.cyclomaticComplexity}\n` +
-                                    `Comment Ratio: ${(metrics.commentRatio * 100).toFixed(1)}%\n\n`
-                                : "") +
-                            `Key Issues:\n${issues
-                                .slice(0, 10)
-                                .map((issue) => `• ${issue.severity.toUpperCase()}: ${issue.message} (${issue.category})`)
-                                .join("\n")}\n\n` +
-                            `Suggestions:\n${suggestions
-                                .slice(0, 5)
-                                .map((s) => `• ${s}`)
-                                .join("\n")}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error analyzing code quality: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    async reviewPullRequest(args) {
-        const { files, baseBranch = "main", focusAreas } = args;
-        try {
-            const results = [];
-            for (const filePath of files) {
-                if (!fs.existsSync(filePath)) {
-                    continue; // Skip files that don't exist
-                }
-                const content = fs.readFileSync(filePath, "utf-8");
-                const extension = path.extname(filePath).toLowerCase();
-                const language = this.detectLanguage(extension);
-                const issues = this.analyzeCode(content, language, focusAreas);
-                const metrics = this.calculateMetrics(content, language);
-                const suggestions = this.generateSuggestions(issues, metrics, language);
-                const overallScore = this.calculateOverallScore(issues, metrics);
-                results.push({
-                    file: filePath,
-                    issues,
-                    metrics,
-                    suggestions,
-                    overallScore,
-                });
-            }
-            const totalIssues = results.reduce((sum, r) => sum + r.issues.length, 0);
-            const avgScore = results.length > 0
-                ? Math.round(results.reduce((sum, r) => sum + r.overallScore, 0) /
-                    results.length)
-                : 0;
-            const criticalIssues = results.flatMap((r) => r.issues.filter((i) => i.severity === "critical"));
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Pull Request Review Summary:\n\n` +
-                            `Files Reviewed: ${results.length}\n` +
-                            `Total Issues: ${totalIssues}\n` +
-                            `Average Quality Score: ${avgScore}/100\n` +
-                            `Critical Issues: ${criticalIssues.length}\n\n` +
-                            `Quality Scores by File:\n${results
-                                .map((r) => `${r.file}: ${r.overallScore}/100 (${r.issues.length} issues)`)
-                                .join("\n")}\n\n` +
-                            (criticalIssues.length > 0
-                                ? `🚨 Critical Issues:\n${criticalIssues
-                                    .map((issue) => `• ${issue.file}:${issue.line} - ${issue.message}`)
-                                    .join("\n")}\n\n`
-                                : "") +
-                            `Overall Assessment: ${this.assessOverallQuality(avgScore, totalIssues, criticalIssues.length)}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error reviewing pull request: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    async checkBestPractices(args) {
-        const { filePath, language: specifiedLanguage, standards = [] } = args;
-        try {
-            if (!fs.existsSync(filePath)) {
-                throw new Error(`File not found: ${filePath}`);
-            }
-            const content = fs.readFileSync(filePath, "utf-8");
-            const extension = path.extname(filePath).toLowerCase();
-            const detectedLanguage = this.detectLanguage(extension);
-            const language = specifiedLanguage || detectedLanguage;
-            const violations = this.checkStandardsCompliance(content, language, standards);
-            const recommendations = this.generateStandardsRecommendations(violations, language, standards);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Best Practices Check for ${filePath}:\n\n` +
-                            `Language: ${language}\n` +
-                            `Standards Checked: ${standards.length > 0 ? standards.join(", ") : "General best practices"}\n\n` +
-                            `Violations Found: ${violations.length}\n\n` +
-                            `Key Violations:\n${violations
-                                .slice(0, 10)
-                                .map((v) => `• ${v.severity.toUpperCase()}: ${v.rule} - ${v.description}`)
-                                .join("\n")}\n\n` +
-                            `Recommendations:\n${recommendations
-                                .slice(0, 5)
-                                .map((r) => `• ${r}`)
-                                .join("\n")}\n\n` +
-                            `Compliance Score: ${this.calculateComplianceScore(violations)}/100`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error checking best practices: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    detectLanguage(extension) {
-        const languageMap = {
-            ".ts": "typescript",
-            ".tsx": "typescript",
-            ".js": "javascript",
-            ".jsx": "javascript",
-            ".py": "python",
-            ".java": "java",
-            ".cpp": "cpp",
-            ".c": "c",
-            ".cs": "csharp",
-            ".php": "php",
-            ".rb": "ruby",
-            ".go": "go",
-            ".rs": "rust",
-            ".swift": "swift",
-            ".kt": "kotlin",
-            ".scala": "scala",
-        };
-        return languageMap[extension] || "unknown";
-    }
-    /**
-     * Governance-oriented proposal analysis from a code quality perspective.
-     */
-    async analyzeProposal(args) {
-        const { proposalTitle = "", proposalDescription = "", evidence = [], proposalType = "" } = args;
-        const vote = (await tryLLMGovernance("code-review", proposalTitle, proposalDescription, evidence, proposalType)) ??
-            localConferVote({
-                role: "code-review",
-                llmConfigured: isGovernanceLlmConfigured(),
-            });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: formatGovernanceVoteText(vote),
-                },
-            ],
-        };
-    }
-    analyzeCode(content, language, focusAreas) {
-        const issues = [];
-        const lines = content.split("\n");
-        // Security analysis
-        if (!focusAreas || focusAreas.includes("security")) {
-            issues.push(...this.analyzeSecurity(content, lines, language));
-        }
-        // Performance analysis
-        if (!focusAreas || focusAreas.includes("performance")) {
-            issues.push(...this.analyzePerformance(content, lines, language));
-        }
-        // Maintainability analysis
-        if (!focusAreas || focusAreas.includes("maintainability")) {
-            issues.push(...this.analyzeMaintainability(content, lines, language));
-        }
-        // Style analysis
-        if (!focusAreas || focusAreas.includes("style")) {
-            issues.push(...this.analyzeStyle(content, lines, language));
-        }
-        // Logic analysis
-        if (!focusAreas || focusAreas.includes("logic")) {
-            issues.push(...this.analyzeLogic(content, lines, language));
-        }
-        return issues;
-    }
-    analyzeSecurity(content, lines, language) {
-        const issues = [];
-        lines.forEach((line, index) => {
-            const lineNum = index + 1;
-            // SQL injection patterns
-            if (line.includes("query(") &&
-                (line.includes("${") || line.includes("+"))) {
-                issues.push({
-                    type: "error",
-                    category: "security",
-                    line: lineNum,
-                    message: "Potential SQL injection vulnerability",
-                    suggestion: "Use parameterized queries or prepared statements",
-                    severity: "critical",
-                });
-            }
-            // XSS patterns
-            if (line.includes("innerHTML") || line.includes("outerHTML")) {
-                issues.push({
-                    type: "error",
-                    category: "security",
-                    line: lineNum,
-                    message: "Direct HTML manipulation detected",
-                    suggestion: "Use textContent or sanitize HTML input",
-                    severity: "high",
-                });
-            }
-            // Hardcoded secrets
-            if (/(password|secret|key|token)\s*=\s*['"][^'"]*['"]/i.test(line)) {
-                issues.push({
-                    type: "error",
-                    category: "security",
-                    line: lineNum,
-                    message: "Hardcoded secret detected",
-                    suggestion: "Move secrets to environment variables or secure vault",
-                    severity: "critical",
-                });
-            }
-            // eval() usage
-            if (line.includes("eval(")) {
-                issues.push({
-                    type: "error",
-                    category: "security",
-                    line: lineNum,
-                    message: "Use of eval() detected",
-                    suggestion: "Avoid eval() for security reasons",
-                    severity: "high",
-                });
-            }
-        });
-        return issues;
-    }
-    analyzePerformance(content, lines, language) {
-        const issues = [];
-        lines.forEach((line, index) => {
-            const lineNum = index + 1;
-            // Inefficient loops
-            if (line.includes("for") &&
-                line.includes(".length") &&
-                !line.includes("let ")) {
-                issues.push({
-                    type: "warning",
-                    category: "performance",
-                    line: lineNum,
-                    message: "Array length accessed in loop condition",
-                    suggestion: "Cache array length outside the loop",
-                    severity: "medium",
-                });
-            }
-            // Memory leaks (event listeners)
-            if (line.includes("addEventListener") &&
-                !content.includes("removeEventListener")) {
-                issues.push({
-                    type: "warning",
-                    category: "performance",
-                    line: lineNum,
-                    message: "Event listener added without cleanup",
-                    suggestion: "Ensure event listeners are removed when no longer needed",
-                    severity: "medium",
-                });
-            }
-            // Inefficient string concatenation
-            if (language === "javascript" &&
-                line.includes("+") &&
-                line.includes("=")) {
-                issues.push({
-                    type: "warning",
-                    category: "performance",
-                    line: lineNum,
-                    message: "String concatenation in loop may be inefficient",
-                    suggestion: "Consider using array.join() or template literals",
-                    severity: "low",
-                });
-            }
-        });
-        return issues;
-    }
-    analyzeMaintainability(content, lines, language) {
-        const issues = [];
-        // Function length check
-        const functions = content.match(/(?:function|const|let)\s+\w+\s*[=(]\s*(?:\([^)]*\)\s*=>|function\s*\([^)]*\))/g);
-        if (functions) {
-            functions.forEach((func) => {
-                const funcStart = content.indexOf(func);
-                const funcBody = content.substring(funcStart, content.indexOf("}", funcStart) + 1);
-                const funcLines = funcBody.split("\n").length;
-                if (funcLines > 50) {
-                    issues.push({
-                        type: "warning",
-                        category: "maintainability",
-                        line: lines.findIndex((l) => l.includes(func.split(" ")[1] || func)) +
-                            1,
-                        message: `Function too long (${funcLines} lines)`,
-                        suggestion: "Break down into smaller, focused functions",
-                        severity: "medium",
-                    });
-                }
-            });
-        }
-        // Deep nesting check
-        let maxNesting = 0;
-        let currentNesting = 0;
-        lines.forEach((line, index) => {
-            const openBraces = (line.match(/{/g) || []).length;
-            const closeBraces = (line.match(/}/g) || []).length;
-            currentNesting += openBraces - closeBraces;
-            maxNesting = Math.max(maxNesting, currentNesting);
-            if (currentNesting > 4) {
-                issues.push({
-                    type: "warning",
-                    category: "maintainability",
-                    line: index + 1,
-                    message: "Excessive nesting depth",
-                    suggestion: "Extract nested logic into separate functions",
-                    severity: "medium",
-                });
-            }
-        });
-        return issues;
-    }
-    analyzeStyle(content, lines, language) {
-        const issues = [];
-        lines.forEach((line, index) => {
-            const lineNum = index + 1;
-            // Line length check
-            if (line.length > 120) {
-                issues.push({
-                    type: "info",
-                    category: "style",
-                    line: lineNum,
-                    message: "Line too long (>120 characters)",
-                    suggestion: "Break long lines for better readability",
-                    severity: "low",
-                });
-            }
-            // Magic numbers
-            if (/\b\d{2,}\b/.test(line) &&
-                !line.includes("//") &&
-                !line.includes("/*")) {
-                const numbers = line.match(/\b\d{2,}\b/g);
-                if (numbers && numbers.some((n) => parseInt(n) > 1)) {
-                    issues.push({
-                        type: "info",
-                        category: "style",
-                        line: lineNum,
-                        message: "Magic number detected",
-                        suggestion: "Replace magic numbers with named constants",
-                        severity: "low",
-                    });
-                }
-            }
-        });
-        return issues;
-    }
-    analyzeLogic(content, lines, language) {
-        const issues = [];
-        // Check for console.log in production code
-        lines.forEach((line, index) => {
-            if (line.includes("console.log") && !line.includes("//")) {
-                issues.push({
-                    type: "warning",
-                    category: "logic",
-                    line: index + 1,
-                    message: "console.log statement found",
-                    suggestion: "Remove console.log statements or replace with proper logging",
-                    severity: "low",
-                });
-            }
-        });
-        // Check for TODO comments
-        lines.forEach((line, index) => {
-            if (line.includes("TODO") || line.includes("FIXME")) {
-                issues.push({
-                    type: "info",
-                    category: "logic",
-                    line: index + 1,
-                    message: "TODO/FIXME comment found",
-                    suggestion: "Address TODO items or create proper issues",
-                    severity: "low",
-                });
-            }
-        });
-        return issues;
-    }
-    calculateMetrics(content, language) {
-        const lines = content.split("\n");
-        const codeLines = lines.filter((line) => {
-            const trimmed = line.trim();
-            return (trimmed &&
-                !trimmed.startsWith("//") &&
-                !trimmed.startsWith("/*") &&
-                !trimmed.startsWith("*"));
-        });
-        const commentLines = lines.filter((line) => line.trim().startsWith("//") ||
-            line.trim().startsWith("/*") ||
-            line.trim().startsWith("*"));
-        // Simple cyclomatic complexity calculation
-        const complexityKeywords = [
-            "if",
-            "else",
-            "for",
-            "while",
-            "case",
-            "catch",
-            "&&",
-            "||",
-        ];
-        let complexity = 1; // Base complexity
-        complexityKeywords.forEach((keyword) => {
-            const matches = (content.match(new RegExp(`\\b${keyword}\\b`, "g")) || [])
-                .length;
-            complexity += matches;
-        });
-        return {
-            cyclomaticComplexity: complexity,
-            linesOfCode: codeLines.length,
-            commentRatio: commentLines.length / lines.length,
-            duplicateLines: this.calculateDuplicateLines(lines),
-        };
-    }
-    calculateDuplicateLines(lines) {
-        const lineCount = new Map();
-        lines.forEach((line) => {
-            const trimmed = line.trim();
-            if (trimmed) {
-                lineCount.set(trimmed, (lineCount.get(trimmed) || 0) + 1);
-            }
-        });
-        let duplicates = 0;
-        lineCount.forEach((count) => {
-            if (count > 1) {
-                duplicates += count;
-            }
-        });
-        return duplicates;
-    }
-    generateSuggestions(issues, metrics, language) {
-        const suggestions = [];
-        if (issues.length === 0) {
-            suggestions.push("Code quality is excellent! Consider adding more comprehensive tests.");
-        }
-        // Group issues by category and severity
-        const criticalIssues = issues.filter((i) => i.severity === "critical");
-        const highIssues = issues.filter((i) => i.severity === "high");
-        if (criticalIssues.length > 0) {
-            suggestions.push("Address all critical security and error issues before committing.");
-        }
-        if (highIssues.length > 0) {
-            suggestions.push("Review and fix high-priority issues to improve code reliability.");
-        }
-        if (metrics) {
-            if (metrics.cyclomaticComplexity > 20) {
-                suggestions.push("Consider breaking down complex functions to reduce cyclomatic complexity.");
-            }
-            if (metrics.commentRatio < 0.1) {
-                suggestions.push("Add more comments to improve code documentation and maintainability.");
-            }
-            if (metrics.linesOfCode > 500) {
-                suggestions.push("Large files detected. Consider splitting into smaller, focused modules.");
-            }
-        }
-        // Language-specific suggestions
-        switch (language) {
-            case "typescript":
-                suggestions.push("Ensure proper TypeScript type annotations and avoid 'any' types.");
-                break;
-            case "javascript":
-                suggestions.push("Consider migrating to TypeScript for better type safety.");
-                break;
-            case "python":
-                suggestions.push("Follow PEP 8 style guidelines and add type hints.");
-                break;
-        }
-        return suggestions;
-    }
-    calculateOverallScore(issues, metrics) {
-        let score = 100;
-        // Deduct points for issues
-        issues.forEach((issue) => {
-            switch (issue.severity) {
-                case "critical":
-                    score -= 10;
-                    break;
-                case "high":
-                    score -= 5;
-                    break;
-                case "medium":
-                    score -= 2;
-                    break;
-                case "low":
-                    score -= 1;
-                    break;
-            }
-        });
-        // Deduct points for poor metrics
-        if (metrics) {
-            if (metrics.cyclomaticComplexity > 20)
-                score -= 10;
-            if (metrics.commentRatio < 0.05)
-                score -= 5;
-            if (metrics.duplicateLines > 50)
-                score -= 5;
-        }
-        return Math.max(0, Math.min(100, score));
-    }
-    assessOverallQuality(avgScore, totalIssues, criticalIssues) {
-        if (avgScore >= 90 && criticalIssues === 0) {
-            return "✅ EXCELLENT: Code quality is outstanding. Ready for production.";
-        }
-        else if (avgScore >= 75 && criticalIssues === 0) {
-            return "👍 GOOD: Code quality is acceptable. Minor improvements recommended.";
-        }
-        else if (avgScore >= 60) {
-            return "⚠️ NEEDS ATTENTION: Address critical issues and major improvements needed.";
-        }
-        else {
-            return "🚨 CRITICAL: Major quality issues detected. Do not merge without fixes.";
-        }
-    }
-    checkStandardsCompliance(content, language, standards) {
-        const violations = [];
-        // TypeScript specific checks
-        if (language === "typescript") {
-            if (content.includes(": any")) {
-                violations.push({
-                    rule: "no-any",
-                    description: "Avoid using 'any' type",
-                    severity: "medium",
-                });
-            }
-            if (!content.includes("interface") && !content.includes("type")) {
-                violations.push({
-                    rule: "use-types",
-                    description: "Consider using interfaces or types for better type safety",
-                    severity: "low",
-                });
-            }
-        }
-        // JavaScript specific checks
-        if (language === "javascript") {
-            if (content.includes("var ")) {
-                violations.push({
-                    rule: "no-var",
-                    description: "Use 'const' or 'let' instead of 'var'",
-                    severity: "medium",
-                });
-            }
-        }
-        // Python specific checks
-        if (language === "python") {
-            if (content.includes("print(") && !content.includes("#")) {
-                violations.push({
-                    rule: "no-print",
-                    description: "Avoid using print() in production code",
-                    severity: "low",
-                });
-            }
-        }
-        return violations;
-    }
-    generateStandardsRecommendations(violations, language, standards) {
-        const recommendations = [];
-        if (violations.length === 0) {
-            recommendations.push(`Code follows ${language} best practices.`);
-            return recommendations;
-        }
-        violations.forEach((violation) => {
-            recommendations.push(`Fix ${violation.rule}: ${violation.description}`);
-        });
-        // Language-specific recommendations
-        switch (language) {
-            case "typescript":
-                recommendations.push("Enable strict TypeScript settings for better type checking.");
-                break;
-            case "javascript":
-                recommendations.push("Consider using ESLint with a comprehensive ruleset.");
-                break;
-            case "python":
-                recommendations.push("Use black for code formatting and flake8 for linting.");
-                break;
-        }
-        return recommendations;
-    }
-    calculateComplianceScore(violations) {
-        const baseScore = 100;
-        const deductions = violations.reduce((total, violation) => {
-            switch (violation.severity) {
-                case "high":
-                    return total + 10;
-                case "medium":
-                    return total + 5;
-                case "low":
-                    return total + 2;
-                default:
-                    return total + 1;
-            }
-        }, 0);
-        return Math.max(0, baseScore - deductions);
-    }
-}
-// Run the server if this file is executed directly
-if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
-    const server = new XrayCodeReviewServer();
-    server.run().catch(() => { });
-}
-export { XrayCodeReviewServer };