0xray 4.0.12 → 4.0.13

package/dist/mcps/knowledge-skills/refactoring-strategies.server.js

@@ -1,762 +0,0 @@
-/**
- * xray Refactoring Strategies MCP Server
- *
- * Knowledge skill for code refactoring, technical debt elimination,
- * modernization, and code improvement patterns
- */
-import * as fs from "fs";
-import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
-class XrayRefactoringStrategiesServer extends XrayKnowledgeSkillBase {
-    constructor() {
-        super("refactoring-strategies", "3.1.0");
-        this.tools = [
-            {
-                name: "analyze_technical_debt",
-                description: "Analyze codebase for technical debt and refactoring opportunities",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        codePath: {
-                            type: "string",
-                            description: "Path to code directory to analyze",
-                        },
-                        includeModernization: {
-                            type: "boolean",
-                            description: "Include technology modernization suggestions",
-                            default: true,
-                        },
-                        debtThreshold: {
-                            type: "number",
-                            description: "Minimum debt score to report (0-100)",
-                            default: 20,
-                        },
-                    },
-                    required: ["codePath"],
-                },
-            },
-            {
-                name: "suggest_refactoring",
-                description: "Suggest specific refactoring opportunities for improved code quality",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        filePath: {
-                            type: "string",
-                            description: "Path to specific file to analyze",
-                        },
-                        refactoringTypes: {
-                            type: "array",
-                            items: {
-                                type: "string",
-                                enum: [
-                                    "extract-method",
-                                    "rename-variable",
-                                    "remove-duplicate",
-                                    "simplify-condition",
-                                    "extract-class",
-                                    "move-method",
-                                ],
-                            },
-                            description: "Types of refactoring to focus on",
-                        },
-                        maxSuggestions: {
-                            type: "number",
-                            description: "Maximum number of suggestions to return",
-                            default: 10,
-                        },
-                    },
-                    required: ["filePath"],
-                },
-            },
-            {
-                name: "generate_refactoring_plan",
-                description: "Generate a comprehensive refactoring plan with prioritization",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        codePath: {
-                            type: "string",
-                            description: "Path to codebase for refactoring analysis",
-                        },
-                        timeBudget: {
-                            type: "string",
-                            enum: ["1-week", "1-month", "3-months", "6-months"],
-                            description: "Available time for refactoring",
-                        },
-                        riskTolerance: {
-                            type: "string",
-                            enum: ["low", "medium", "high"],
-                            description: "Risk tolerance for changes",
-                        },
-                        priorities: {
-                            type: "array",
-                            items: { type: "string" },
-                            description: "Specific priorities (performance, maintainability, security)",
-                            default: ["maintainability", "performance"],
-                        },
-                    },
-                    required: ["codePath", "timeBudget"],
-                },
-            },
-            {
-                name: "modernize_codebase",
-                description: "Suggest modernization strategies for outdated code and dependencies",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        codePath: {
-                            type: "string",
-                            description: "Path to codebase to analyze",
-                        },
-                        technologies: {
-                            type: "array",
-                            items: { type: "string" },
-                            description: "Specific technologies to focus on (node, react, etc.)",
-                        },
-                        safeMode: {
-                            type: "boolean",
-                            description: "Only suggest low-risk modernization options",
-                            default: true,
-                        },
-                    },
-                    required: ["codePath"],
-                },
-            },
-        ];
-        this.handlers = {
-            "analyze_technical_debt": async (args) => this.analyzeTechnicalDebt(args),
-            "suggest_refactoring": async (args) => this.suggestRefactoring(args),
-            "generate_refactoring_plan": async (args) => this.generateRefactoringPlan(args),
-            "modernize_codebase": async (args) => this.modernizeCodebase(args),
-        };
-        this.setupToolHandlers();
-    }
-    async analyzeTechnicalDebt(args) {
-        const { codePath, includeModernization = true, debtThreshold = 20 } = args;
-        try {
-            const analysis = await this.performTechnicalDebtAnalysis(codePath, includeModernization);
-            // Filter results based on threshold
-            const significantIssues = analysis.criticalIssues.filter((issue) => this.calculateDebtScore(issue) >= debtThreshold);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Technical Debt Analysis for ${codePath}:\n\n` +
-                            `📊 OVERALL DEBT METRICS\n` +
-                            `Total Technical Debt: ${analysis.totalDebt}/100\n` +
-                            `Maintainability Score: ${analysis.maintainabilityScore}/100\n` +
-                            `Technical Debt Ratio: ${(analysis.technicalDebtRatio * 100).toFixed(1)}%\n\n` +
-                            `💰 DEBT BY CATEGORY\n${Object.entries(analysis.debtByCategory)
-                                .map(([category, score]) => `${category}: ${score}/100`)
-                                .join("\n")}\n\n` +
-                            `🚨 CRITICAL ISSUES (${significantIssues.length})\n${significantIssues
-                                .slice(0, 5)
-                                .map((issue) => `${this.getImpactIcon(issue.impact)} ${issue.type.toUpperCase()}: ${issue.description} (${issue.file}:${issue.line})`)
-                                .join("\n")}\n\n` +
-                            `${includeModernization
-                                ? `🔄 MODERNIZATION OPPORTUNITIES\n${analysis.modernizationOpportunities
-                                    .slice(0, 3)
-                                    .map((mod) => `${mod.technology}: ${mod.currentVersion} → ${mod.recommendedVersion} (${mod.migrationEffort} effort)`)
-                                    .join("\n")}\n\n`
-                                : ""}` +
-                            `💡 RECOMMENDATIONS\n` +
-                            `• Focus on high-impact, low-effort refactoring first\n` +
-                            `• Address critical issues before adding new features\n` +
-                            `• Consider automated testing before major refactoring\n` +
-                            `• Plan modernization in phases to minimize disruption`,
-                    },
-                ],
-                data: {
-                    analysis,
-                    filteredIssues: significantIssues,
-                    recommendations: this.generateDebtRecommendations(analysis),
-                },
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error analyzing technical debt: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    async suggestRefactoring(args) {
-        const { filePath, refactoringTypes, maxSuggestions = 10 } = args;
-        try {
-            const suggestions = await this.analyzeFileForRefactoring(filePath, refactoringTypes);
-            const prioritized = this.prioritizeSuggestions(suggestions).slice(0, maxSuggestions);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Refactoring Suggestions for ${filePath}:\n\n` +
-                            `📋 ANALYSIS RESULTS\n` +
-                            `Total Opportunities: ${suggestions.length}\n` +
-                            `High Impact: ${suggestions.filter((s) => s.impact === "high").length}\n` +
-                            `Low Effort: ${suggestions.filter((s) => s.effort === "low").length}\n\n` +
-                            `🎯 TOP SUGGESTIONS\n${prioritized
-                                .map((suggestion, i) => `${i + 1}. ${this.getRefactoringIcon(suggestion.type)} ${suggestion.type.replace("-", " ").toUpperCase()}\n` +
-                                `   ${suggestion.description}\n` +
-                                `   Impact: ${suggestion.impact.toUpperCase()} | Effort: ${suggestion.effort.toUpperCase()}\n` +
-                                `   Benefits: ${suggestion.benefits.slice(0, 2).join(", ")}`)
-                                .join("\n\n")}\n\n` +
-                            `💡 IMPLEMENTATION NOTES\n` +
-                            `• Start with low-effort, high-impact changes\n` +
-                            `• Ensure comprehensive tests before refactoring\n` +
-                            `• Make small, incremental changes\n` +
-                            `• Run tests after each refactoring step`,
-                    },
-                ],
-                data: {
-                    suggestions: prioritized,
-                    implementationPlan: this.createImplementationPlan(prioritized),
-                },
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error suggesting refactoring: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    async generateRefactoringPlan(args) {
-        const { codePath, timeBudget, riskTolerance, priorities = ["maintainability", "performance"], } = args;
-        try {
-            const fullAnalysis = await this.performTechnicalDebtAnalysis(codePath, false);
-            const plan = this.createPrioritizedRefactoringPlan(fullAnalysis, timeBudget, riskTolerance ?? "medium", priorities);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Refactoring Plan for ${codePath}:\n\n` +
-                            `⏰ TIME BUDGET: ${timeBudget.toUpperCase()}\n` +
-                            `🎯 RISK TOLERANCE: ${(riskTolerance ?? "medium").toUpperCase()}\n` +
-                            `📍 PRIORITIES: ${priorities.join(", ")}\n\n` +
-                            `📊 PLAN OVERVIEW\n` +
-                            `Total Phases: ${plan.phases.length}\n` +
-                            `Estimated Duration: ${plan.totalWeeks} weeks\n` +
-                            `Risk Level: ${plan.overallRisk}\n` +
-                            `Expected Improvement: ${plan.expectedImprovement}%\n\n` +
-                            `🗓️ PHASE-BY-PHASE PLAN\n${plan.phases
-                                .map((phase, i) => `Phase ${i + 1}: ${phase.name} (${phase.duration} weeks)\n` +
-                                `   Focus: ${phase.focus}\n` +
-                                `   Changes: ${phase.changes.length}\n` +
-                                `   Risk: ${phase.risk}\n` +
-                                `   Expected Impact: ${phase.expectedImpact}`)
-                                .join("\n\n")}\n\n` +
-                            `⚠️ IMPORTANT CONSIDERATIONS\n` +
-                            `• Always backup code before refactoring\n` +
-                            `• Run full test suite after each phase\n` +
-                            `• Monitor performance metrics during changes\n` +
-                            `• Have rollback plan for each phase\n` +
-                            `• Communicate changes to team regularly`,
-                    },
-                ],
-                data: {
-                    plan,
-                    riskAssessment: this.assessPlanRisks(plan),
-                    successMetrics: this.defineSuccessMetrics(plan),
-                },
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error generating refactoring plan: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    async modernizeCodebase(args) {
-        const { codePath, technologies, safeMode = true } = args;
-        try {
-            const modernization = await this.analyzeModernizationOpportunities(codePath, technologies ?? [], safeMode);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Codebase Modernization Analysis for ${codePath}:\n\n` +
-                            `🔄 MODERNIZATION OPPORTUNITIES\n` +
-                            `Total Suggestions: ${modernization.suggestions.length}\n` +
-                            `Safe Updates: ${modernization.suggestions.filter((s) => !s.breakingChanges).length}\n` +
-                            `Breaking Changes: ${modernization.suggestions.filter((s) => s.breakingChanges).length}\n\n` +
-                            `📦 DEPENDENCY UPDATES\n${modernization.suggestions
-                                .map((suggestion) => `${this.getMigrationIcon(suggestion.migrationEffort)} ${suggestion.technology}\n` +
-                                `   ${suggestion.currentVersion} → ${suggestion.recommendedVersion}\n` +
-                                `   ${suggestion.breakingChanges ? "⚠️ BREAKING" : "✅ SAFE"}\n` +
-                                `   Benefits: ${suggestion.benefits.slice(0, 2).join(", ")}`)
-                                .join("\n\n")}\n\n` +
-                            `🎯 IMPLEMENTATION STRATEGY\n` +
-                            `1. Start with safe, non-breaking updates\n` +
-                            `2. Update dependencies in groups (testing, UI, core)\n` +
-                            `3. Run comprehensive tests after each update\n` +
-                            `4. Plan breaking changes for major version bumps\n` +
-                            `5. Consider gradual migration for large changes\n\n` +
-                            `⚠️ MIGRATION CONSIDERATIONS\n` +
-                            `• Schedule updates during low-traffic periods\n` +
-                            `• Have rollback plan for each modernization step\n` +
-                            `• Monitor performance after updates\n` +
-                            `• Update documentation to reflect changes`,
-                    },
-                ],
-                data: {
-                    modernization,
-                    migrationStrategy: this.createMigrationStrategy(modernization),
-                    rollbackPlan: this.createRollbackPlan(modernization),
-                },
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error modernizing codebase: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    async performTechnicalDebtAnalysis(codePath, includeModernization) {
-        // Simplified analysis - would be more comprehensive in production
-        const analysis = {
-            totalDebt: 0,
-            debtByCategory: {
-                "code-quality": 0,
-                architecture: 0,
-                performance: 0,
-                maintainability: 0,
-                security: 0,
-            },
-            criticalIssues: [],
-            modernizationOpportunities: [],
-            maintainabilityScore: 85,
-            technicalDebtRatio: 0.15,
-        };
-        if (includeModernization) {
-            analysis.modernizationOpportunities = [
-                {
-                    technology: "Node.js",
-                    currentVersion: "18.x",
-                    recommendedVersion: "20.x",
-                    breakingChanges: false,
-                    migrationEffort: "low",
-                    benefits: ["Better performance", "Security updates", "New features"],
-                    risks: ["Minimal compatibility issues"],
-                },
-                {
-                    technology: "TypeScript",
-                    currentVersion: "5.0",
-                    recommendedVersion: "5.3",
-                    breakingChanges: false,
-                    migrationEffort: "low",
-                    benefits: ["Better type checking", "New language features"],
-                    risks: ["None significant"],
-                },
-            ];
-        }
-        // Calculate debt scores
-        analysis.debtByCategory["code-quality"] = 25;
-        analysis.debtByCategory["maintainability"] = 20;
-        analysis.debtByCategory["performance"] = 15;
-        analysis.totalDebt = Object.values(analysis.debtByCategory).reduce((sum, score) => sum + score, 0);
-        return analysis;
-    }
-    async analyzeFileForRefactoring(filePath, types) {
-        const opportunities = [];
-        try {
-            const fs = await import("fs");
-            const content = fs.readFileSync(filePath, "utf-8");
-            const lines = content.split("\n");
-            lines.forEach((line, index) => {
-                const lineNum = index + 1;
-                // Long method detection
-                if (line.includes("function") ||
-                    (line.includes("const") && line.includes("=>"))) {
-                    const functionStart = index;
-                    let braceCount = 0;
-                    let functionEnd = index;
-                    for (let i = functionStart; i < lines.length; i++) {
-                        const line = lines[i];
-                        const openBraces = line.match(/{/g);
-                        const closeBraces = line.match(/}/g);
-                        braceCount += openBraces ? openBraces.length : 0;
-                        braceCount -= closeBraces ? closeBraces.length : 0;
-                        if (braceCount === 0 && braceCount !== 0) {
-                            functionEnd = i;
-                            break;
-                        }
-                    }
-                    const functionLength = functionEnd - functionStart;
-                    if (functionLength > 30) {
-                        opportunities.push({
-                            type: "extract-method",
-                            file: filePath,
-                            line: lineNum,
-                            description: `Function is ${functionLength} lines long - consider extracting methods`,
-                            impact: "medium",
-                            effort: "medium",
-                            beforeCode: lines
-                                .slice(functionStart, functionEnd + 1)
-                                .join("\n"),
-                            afterCode: "// Extracted into smaller, focused methods",
-                            benefits: [
-                                "Improved readability",
-                                "Easier testing",
-                                "Better maintainability",
-                            ],
-                        });
-                    }
-                }
-                // Duplicate code detection (simplified)
-                if (line.length > 50 &&
-                    line.includes("if") &&
-                    line.includes("return")) {
-                    opportunities.push({
-                        type: "simplify-condition",
-                        file: filePath,
-                        line: lineNum,
-                        description: "Complex conditional logic - consider simplifying",
-                        impact: "low",
-                        effort: "low",
-                        beforeCode: line,
-                        afterCode: "// Simplified conditional logic",
-                        benefits: ["Improved readability", "Reduced complexity"],
-                    });
-                }
-            });
-        }
-        catch (error) {
-            // Skip files that can't be analyzed
-        }
-        return opportunities.filter((opp) => !types || types.includes(opp.type));
-    }
-    prioritizeSuggestions(suggestions) {
-        return suggestions.sort((a, b) => {
-            const scoreA = this.calculatePriorityScore(a);
-            const scoreB = this.calculatePriorityScore(b);
-            return scoreB - scoreA;
-        });
-    }
-    calculatePriorityScore(suggestion) {
-        const impactScores = { high: 3, medium: 2, low: 1 };
-        const effortScores = { low: 3, medium: 2, high: 1 };
-        return impactScores[suggestion.impact] * effortScores[suggestion.effort];
-    }
-    createPrioritizedRefactoringPlan(analysis, timeBudget, riskTolerance, priorities) {
-        const timeLimits = {
-            "1-month": 4,
-            "3-months": 12,
-            "6-months": 26,
-        };
-        const availableWeeks = timeLimits[timeBudget];
-        const riskMultipliers = { low: 0.5, medium: 1, high: 1.5 };
-        const riskMultiplier = riskMultipliers[riskTolerance];
-        // Create phases based on analysis
-        const phases = [
-            {
-                name: "Code Quality Cleanup",
-                duration: Math.min(2, availableWeeks),
-                focus: "Fix linting issues, remove dead code, improve formatting",
-                changes: ["Linting fixes", "Code formatting", "Dead code removal"],
-                risk: "low",
-                expectedImpact: "high",
-            },
-            {
-                name: "Refactoring Core Issues",
-                duration: Math.min(4, Math.max(0, availableWeeks - 2)),
-                focus: "Address high-impact technical debt and refactoring opportunities",
-                changes: [
-                    "Method extraction",
-                    "Class restructuring",
-                    "Dependency cleanup",
-                ],
-                risk: "medium",
-                expectedImpact: "high",
-            },
-            {
-                name: "Architecture Improvements",
-                duration: Math.min(6, Math.max(0, availableWeeks - 6)),
-                focus: "Modernize architecture patterns and improve scalability",
-                changes: [
-                    "Pattern updates",
-                    "Architecture refactoring",
-                    "Performance optimization",
-                ],
-                risk: "high",
-                expectedImpact: "medium",
-            },
-        ].filter((phase) => phase.duration > 0);
-        return {
-            phases,
-            totalWeeks: phases.reduce((sum, phase) => sum + phase.duration, 0),
-            overallRisk: riskTolerance,
-            expectedImprovement: 30 + availableWeeks * 5, // Rough estimate
-            priorities,
-        };
-    }
-    async analyzeModernizationOpportunities(codePath, technologies, safeMode) {
-        const suggestions = [];
-        // Check package.json for dependencies
-        try {
-            const fs = await import("fs");
-            const packagePath = `${codePath}/package.json`;
-            if (fs.existsSync(packagePath)) {
-                const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
-                // Node.js version check
-                if (technologies.includes("node") || technologies.length === 0) {
-                    suggestions.push({
-                        technology: "Node.js",
-                        currentVersion: packageJson.engines?.node || "16.x",
-                        recommendedVersion: "20.x",
-                        breakingChanges: false,
-                        migrationEffort: "low",
-                        benefits: [
-                            "Better performance",
-                            "Security updates",
-                            "New ECMAScript features",
-                        ],
-                        risks: ["Minimal compatibility concerns"],
-                    });
-                }
-                // TypeScript version check
-                if (technologies.includes("typescript") || technologies.length === 0) {
-                    const tsVersion = packageJson.devDependencies?.typescript ||
-                        packageJson.dependencies?.typescript;
-                    if (tsVersion && tsVersion.startsWith("4.")) {
-                        suggestions.push({
-                            technology: "TypeScript",
-                            currentVersion: tsVersion,
-                            recommendedVersion: "^5.3.0",
-                            breakingChanges: false,
-                            migrationEffort: "low",
-                            benefits: [
-                                "Better type inference",
-                                "Improved performance",
-                                "New language features",
-                            ],
-                            risks: ["Minor breaking changes in edge cases"],
-                        });
-                    }
-                }
-            }
-        }
-        catch (error) {
-            // Skip modernization analysis if files can't be read
-        }
-        return {
-            suggestions: safeMode
-                ? suggestions.filter((s) => !s.breakingChanges)
-                : suggestions,
-            summary: {
-                totalSuggestions: suggestions.length,
-                safeUpdates: suggestions.filter((s) => !s.breakingChanges).length,
-                breakingUpdates: suggestions.filter((s) => s.breakingChanges).length,
-            },
-        };
-    }
-    calculateDebtScore(issue) {
-        const impactScores = { high: 30, medium: 20, low: 10 };
-        const effortScores = { high: 10, medium: 20, low: 30 };
-        return impactScores[issue.impact] + effortScores[issue.effort];
-    }
-    generateDebtRecommendations(analysis) {
-        const recommendations = [];
-        if (analysis.totalDebt > 50) {
-            recommendations.push("Prioritize technical debt reduction in next sprint");
-        }
-        if (analysis.criticalIssues.length > 0) {
-            recommendations.push("Address critical issues immediately before they cause production problems");
-        }
-        if (analysis.maintainabilityScore < 70) {
-            recommendations.push("Focus on improving code maintainability through refactoring");
-        }
-        return recommendations;
-    }
-    createImplementationPlan(suggestions) {
-        return {
-            phases: [
-                {
-                    name: "Preparation",
-                    steps: [
-                        "Create comprehensive tests",
-                        "Set up CI/CD for validation",
-                        "Create backup branch",
-                    ],
-                },
-                {
-                    name: "Implementation",
-                    steps: suggestions.map((s) => `Implement ${s.type} refactoring`),
-                    parallel: suggestions.filter((s) => s.effort === "low").length,
-                },
-                {
-                    name: "Validation",
-                    steps: [
-                        "Run full test suite",
-                        "Performance testing",
-                        "Code review",
-                        "Deploy to staging",
-                    ],
-                },
-            ],
-            estimatedTime: suggestions.reduce((sum, s) => {
-                const effortHours = { low: 2, medium: 8, high: 24 };
-                return sum + effortHours[s.effort];
-            }, 0),
-        };
-    }
-    assessPlanRisks(plan) {
-        return {
-            overallRisk: plan.phases.some((p) => p.risk === "high")
-                ? "high"
-                : "medium",
-            riskFactors: [
-                "Breaking changes in refactoring",
-                "Performance regression",
-                "Increased complexity",
-                "Testing gaps",
-            ],
-            mitigationStrategies: [
-                "Comprehensive testing before/after",
-                "Gradual rollout with feature flags",
-                "Performance monitoring and alerting",
-                "Rollback plan for each phase",
-            ],
-        };
-    }
-    defineSuccessMetrics(plan) {
-        return {
-            codeQuality: {
-                target: "Improve maintainability score by 20%",
-                current: "Baseline measurement needed",
-                measurement: "Automated code quality tools",
-            },
-            performance: {
-                target: "No performance regression",
-                current: "Establish performance baselines",
-                measurement: "Automated performance tests",
-            },
-            delivery: {
-                target: `Complete refactoring within ${plan.totalWeeks} weeks`,
-                current: "Track progress weekly",
-                measurement: "Sprint velocity and completion metrics",
-            },
-        };
-    }
-    createMigrationStrategy(modernization) {
-        return {
-            phases: [
-                {
-                    name: "Assessment",
-                    duration: 1,
-                    tasks: [
-                        "Analyze current state",
-                        "Identify dependencies",
-                        "Plan testing strategy",
-                    ],
-                },
-                {
-                    name: "Safe Updates",
-                    duration: 2,
-                    tasks: [
-                        "Update patch versions",
-                        "Update minor versions",
-                        "Validate compatibility",
-                    ],
-                },
-                {
-                    name: "Breaking Changes",
-                    duration: 4,
-                    tasks: [
-                        "Update major versions",
-                        "Refactor breaking changes",
-                        "Update configurations",
-                    ],
-                },
-                {
-                    name: "Optimization",
-                    duration: 2,
-                    tasks: [
-                        "Performance tuning",
-                        "Bundle optimization",
-                        "Cleanup deprecated code",
-                    ],
-                },
-            ],
-            totalDuration: 9,
-            successCriteria: [
-                "All tests passing",
-                "Performance within 5% of baseline",
-                "Zero production incidents during migration",
-                "Documentation updated",
-            ],
-        };
-    }
-    createRollbackPlan(modernization) {
-        return {
-            strategies: [
-                {
-                    type: "Branch-based",
-                    description: "Maintain separate branches for each modernization phase",
-                    effort: "low",
-                    effectiveness: "high",
-                },
-                {
-                    type: "Container-based",
-                    description: "Use containerized deployments with quick rollback",
-                    effort: "medium",
-                    effectiveness: "high",
-                },
-                {
-                    type: "Feature Flags",
-                    description: "Gradually enable features with ability to disable",
-                    effort: "high",
-                    effectiveness: "very-high",
-                },
-            ],
-            emergencyProcedures: [
-                "Immediate rollback to last stable version",
-                "Disable problematic features via feature flags",
-                "Switch to backup infrastructure if needed",
-                "Communicate incident status to stakeholders",
-            ],
-        };
-    }
-    getImpactIcon(impact) {
-        const icons = { high: "🔴", medium: "🟡", low: "🟢" };
-        return icons[impact] || "❓";
-    }
-    getRefactoringIcon(type) {
-        const icons = {
-            "extract-method": "📦",
-            "rename-variable": "🏷️",
-            "remove-duplicate": "🗑️",
-            "simplify-condition": "🔀",
-            "extract-class": "🏗️",
-            "move-method": "🚚",
-        };
-        return icons[type] || "🔧";
-    }
-    getMigrationIcon(effort) {
-        const icons = { low: "🟢", medium: "🟡", high: "🔴" };
-        return icons[effort] || "❓";
-    }
-}
-// Run the server if this file is executed directly
-if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
-    const server = new XrayRefactoringStrategiesServer();
-    server.run().catch(() => { });
-}
-export { XrayRefactoringStrategiesServer };