@skyramp/mcp 0.0.38 → 0.0.39

package/build/types/TestMapping.js

@@ -0,0 +1,173 @@
+import { z } from "zod";
+import { TestType } from "./TestTypes.js";
+// Re-export TestType for convenience
+export { TestType };
+// Base impact scores for each test type
+export const BASE_SCORES = {
+    [TestType.E2E]: 100,
+    [TestType.UI]: 95,
+    [TestType.INTEGRATION]: 90,
+    [TestType.LOAD]: 60,
+    [TestType.FUZZ]: 50,
+    [TestType.CONTRACT]: 80,
+    [TestType.SMOKE]: 70,
+};
+export const CONTEXT_RULES = {
+    [TestType.E2E]: [
+        {
+            condition: "full-stack",
+            multiplier: 1.2,
+            description: "Full-stack apps benefit most from E2E tests",
+        },
+        {
+            condition: "backend-only",
+            multiplier: 0.7,
+            description: "Limited E2E applicability for backend-only",
+        },
+        {
+            condition: "frontend-spa",
+            multiplier: 0.9,
+            description: "Slightly reduced without backend",
+        },
+        {
+            condition: "library",
+            multiplier: 0,
+            description: "Not applicable to libraries",
+        },
+    ],
+    [TestType.LOAD]: [
+        {
+            condition: "hasKubernetes",
+            multiplier: 1.2,
+            description: "K8s suggests high-traffic expectations",
+        },
+        {
+            condition: "hasDockerCompose",
+            multiplier: 1.15,
+            description: "Scaled infrastructure indicates traffic needs",
+        },
+        {
+            condition: "cli-or-library",
+            multiplier: 0.4,
+            description: "Low traffic expected",
+        },
+        {
+            condition: "internal-tool",
+            multiplier: 0.4,
+            description: "Minimal load",
+        },
+    ],
+    [TestType.FUZZ]: [
+        {
+            condition: "handles-payments",
+            multiplier: 1.2,
+            description: "Security critical for payments",
+        },
+        {
+            condition: "handles-pii",
+            multiplier: 1.2,
+            description: "Security critical for PII",
+        },
+        {
+            condition: "oauth2",
+            multiplier: 1.15,
+            description: "Public API security needs",
+        },
+        {
+            condition: "internal-service",
+            multiplier: 0.9,
+            description: "Lower security priority",
+        },
+    ],
+    [TestType.CONTRACT]: [
+        {
+            condition: "microservices",
+            multiplier: 1.2,
+            description: "Critical for service contracts",
+        },
+        {
+            condition: "multiple-services",
+            multiplier: 1.15,
+            description: "Service interactions important",
+        },
+        {
+            condition: "monolith",
+            multiplier: 0.9,
+            description: "Less critical",
+        },
+    ],
+    [TestType.INTEGRATION]: [
+        {
+            condition: "microservices",
+            multiplier: 1.1,
+            description: "Service communication important",
+        },
+        {
+            condition: "has-unit-missing-integration",
+            multiplier: 1.2,
+            description: "Fill coverage gap",
+        },
+        {
+            condition: "has-integration-tests",
+            multiplier: 0.9,
+            description: "Less urgent",
+        },
+    ],
+    [TestType.UI]: [
+        {
+            condition: "frontend-spa-or-fullstack",
+            multiplier: 1.2,
+            description: "Full value for UI apps",
+        },
+        {
+            condition: "backend-only",
+            multiplier: 0,
+            description: "Not applicable",
+        },
+    ],
+    [TestType.SMOKE]: [
+        {
+            condition: "no-existing-tests",
+            multiplier: 1.2,
+            description: "Quick wins needed",
+        },
+        {
+            condition: "has-cicd",
+            multiplier: 1.1,
+            description: "Deployment validation",
+        },
+        {
+            condition: "comprehensive-tests",
+            multiplier: 0.8,
+            description: "Less valuable",
+        },
+    ],
+};
+// Zod schemas for validation
+export const testPriorityScoreSchema = z.object({
+    testType: z.nativeEnum(TestType),
+    _baseScore: z.number().min(0).max(120),
+    contextMultiplier: z.number().min(0).max(2),
+    _finalScore: z.number().min(0).max(150),
+    feasibility: z.enum(["high", "medium", "low", "not-applicable"]),
+    requiredArtifacts: z.object({
+        available: z.array(z.string()),
+        missing: z.array(z.string()),
+    }),
+    reasoning: z.string(),
+});
+export const testMappingResultSchema = z.object({
+    priorityScores: z.array(testPriorityScoreSchema),
+    contextFactors: z.object({
+        applied: z.array(z.object({
+            factor: z.string(),
+            impact: z.string(),
+            multiplier: z.number(),
+        })),
+    }),
+    summary: z.object({
+        highPriority: z.array(z.nativeEnum(TestType)),
+        mediumPriority: z.array(z.nativeEnum(TestType)),
+        lowPriority: z.array(z.nativeEnum(TestType)),
+    }),
+});

package/build/types/TestRecommendation.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { TestType } from "./TestTypes.js";
+// Test type to documentation URL mapping
+export const TEST_TYPE_DOCS = {
+    [TestType.SMOKE]: "https://www.skyramp.dev/docs/smoke-tests",
+    [TestType.CONTRACT]: "https://www.skyramp.dev/docs/contract-tests",
+    [TestType.FUZZ]: "https://www.skyramp.dev/docs/fuzz-tests",
+    [TestType.INTEGRATION]: "https://www.skyramp.dev/docs/integration-tests",
+    [TestType.LOAD]: "https://www.skyramp.dev/docs/load-tests",
+    [TestType.E2E]: "https://www.skyramp.dev/docs/e2e-tests",
+    [TestType.UI]: "https://www.skyramp.dev/docs/ui-tests",
+};
+// Zod schemas for validation
+export const specificTestSchema = z.object({
+    testName: z.string(),
+    description: z.string(),
+    targetEndpoint: z.string().optional(),
+    targetFlow: z.string().optional(),
+    // generationPrompt: z.string(),
+    requiredInputs: z.object({
+        available: z.array(z.object({
+            name: z.string(),
+            path: z.string(),
+        })),
+        missing: z.array(z.object({
+            name: z.string(),
+            guidance: z.string(),
+        })),
+    }),
+    estimatedValue: z.string(),
+});
+export const testTypeRecommendationSchema = z.object({
+    priority: z.enum(["high", "medium", "low"]),
+    testType: z.nativeEnum(TestType),
+    rationale: z.string(),
+    specificTests: z.array(specificTestSchema),
+    gettingStarted: z.object({
+        prerequisites: z.array(z.string()),
+        quickStartCommand: z.string().optional(),
+        documentationUrl: z.string(),
+    }),
+});
+export const testRecommendationSchema = z.object({
+    summary: z.object({
+        totalRecommended: z.number(),
+        highPriorityCount: z.number(),
+        estimatedEffort: z.string(),
+        quickWins: z.array(z.string()),
+    }),
+    recommendations: z.array(testTypeRecommendationSchema),
+    nextSteps: z.array(z.string()),
+});

package/build/types/TestTypes.js

@@ -68,7 +68,7 @@ export const baseSchema = z.object({
 export const baseTraceSchema = z.object({
     trace: z
         .string()
-        .describe("MUST be absolute path to trace file for test generation like /path/to/trace.json and MUST be a json file"),
+        .describe("Absolute path to the trace file in JSON format (e.g., /path/to/trace.json). Must use .json extension only. Do not use .jsonl files."),
     include: z
         .array(z.string())
         .default([])

package/build/utils/scoring-engine.js

@@ -0,0 +1,262 @@
+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) {
+        const _baseScore = BASE_SCORES[testType];
+        const contextMultiplier = this.calculateContextMultiplier(testType, analysis);
+        const _finalScore = _baseScore * contextMultiplier;
+        const feasibility = this.assessFeasibility(testType, analysis);
+        const requiredArtifacts = this.identifyRequiredArtifacts(testType, analysis);
+        const reasoning = this.generateReasoning(testType, _baseScore, contextMultiplier, _finalScore, analysis);
+        return {
+            testType,
+            _baseScore,
+            contextMultiplier,
+            _finalScore: Math.round(_finalScore * 10) / 10,
+            feasibility,
+            requiredArtifacts,
+            reasoning,
+        };
+    }
+    /**
+     * 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) {
+        const { projectClassification, existingTests, artifacts, infrastructure } = analysis;
+        let reasoning = "";
+        // Base reasoning by test type
+        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();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyramp/mcp",
-  "version": "0.0.38",
+  "version": "0.0.39",
   "main": "build/index.js",
   "type": "module",
   "bin": {