@skyramp/mcp 0.0.59 → 0.0.60-rc.2

package/build/utils/scoring-engine.js

@@ -1,380 +0,0 @@
-import { BASE_SCORES, CONTEXT_RULES, } from "../types/TestMapping.js";
-import { TestType } from "../types/TestTypes.js";
-/**
- * Scoring Engine
- * Calculates priority scores for test types based on repository analysis
- */
-export class ScoringEngine {
-    /**
-     * Calculate priority score for a specific test type
-     */
-    static calculateTestScore(testType, analysis, analysisScope) {
-        const _baseScore = BASE_SCORES[testType];
-        const contextMultiplier = this.calculateContextMultiplier(testType, analysis);
-        const diffMultiplier = analysisScope === "current_branch_diff" && analysis.branchDiffContext
-            ? this.calculateDiffMultiplier(testType, analysis.branchDiffContext)
-            : 1.0;
-        const combinedMultiplier = contextMultiplier * diffMultiplier;
-        const _finalScore = _baseScore * combinedMultiplier;
-        const feasibility = this.assessFeasibility(testType, analysis);
-        const requiredArtifacts = this.identifyRequiredArtifacts(testType, analysis);
-        const reasoning = this.generateReasoning(testType, _baseScore, combinedMultiplier, _finalScore, analysis, analysisScope);
-        return {
-            testType,
-            _baseScore,
-            // Note: this field stores the combined multiplier (contextMultiplier * diffMultiplier)
-            contextMultiplier: Math.round(combinedMultiplier * 100) / 100,
-            _finalScore: Math.round(_finalScore * 10) / 10,
-            feasibility,
-            requiredArtifacts,
-            reasoning,
-        };
-    }
-    /**
-     * Calculate a score multiplier based on what changed in the branch diff.
-     * Boosts test types that are most relevant to the specific code changes.
-     */
-    static calculateDiffMultiplier(testType, diff) {
-        const hasNewEndpoints = diff.newEndpoints.length > 0;
-        const hasModifiedEndpoints = diff.modifiedEndpoints.length > 0;
-        const hasEndpointChanges = hasNewEndpoints || hasModifiedEndpoints;
-        if (!hasEndpointChanges) {
-            if (diff.changedFiles.length === 0) {
-                // Truly empty diff — lower priority across the board.
-                return 0.5;
-            }
-            // Check whether any changed file looks like an API-affecting resource
-            // (model, schema, validator, serializer, DTO) even though no route
-            // decorator lines were touched. These changes affect API behaviour just
-            // as much as a route change (e.g. tightening a Pydantic field validator).
-            const hasApiRelatedFiles = diff.changedFiles.some((f) => /(model|schema|validator|serializer|dto)/i.test(f));
-            if (hasApiRelatedFiles) {
-                // Boost contract and fuzz — they're the most relevant for
-                // validation/schema changes. Give smoke a small nudge too.
-                switch (testType) {
-                    case TestType.CONTRACT:
-                        return 1.3;
-                    case TestType.FUZZ:
-                        return 1.4; // validation rule changes are exactly what fuzz catches
-                    case TestType.SMOKE:
-                        return 1.1;
-                    default:
-                        return 1.0;
-                }
-            }
-            // Files changed but not API-related — neutral.
-            return 1.0;
-        }
-        switch (testType) {
-            case TestType.CONTRACT:
-                if (hasModifiedEndpoints)
-                    return 1.4;
-                if (hasNewEndpoints)
-                    return 1.3;
-                return 1.0;
-            case TestType.FUZZ:
-                if (hasModifiedEndpoints)
-                    return 1.4;
-                if (hasNewEndpoints)
-                    return 1.2;
-                return 1.0;
-            case TestType.SMOKE:
-                if (hasNewEndpoints)
-                    return 1.3;
-                if (hasModifiedEndpoints)
-                    return 1.2;
-                return 1.0;
-            case TestType.INTEGRATION:
-                if (hasNewEndpoints)
-                    return 1.2;
-                if (hasModifiedEndpoints)
-                    return 1.1;
-                return 1.0;
-            case TestType.LOAD:
-                if (hasNewEndpoints)
-                    return 1.1;
-                if (hasModifiedEndpoints)
-                    return 1.0;
-                return 1.0;
-            case TestType.E2E:
-                if (hasNewEndpoints)
-                    return 1.1;
-                if (hasModifiedEndpoints)
-                    return 1.0;
-                return 1.0;
-            case TestType.UI:
-                return 0.5;
-            default:
-                return 1.0;
-        }
-    }
-    /**
-     * Calculate context multiplier based on repository characteristics
-     */
-    static calculateContextMultiplier(testType, analysis) {
-        const rules = CONTEXT_RULES[testType];
-        let multiplier = 1.0;
-        for (const rule of rules) {
-            if (this.evaluateCondition(rule.condition, analysis)) {
-                multiplier = rule.multiplier;
-                break; // Use first matching rule
-            }
-        }
-        return multiplier;
-    }
-    /**
-     * Evaluate a context condition against repository analysis
-     */
-    static evaluateCondition(condition, analysis) {
-        const { projectClassification, infrastructure, existingTests, artifacts } = analysis;
-        switch (condition) {
-            // Project type conditions
-            case "full-stack":
-                return projectClassification.projectType === "full-stack";
-            case "backend-only":
-                return projectClassification.projectType === "rest-api";
-            case "frontend-spa":
-                return projectClassification.projectType === "frontend";
-            case "library":
-                return projectClassification.projectType === "library";
-            case "cli-or-library":
-                return ["library", "cli"].includes(projectClassification.projectType);
-            case "microservices":
-                return (projectClassification.projectType === "microservices" ||
-                    projectClassification.deploymentPattern === "microservices");
-            case "monolith":
-                return (projectClassification.deploymentPattern === "containerized-monolith");
-            // Infrastructure conditions
-            case "hasKubernetes":
-                return infrastructure.hasKubernetes;
-            case "hasDockerCompose":
-                return infrastructure.hasDockerCompose;
-            case "has-cicd":
-                return infrastructure.hasCiCd;
-            // Testing conditions
-            case "no-existing-tests":
-                return Object.values(existingTests.coverage).every((v) => v === 0);
-            case "has-unit-missing-integration":
-                return (existingTests.coverage.unit > 0 &&
-                    existingTests.coverage.integration === 0);
-            case "has-integration-tests":
-                return existingTests.coverage.integration > 0;
-            case "comprehensive-tests":
-                return (Object.values(existingTests.coverage).reduce((a, b) => a + b, 0) > 20);
-            // Artifact conditions
-            case "frontend-spa-or-fullstack":
-                return ["frontend", "full-stack"].includes(projectClassification.projectType);
-            case "multiple-services":
-                return projectClassification.deploymentPattern === "microservices";
-            // Security conditions (inferred)
-            case "handles-payments":
-                return (analysis.businessContext.mainPurpose
-                    .toLowerCase()
-                    .includes("payment") ||
-                    analysis.businessContext.mainPurpose
-                        .toLowerCase()
-                        .includes("commerce"));
-            case "handles-pii":
-                return (analysis.businessContext.mainPurpose.toLowerCase().includes("user") ||
-                    analysis.businessContext.mainPurpose.toLowerCase().includes("profile"));
-            case "oauth2":
-                return analysis.authentication.method === "oauth2";
-            case "internal-service":
-            case "internal-tool":
-                return analysis.businessContext.mainPurpose
-                    .toLowerCase()
-                    .includes("internal");
-            default:
-                return false;
-        }
-    }
-    /**
-     * Assess feasibility of generating a test type
-     */
-    static assessFeasibility(testType, analysis) {
-        const { artifacts, projectClassification } = analysis;
-        // Check for N/A cases first
-        if (testType === TestType.UI &&
-            projectClassification.projectType === "rest-api") {
-            return "not-applicable";
-        }
-        if (testType === TestType.E2E &&
-            projectClassification.projectType === "library") {
-            return "not-applicable";
-        }
-        // Check artifact requirements
-        const requiredArtifacts = this.identifyRequiredArtifacts(testType, analysis);
-        const missingCount = requiredArtifacts.missing.length;
-        if (missingCount === 0) {
-            return "high";
-        }
-        else if (missingCount === 1) {
-            return "medium";
-        }
-        else {
-            return "low";
-        }
-    }
-    /**
-     * Identify required artifacts and their availability
-     */
-    static identifyRequiredArtifacts(testType, analysis) {
-        const available = [];
-        const missing = [];
-        const { artifacts } = analysis;
-        // Check OpenAPI spec
-        if (artifacts.openApiSpecs.length > 0) {
-            available.push("openApiSpec");
-        }
-        else {
-            if ([
-                TestType.SMOKE,
-                TestType.CONTRACT,
-                TestType.FUZZ,
-                TestType.INTEGRATION,
-                TestType.LOAD,
-            ].includes(testType)) {
-                missing.push("openApiSpec");
-            }
-        }
-        // Check Playwright recordings
-        if (artifacts.playwrightRecordings.length > 0) {
-            available.push("playwrightRecording");
-        }
-        else {
-            if ([TestType.UI, TestType.E2E].includes(testType)) {
-                missing.push("playwrightRecording");
-            }
-        }
-        // Check trace files
-        if (artifacts.traceFiles.length > 0) {
-            available.push("traceFile");
-        }
-        else {
-            if ([TestType.E2E, TestType.INTEGRATION].includes(testType)) {
-                // Trace files are helpful but not required if OpenAPI is available
-                if (artifacts.openApiSpecs.length === 0) {
-                    missing.push("traceFile");
-                }
-            }
-        }
-        return { available, missing };
-    }
-    /**
-     * Generate reasoning explanation for the score
-     */
-    static generateReasoning(testType, _baseScore, multiplier, _finalScore, analysis, analysisScope) {
-        const { projectClassification, existingTests, artifacts, infrastructure } = analysis;
-        let reasoning = "";
-        if (analysisScope === "current_branch_diff" &&
-            analysis.branchDiffContext) {
-            const diff = analysis.branchDiffContext;
-            const hasNew = diff.newEndpoints.length > 0;
-            const hasMod = diff.modifiedEndpoints.length > 0;
-            const endpoints = [
-                ...diff.newEndpoints.map((e) => `${e.method} ${e.path} (new)`),
-                ...diff.modifiedEndpoints.map((e) => `${e.method} ${e.path} (modified)`),
-            ];
-            if (!hasNew && !hasMod) {
-                reasoning += "No endpoint changes in branch diff — lower priority. ";
-            }
-            else {
-                const affectedLabel = endpoints.join(", ");
-                switch (testType) {
-                    case TestType.CONTRACT:
-                        reasoning += `Modified endpoints change API contract — contract tests critical. Affected: ${affectedLabel}. `;
-                        break;
-                    case TestType.FUZZ:
-                        reasoning += `Validation rules changed — fuzz testing needed to verify boundary handling. Affected: ${affectedLabel}. `;
-                        break;
-                    case TestType.SMOKE:
-                        reasoning += `Endpoint behavior changed — smoke tests verify basic functionality. Affected: ${affectedLabel}. `;
-                        break;
-                    case TestType.INTEGRATION:
-                        reasoning += `Endpoint changes may affect multi-step flows. Affected: ${affectedLabel}. `;
-                        break;
-                    default:
-                        if (hasNew || hasMod) {
-                            reasoning += `Branch changes affect: ${affectedLabel}. `;
-                        }
-                        break;
-                }
-            }
-        }
-        // Base reasoning by test type — use += to preserve any diff reasoning above
-        switch (testType) {
-            case TestType.INTEGRATION:
-                if (existingTests.coverage.integration === 0) {
-                    reasoning += `No integration tests exist for ${analysis.apiEndpoints.totalCount} endpoints. `;
-                }
-                else {
-                    reasoning += `${existingTests.coverage.integration} integration tests exist. `;
-                }
-                if (projectClassification.deploymentPattern === "microservices") {
-                    reasoning +=
-                        "Microservices architecture makes integration testing critical. ";
-                }
-                break;
-            case TestType.E2E:
-                if (projectClassification.projectType === "full-stack") {
-                    reasoning +=
-                        "Full-stack application - E2E tests validate complete user journeys. ";
-                }
-                else {
-                    reasoning +=
-                        "E2E tests have limited applicability for this project type. ";
-                }
-                break;
-            case TestType.UI:
-                if (["frontend", "full-stack"].includes(projectClassification.projectType)) {
-                    reasoning += "UI testing essential for frontend validation. ";
-                }
-                else {
-                    reasoning += "No UI components detected. ";
-                }
-                break;
-            case TestType.SMOKE:
-                if (Object.values(existingTests.coverage).every((v) => v === 0)) {
-                    reasoning += "No existing tests - smoke tests provide quick wins. ";
-                }
-                if (infrastructure.hasCiCd) {
-                    reasoning += "CI/CD pipeline benefits from smoke test validation. ";
-                }
-                break;
-            case TestType.LOAD:
-                if (infrastructure.hasKubernetes) {
-                    reasoning +=
-                        "Kubernetes deployment suggests high-traffic expectations. ";
-                }
-                else {
-                    reasoning += "Load testing validates performance and scalability. ";
-                }
-                break;
-            case TestType.FUZZ:
-                if (analysis.authentication.method !== "none") {
-                    reasoning +=
-                        "API handles authentication - security testing important. ";
-                }
-                reasoning += "Fuzz testing discovers input validation issues. ";
-                break;
-            case TestType.CONTRACT:
-                if (artifacts.openApiSpecs.length > 0) {
-                    reasoning +=
-                        "OpenAPI spec available - contract validation straightforward. ";
-                }
-                else {
-                    reasoning += "No OpenAPI spec - contract tests harder to generate. ";
-                }
-                break;
-        }
-        // Add artifact status
-        const requiredArtifacts = this.identifyRequiredArtifacts(testType, analysis);
-        if (requiredArtifacts.missing.length > 0) {
-            reasoning += `Missing: ${requiredArtifacts.missing.join(", ")}. `;
-        }
-        else if (requiredArtifacts.available.length > 0) {
-            reasoning += `All required artifacts available. `;
-        }
-        return reasoning.trim();
-    }
-}