0xray 4.0.12 → 4.0.13

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

@@ -1,689 +0,0 @@
-/**
- * xray Testing Strategy MCP Server
- *
- * Knowledge skill for test planning, coverage optimization,
- * and testing methodology recommendations
- */
-import * as fs from "fs";
-import * as path from "path";
-import { frameworkLogger } from "../../core/framework-logger.js";
-import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
-import { detectProjectLanguage, LANGUAGE_CONFIGS, } from "../../utils/language-detector.js";
-class XrayTestingStrategyServer extends XrayKnowledgeSkillBase {
-    constructor() {
-        super("testing-strategy", "3.1.0");
-        this.tools = [
-            { name: "analyze-test-coverage", description: "Analyze current test coverage and identify gaps", inputSchema: { type: "object", properties: { projectRoot: { type: "string" }, includeBreakdown: { type: "boolean", default: true }, coverageThreshold: { type: "number", default: 80 } }, required: ["projectRoot"] } },
-            { name: "design-test-strategy", description: "Design comprehensive testing strategy for the project", inputSchema: { type: "object", properties: { projectRoot: { type: "string" }, projectType: { type: "string", enum: ["web", "api", "mobile", "desktop"] }, complexity: { type: "string", enum: ["simple", "medium", "complex"] }, timeline: { type: "string", enum: ["agile", "waterfall", "continuous"] } }, required: ["projectRoot"] } },
-            { name: "identify-test-gaps", description: "Identify untested code and recommend test cases", inputSchema: { type: "object", properties: { projectRoot: { type: "string" }, sourceFiles: { type: "array", items: { type: "string" } }, existingTests: { type: "array", items: { type: "string" } } }, required: ["projectRoot"] } },
-            { name: "optimize-test-coverage", description: "Analyze and optimize test coverage patterns", inputSchema: { type: "object", properties: { projectRoot: { type: "string" }, currentCoverage: { type: "number" }, targetCoverage: { type: "number", default: 85 }, focusAreas: { type: "array", items: { type: "string" } } }, required: ["projectRoot"] } },
-            { name: "generate-test-file", description: "Generate test file for a source file with exports", inputSchema: { type: "object", properties: { sourceFile: { type: "string", description: "Path to source file" }, sourceContent: { type: "string", description: "Source file content" }, exports: { type: "array", items: { type: "object", properties: { name: { type: "string" }, type: { type: "string" } } }, description: "Exported functions/classes to test" }, testFilePath: { type: "string", description: "Path for generated test file" }, directory: { type: "string", description: "Project directory" } }, required: ["sourceFile", "sourceContent", "exports", "testFilePath"] } },
-        ];
-        this.handlers = {
-            "analyze-test-coverage": async (args) => this.analyzeTestCoverage(args),
-            "design-test-strategy": async (args) => this.designTestStrategy(args),
-            "identify-test-gaps": async (args) => this.identifyTestGaps(args),
-            "optimize-test-coverage": async (args) => this.optimizeTestCoverage(args),
-            "generate-test-file": async (args) => this.generateTestFile(args),
-        };
-        this.setupToolHandlers();
-    }
-    // setupToolHandlers removed — handled by XrayKnowledgeSkillBase via this.tools + this.handlers
-    async analyzeTestCoverage(args) {
-        const { projectRoot, includeBreakdown = true, coverageThreshold = 80, } = args;
-        const analysis = this.performTestCoverageAnalysis(projectRoot);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        projectRoot,
-                        analysis,
-                        threshold: coverageThreshold,
-                        status: analysis.coverage >= coverageThreshold
-                            ? "adequate"
-                            : "insufficient",
-                        analyzedAt: new Date().toISOString(),
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async designTestStrategy(args) {
-        const { projectRoot, projectType = "web", complexity = "medium", timeline = "agile" } = args;
-        const strategy = this.generateTestStrategy(projectRoot, projectType, complexity, timeline);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        projectRoot,
-                        strategy,
-                        recommendations: this.generateStrategyRecommendations(strategy, projectType),
-                        implementation: this.createImplementationPlan(strategy, timeline),
-                        analyzedAt: new Date().toISOString(),
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async identifyTestGaps(args) {
-        const { projectRoot, sourceFiles, existingTests } = args;
-        const gaps = this.analyzeTestGaps(sourceFiles || [], existingTests || []);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        projectRoot,
-                        gaps,
-                        coverage: this.calculateGapCoverage(gaps, sourceFiles?.length || 0),
-                        recommendations: this.generateGapRecommendations(gaps),
-                        analyzedAt: new Date().toISOString(),
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async optimizeTestCoverage(args) {
-        const { projectRoot, currentCoverage, targetCoverage = 85, focusAreas, } = args;
-        const optimization = this.createCoverageOptimizationPlan(projectRoot, currentCoverage ?? 0, targetCoverage, focusAreas);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        projectRoot,
-                        optimization,
-                        timeline: this.estimateOptimizationTimeline(optimization),
-                        roi: this.calculateOptimizationROI(optimization),
-                        analyzedAt: new Date().toISOString(),
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async generateTestFile(args) {
-        const { sourceFile, sourceContent, exports, testFilePath, directory } = args;
-        await frameworkLogger.log('testing-strategy.server', 'generate-test-file-called', 'info', { message: `[testing-strategy] generateTestFile called:` });
-        await frameworkLogger.log('testing-strategy.server', 'source-file', 'info', { sourceFile });
-        await frameworkLogger.log('testing-strategy.server', 'test-file-path', 'info', { testFilePath });
-        await frameworkLogger.log('testing-strategy.server', 'directory', 'info', { directory });
-        await frameworkLogger.log('testing-strategy.server', 'exports', 'info', { exports: JSON.stringify(exports) });
-        // Use dynamic import for ESM compatibility
-        const fs = await import("fs");
-        const pathModule = await import("path");
-        // Resolve paths relative to the project directory
-        const projectDir = directory || process.cwd();
-        const resolvedTestPath = pathModule.isAbsolute(testFilePath)
-            ? testFilePath
-            : pathModule.join(projectDir, testFilePath);
-        await frameworkLogger.log('testing-strategy.server', 'resolved-test-path', 'info', { resolvedTestPath });
-        const testDir = pathModule.dirname(resolvedTestPath);
-        // Ensure test directory exists
-        if (!fs.existsSync(testDir)) {
-            fs.mkdirSync(testDir, { recursive: true });
-        }
-        const relativeSourcePath = pathModule.relative(testDir, sourceFile.replace(/\.ts$/, ""));
-        const importPath = relativeSourcePath.startsWith(".")
-            ? relativeSourcePath
-            : `./${relativeSourcePath}`;
-        // Generate test content
-        const imports = exports.map((e) => e.name).join(", ");
-        const testCases = exports
-            .map((exp) => {
-            if (exp.type === "function") {
-                return `
-  describe("${exp.name}", () => {
-    it("should be defined", () => {
-      expect(typeof ${exp.name}).toBe("function");
-    });
-
-    it("should handle basic case", async () => {
-      const result = await ${exp.name}();
-      expect(result).toBeDefined();
-    });
-  });`;
-            }
-            else if (exp.type === "class") {
-                return `
-  describe("${exp.name}", () => {
-    it("should instantiate", () => {
-      const instance = new ${exp.name}();
-      expect(instance).toBeInstanceOf(${exp.name});
-    });
-  });`;
-            }
-            else {
-                return `
-  describe("${exp.name}", () => {
-    it("should be defined", () => {
-      expect(${exp.name}).toBeDefined();
-    });
-  });`;
-            }
-        })
-            .join("\n");
-        const testContent = `/**
- * Auto-generated test file for ${sourceFile}
- * Generated by xray Testing Strategy Server
- * @generated
- */
-
-import { describe, it, expect } from "vitest";
-import { ${imports} } from "${importPath}";
-
-describe("${pathModule.basename(sourceFile, ".ts")}", () => {${testCases}
-});
-`;
-        // Write the test file
-        fs.writeFileSync(resolvedTestPath, testContent, "utf8");
-        await frameworkLogger.log('testing-strategy.server', 'test-file-written', 'info', { resolvedTestPath });
-        await frameworkLogger.log('testing-strategy.server', 'file-exists', 'info', { resolvedTestPath, exists: fs.existsSync(resolvedTestPath) });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        success: true,
-                        testFile: testFilePath,
-                        exportsGenerated: exports.length,
-                        message: `Test file generated successfully at ${testFilePath}`,
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    // Helper methods
-    performTestCoverageAnalysis(projectRoot) {
-        const testFiles = this.findTestFiles(projectRoot);
-        const sourceFiles = this.findSourceFiles(projectRoot);
-        const analysis = {
-            coverage: this.calculateCoverage(testFiles, sourceFiles),
-            testTypes: this.categorizeTests(testFiles),
-            testFrameworks: this.detectTestFrameworks(testFiles),
-            testPatterns: this.analyzeTestPatterns(testFiles),
-            gaps: this.identifyCoverageGaps(sourceFiles, testFiles),
-            recommendations: [],
-        };
-        analysis.recommendations = this.generateCoverageRecommendations(analysis);
-        return analysis;
-    }
-    generateTestStrategy(projectRoot, projectType, complexity, timeline) {
-        const baseTests = this.estimateBaseTestCounts(projectType, complexity);
-        // Adjust for timeline
-        const multiplier = timeline === "agile" ? 1.2 : timeline === "continuous" ? 1.4 : 1.0;
-        return {
-            unitTests: Math.round(baseTests.unit * multiplier),
-            integrationTests: Math.round(baseTests.integration * multiplier),
-            e2eTests: Math.round(baseTests.e2e * multiplier),
-            performanceTests: Math.round(baseTests.performance * multiplier),
-            securityTests: Math.round(baseTests.security * multiplier),
-            totalEstimated: 0, // Will be calculated
-        };
-    }
-    analyzeTestGaps(sourceFiles, existingTests) {
-        const gaps = [];
-        for (const sourceFile of sourceFiles) {
-            const expectedTest = this.generateExpectedTestFile(sourceFile);
-            const hasTest = existingTests.some((test) => test.includes(expectedTest));
-            if (!hasTest) {
-                gaps.push({
-                    sourceFile,
-                    expectedTest,
-                    type: this.inferTestType(sourceFile),
-                    priority: this.calculateTestPriority(sourceFile),
-                    complexity: this.estimateTestComplexity(sourceFile),
-                });
-            }
-        }
-        return gaps.sort((a, b) => b.priority - a.priority);
-    }
-    createCoverageOptimizationPlan(projectRoot, currentCoverage, targetCoverage, focusAreas) {
-        const gap = targetCoverage - currentCoverage;
-        const plan = {
-            currentCoverage,
-            targetCoverage,
-            gap,
-            phases: [],
-            estimatedEffort: this.estimateOptimizationEffort(gap),
-            priorityAreas: this.identifyPriorityAreas(projectRoot, focusAreas),
-        };
-        // Create optimization phases
-        if (gap > 0) {
-            plan.phases = this.createOptimizationPhases(gap, focusAreas);
-        }
-        return plan;
-    }
-    // Implementation helpers
-    findTestFiles(projectRoot) {
-        return this.findFiles(projectRoot, (file) => file.includes(".test.") ||
-            file.includes(".spec.") ||
-            file.includes("/__tests__/"));
-    }
-    findSourceFiles(projectRoot) {
-        // Use language detector to find supported extensions
-        const projectLanguage = detectProjectLanguage(projectRoot);
-        const langConfig = projectLanguage
-            ? LANGUAGE_CONFIGS.find((c) => c.language === projectLanguage.language)
-            : null;
-        const supportedExtensions = langConfig?.extensions || [
-            ".ts",
-            ".js",
-            ".tsx",
-            ".jsx",
-            ".py",
-            ".java",
-            ".go",
-            ".rs",
-            ".cs",
-            ".rb",
-            ".php",
-        ];
-        return this.findFiles(projectRoot, (file) => {
-            const ext = path.extname(file);
-            return (supportedExtensions.includes(ext) &&
-                !file.includes(".test.") &&
-                !file.includes(".spec.") &&
-                !file.includes("/__tests__/"));
-        });
-    }
-    findFiles(projectRoot, filter) {
-        const files = [];
-        const traverse = (dir) => {
-            try {
-                const entries = fs.readdirSync(dir, { withFileTypes: true });
-                for (const entry of entries) {
-                    const entryPath = path.join(dir, entry.name);
-                    if (this.shouldIgnorePath(entryPath))
-                        continue;
-                    if (entry.isFile() && filter(entryPath)) {
-                        files.push(entryPath);
-                    }
-                    else if (entry.isDirectory()) {
-                        traverse(entryPath);
-                    }
-                }
-            }
-            catch (error) {
-                // Skip inaccessible directories
-            }
-        };
-        traverse(projectRoot);
-        return files;
-    }
-    calculateCoverage(testFiles, sourceFiles) {
-        if (sourceFiles.length === 0)
-            return 0;
-        return Math.min(100, Math.round((testFiles.length / sourceFiles.length) * 100));
-    }
-    categorizeTests(testFiles) {
-        const categories = {
-            unit: 0,
-            integration: 0,
-            e2e: 0,
-            performance: 0,
-            security: 0,
-        };
-        for (const testFile of testFiles) {
-            const content = fs.readFileSync(testFile, "utf8").toLowerCase();
-            if (content.includes("integration") || content.includes("e2e")) {
-                categories.integration = (categories.integration || 0) + 1;
-            }
-            else if (content.includes("performance") ||
-                content.includes("benchmark")) {
-                categories.performance = (categories.performance || 0) + 1;
-            }
-            else if (content.includes("security") || content.includes("auth")) {
-                categories.security = (categories.security || 0) + 1;
-            }
-            else {
-                categories.unit = (categories.unit || 0) + 1;
-            }
-        }
-        return categories;
-    }
-    detectTestFrameworks(testFiles) {
-        const frameworks = [];
-        const sampleFiles = testFiles.slice(0, 5);
-        for (const file of sampleFiles) {
-            try {
-                const content = fs.readFileSync(file, "utf8");
-                if (content.includes("describe(") && content.includes("it(")) {
-                    if (content.includes("vitest"))
-                        frameworks.push("vitest");
-                    else if (content.includes("jest"))
-                        frameworks.push("jest");
-                    else
-                        frameworks.push("mocha/chai");
-                }
-                if (content.includes("pytest"))
-                    frameworks.push("pytest");
-                if (content.includes("junit"))
-                    frameworks.push("junit");
-            }
-            catch (error) {
-                // Skip
-            }
-        }
-        return Array.from(new Set(frameworks));
-    }
-    analyzeTestPatterns(testFiles) {
-        const patterns = [];
-        const sampleFiles = testFiles.slice(0, 3);
-        for (const file of sampleFiles) {
-            try {
-                const content = fs.readFileSync(file, "utf8");
-                if (content.includes("beforeEach") || content.includes("afterEach")) {
-                    patterns.push("setup/teardown");
-                }
-                if (content.includes("mock") || content.includes("stub")) {
-                    patterns.push("mocking");
-                }
-                if (content.includes("fixture") || content.includes("factory")) {
-                    patterns.push("test data factories");
-                }
-            }
-            catch (error) {
-                // Skip
-            }
-        }
-        return Array.from(new Set(patterns));
-    }
-    identifyCoverageGaps(sourceFiles, testFiles) {
-        const gaps = [];
-        for (const sourceFile of sourceFiles) {
-            const hasTest = testFiles.some((testFile) => testFile
-                .replace(".test.", ".")
-                .replace(".spec.", ".")
-                .replace("/__tests__/", "/")
-                .includes(path.basename(sourceFile, path.extname(sourceFile))));
-            if (!hasTest) {
-                gaps.push(sourceFile);
-            }
-        }
-        return gaps;
-    }
-    generateCoverageRecommendations(analysis) {
-        const recommendations = [];
-        if (analysis.coverage < 70) {
-            recommendations.push("Increase test coverage to at least 80%");
-        }
-        if ((analysis.testTypes.unit || 0) < (analysis.testTypes.integration || 0)) {
-            recommendations.push("Focus more on unit tests before integration tests");
-        }
-        if (analysis.gaps.length > 5) {
-            recommendations.push(`Address ${analysis.gaps.length} files without test coverage`);
-        }
-        return recommendations;
-    }
-    estimateBaseTestCounts(projectType, complexity) {
-        const baseMultipliers = {
-            web: { unit: 10, integration: 3, e2e: 2, performance: 1, security: 1 },
-            api: { unit: 8, integration: 4, e2e: 1, performance: 2, security: 2 },
-            mobile: { unit: 12, integration: 5, e2e: 3, performance: 1, security: 1 },
-            desktop: {
-                unit: 15,
-                integration: 4,
-                e2e: 2,
-                performance: 1,
-                security: 1,
-            },
-        };
-        const complexityMultipliers = {
-            simple: 0.7,
-            medium: 1.0,
-            complex: 1.5,
-        };
-        const base = baseMultipliers[projectType] ||
-            baseMultipliers.web;
-        const multiplier = complexityMultipliers[complexity] ||
-            1.0;
-        return {
-            unit: Math.round(base.unit * multiplier),
-            integration: Math.round(base.integration * multiplier),
-            e2e: Math.round(base.e2e * multiplier),
-            performance: Math.round(base.performance * multiplier),
-            security: Math.round(base.security * multiplier),
-        };
-    }
-    generateStrategyRecommendations(strategy, projectType) {
-        const recommendations = [];
-        if (strategy.unitTests < strategy.integrationTests) {
-            recommendations.push("Prioritize unit tests for better test pyramid balance");
-        }
-        if (projectType === "api" && strategy.e2eTests < 2) {
-            recommendations.push("Increase E2E tests for API contract validation");
-        }
-        return recommendations;
-    }
-    createImplementationPlan(strategy, timeline) {
-        const phases = timeline === "agile"
-            ? ["sprint1", "sprint2", "sprint3"]
-            : timeline === "continuous"
-                ? ["week1", "week2", "week3", "week4"]
-                : ["phase1", "phase2", "phase3"];
-        return {
-            phases: phases.map((phase, index) => ({
-                name: phase,
-                focus: index === 0
-                    ? "unit-tests"
-                    : index === 1
-                        ? "integration-tests"
-                        : "e2e-tests",
-                estimatedTests: Math.round(strategy.totalEstimated / phases.length),
-            })),
-            timeline,
-            milestones: this.generateMilestones(strategy, timeline),
-        };
-    }
-    generateExpectedTestFile(sourceFile) {
-        const ext = path.extname(sourceFile);
-        const baseName = path.basename(sourceFile, ext);
-        const dir = path.dirname(sourceFile);
-        return path.join(dir, "__tests__", `${baseName}.test${ext}`);
-    }
-    inferTestType(sourceFile) {
-        const content = fs.readFileSync(sourceFile, "utf8");
-        if (content.includes("export") && content.includes("function")) {
-            return "unit";
-        }
-        if (content.includes("router") || content.includes("endpoint")) {
-            return "integration";
-        }
-        if (content.includes("component") || content.includes("render")) {
-            return "component";
-        }
-        return "unit";
-    }
-    calculateTestPriority(sourceFile) {
-        const content = fs.readFileSync(sourceFile, "utf8");
-        let priority = 1;
-        // Critical business logic gets higher priority
-        if (content.includes("auth") ||
-            content.includes("security") ||
-            content.includes("payment")) {
-            priority += 3;
-        }
-        // Complex functions get higher priority
-        if ((content.match(/function/g) || []).length > 5) {
-            priority += 2;
-        }
-        // Public APIs get higher priority
-        if (content.includes("export")) {
-            priority += 1;
-        }
-        return Math.min(priority, 5);
-    }
-    estimateTestComplexity(sourceFile) {
-        const content = fs.readFileSync(sourceFile, "utf8");
-        const functions = (content.match(/function|class|interface/g) || []).length;
-        const branches = (content.match(/if|switch|catch/g) || []).length;
-        const asyncOps = (content.match(/async|await|Promise/g) || []).length;
-        return Math.min(Math.round((functions + branches + asyncOps) / 3), 5);
-    }
-    calculateGapCoverage(gaps, totalFiles) {
-        if (totalFiles === 0)
-            return 100;
-        return Math.round(((totalFiles - gaps.length) / totalFiles) * 100);
-    }
-    generateGapRecommendations(gaps) {
-        const recommendations = [];
-        const highPriorityGaps = gaps.filter((g) => g.priority >= 4);
-        if (highPriorityGaps.length > 0) {
-            recommendations.push(`Address ${highPriorityGaps.length} high-priority test gaps first`);
-        }
-        const complexGaps = gaps.filter((g) => g.complexity >= 4);
-        if (complexGaps.length > 0) {
-            recommendations.push(`Plan additional time for ${complexGaps.length} complex test implementations`);
-        }
-        return recommendations;
-    }
-    estimateOptimizationEffort(gap) {
-        if (gap <= 10)
-            return "1-2 days";
-        if (gap <= 20)
-            return "3-5 days";
-        if (gap <= 30)
-            return "1-2 weeks";
-        return "2-4 weeks";
-    }
-    identifyPriorityAreas(projectRoot, focusAreas) {
-        const areas = focusAreas || [
-            "authentication",
-            "data-validation",
-            "api-endpoints",
-            "ui-components",
-        ];
-        // Analyze codebase to identify actual priority areas
-        const sourceFiles = this.findSourceFiles(projectRoot);
-        const priorityAreas = [];
-        for (const area of areas) {
-            const relevantFiles = sourceFiles.filter((file) => fs
-                .readFileSync(file, "utf8")
-                .toLowerCase()
-                .includes(area.toLowerCase()));
-            if (relevantFiles.length > 0) {
-                priorityAreas.push(`${area} (${relevantFiles.length} files)`);
-            }
-        }
-        return priorityAreas;
-    }
-    createOptimizationPhases(gap, focusAreas) {
-        const phases = [];
-        if (gap > 30) {
-            phases.push({
-                name: "Phase 1: Critical Paths",
-                focus: "authentication, security, payment flows",
-                targetCoverage: 70,
-                estimatedTests: Math.round(gap * 0.4),
-            });
-        }
-        if (gap > 20) {
-            phases.push({
-                name: "Phase 2: Core Functionality",
-                focus: "main business logic, data validation",
-                targetCoverage: 80,
-                estimatedTests: Math.round(gap * 0.4),
-            });
-        }
-        phases.push({
-            name: "Phase 3: Edge Cases & UI",
-            focus: "error handling, ui components, edge cases",
-            targetCoverage: 85,
-            estimatedTests: Math.round(gap * 0.2),
-        });
-        return phases;
-    }
-    estimateOptimizationTimeline(optimization) {
-        const baseDays = optimization.phases.length * 3;
-        const complexityMultiplier = optimization.gap > 20 ? 1.5 : 1.0;
-        return {
-            estimatedDays: Math.round(baseDays * complexityMultiplier),
-            phases: optimization.phases.map((phase) => ({
-                name: phase.name,
-                estimatedDays: Math.round(phase.estimatedTests / 5),
-            })),
-        };
-    }
-    calculateOptimizationROI(optimization) {
-        const effortDays = optimization.estimatedEffort.includes("days")
-            ? parseInt(optimization.estimatedEffort)
-            : 14;
-        const coverageIncrease = optimization.gap;
-        return {
-            coverageIncrease: `${coverageIncrease}%`,
-            effortDays,
-            bugsPrevented: Math.round(coverageIncrease * 0.8), // Rough estimate
-            confidenceIncrease: `${Math.min(coverageIncrease * 2, 90)}%`,
-        };
-    }
-    generateMilestones(strategy, timeline) {
-        const totalTests = strategy.unitTests +
-            strategy.integrationTests +
-            strategy.e2eTests +
-            strategy.performanceTests +
-            strategy.securityTests;
-        strategy.totalEstimated = totalTests;
-        if (timeline === "agile") {
-            return [
-                {
-                    milestone: "Sprint 1 Complete",
-                    tests: Math.round(totalTests * 0.3),
-                    focus: "unit tests",
-                },
-                {
-                    milestone: "Sprint 2 Complete",
-                    tests: Math.round(totalTests * 0.6),
-                    focus: "integration tests",
-                },
-                {
-                    milestone: "Sprint 3 Complete",
-                    tests: totalTests,
-                    focus: "e2e and performance tests",
-                },
-            ];
-        }
-        return [
-            {
-                milestone: "Phase 1 Complete",
-                tests: Math.round(totalTests * 0.4),
-                focus: "foundation tests",
-            },
-            {
-                milestone: "Phase 2 Complete",
-                tests: Math.round(totalTests * 0.75),
-                focus: "feature tests",
-            },
-            {
-                milestone: "Phase 3 Complete",
-                tests: totalTests,
-                focus: "complete coverage",
-            },
-        ];
-    }
-    shouldIgnorePath(filePath) {
-        const ignorePatterns = [
-            /node_modules/,
-            /\.git/,
-            /dist/,
-            /build/,
-            /\.next/,
-            /\.nuxt/,
-            /\.cache/,
-            /\.temp/,
-            /coverage/,
-            /\.nyc_output/,
-            /logs/,
-            /\.DS_Store/,
-            /Thumbs\.db/,
-        ];
-        return ignorePatterns.some((pattern) => pattern.test(filePath));
-    }
-}
-// Start the server if run directly
-if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
-    const server = new XrayTestingStrategyServer();
-    server.run().catch(() => { });
-}
-export default XrayTestingStrategyServer;