@skyramp/mcp 0.0.59 → 0.0.60-rc.2

package/build/tools/test-recommendation/mapTestsTool.js

@@ -1,243 +0,0 @@
-import { z } from "zod";
-import { readFile } from "fs/promises";
-import { repositoryAnalysisSchema } from "../../types/RepositoryAnalysis.js";
-import { TestType } from "../../types/TestTypes.js";
-import { ScoringEngine } from "../../utils/scoring-engine.js";
-import { StateManager, } from "../../utils/AnalysisStateManager.js";
-import { logger } from "../../utils/logger.js";
-import { AnalyticsService } from "../../services/AnalyticsService.js";
-/**
- * Map Tests Tool
- * MCP tool for calculating test priority scores
- */
-const mapTestsSchema = z.object({
-    stateFile: z
-        .string()
-        .describe("Path to a state file containing the RepositoryAnalysis JSON (created by skyramp_analyze_repository)."),
-    analysisScope: z
-        .enum(["full_repo", "current_branch_diff"])
-        .default("full_repo")
-        .describe("Scope of the analysis that produced the report. Must match the scope used in skyramp_analyze_repository. 'current_branch_diff' scopes recommendations to only the endpoints/code changed in the current branch."),
-    customWeights: z
-        .record(z.number())
-        .optional()
-        .describe("Optional: Custom weight multipliers for specific test types (e.g., {'load': 1.5, 'fuzz': 1.3})"),
-    focusTestTypes: z
-        .array(z.nativeEnum(TestType))
-        .optional()
-        .describe("Optional: Only evaluate specific test types (e.g., ['integration', 'smoke'])"),
-});
-const TOOL_NAME = "skyramp_map_tests";
-export function registerMapTestsTool(server) {
-    server.registerTool(TOOL_NAME, {
-        description: `Calculate priority scores for Skyramp test types based on repository analysis.
-
-This tool evaluates all test types (E2E, UI, Integration, Load, Fuzz, Contract, Smoke) and calculates priority scores using:
-- Base impact scores (E2E: 100, UI: 95, Integration: 85, etc.)
-- Context multipliers based on repository characteristics
-- Feasibility assessment based on available artifacts
-
-The scoring algorithm considers:
-- Project type (full-stack, microservices, REST API, etc.)
-- Infrastructure (Kubernetes, Docker Compose, CI/CD)
-- Existing test coverage gaps
-- Available artifacts (OpenAPI specs, Playwright recordings)
-- Security requirements (authentication, sensitive data)
-
-Example usage:
-\`\`\`
-{
-  "stateFile": "/tmp/skyramp-recommendation-123456.json",
-  "customWeights": {
-    "load": 1.5,
-    "fuzz": 1.3
-  }
-}
-\`\`\`
-
-**OUTPUT**:
-Returns the state file path to pass to skyramp_recommend_tests
-
-Output: TestMappingResult with priority scores, and state file path for next step.`,
-        inputSchema: mapTestsSchema.shape,
-    }, async (params) => {
-        let errorResult;
-        try {
-            logger.info("Map tests tool invoked", {
-                hasStateFile: !!params.stateFile,
-            });
-            if (!params.stateFile) {
-                throw new Error("stateFile is required. Run skyramp_analyze_repository first to create one.");
-            }
-            let analysis;
-            let repositoryPath;
-            logger.info("Reading analysis from state file", {
-                stateFile: params.stateFile,
-            });
-            try {
-                const raw = await readFile(params.stateFile, "utf-8");
-                const parsed = JSON.parse(raw);
-                if (parsed.metadata?.stateType && parsed.analysis) {
-                    analysis = parsed.analysis;
-                    if (parsed.repositoryPath) {
-                        repositoryPath = parsed.repositoryPath;
-                    }
-                }
-                else {
-                    analysis = parsed;
-                }
-            }
-            catch (error) {
-                const msg = error instanceof Error ? error.message : String(error);
-                throw new Error(`Failed to read analysis from stateFile "${params.stateFile}": ${msg}`);
-            }
-            // Validate the analysis object against the schema
-            const validationResult = repositoryAnalysisSchema.safeParse(analysis);
-            if (!validationResult.success) {
-                const errors = validationResult.error.errors
-                    .map((e) => `${e.path.join(".")}: ${e.message}`)
-                    .join("; ");
-                throw new Error(`Analysis validation failed: ${errors}`);
-            }
-            analysis = validationResult.data;
-            // Determine which test types to evaluate
-            const testTypesToEvaluate = params.focusTestTypes ||
-                Object.values(TestType).filter((t) => typeof t === "string");
-            // Calculate scores for each test type
-            const analysisScope = params.analysisScope || "full_repo";
-            const priorityScores = [];
-            for (const testType of testTypesToEvaluate) {
-                const score = ScoringEngine.calculateTestScore(testType, analysis, analysisScope);
-                // Apply custom weights if provided
-                if (params.customWeights && params.customWeights[testType]) {
-                    score._finalScore *= params.customWeights[testType];
-                    score.contextMultiplier *= params.customWeights[testType];
-                    score.reasoning += ` (custom weight: ×${params.customWeights[testType]})`;
-                }
-                priorityScores.push(score);
-            }
-            // Sort by final score (descending)
-            priorityScores.sort((a, b) => b._finalScore - a._finalScore);
-            // Create summary
-            const highPriority = [];
-            const mediumPriority = [];
-            const lowPriority = [];
-            for (const score of priorityScores) {
-                if (score.feasibility === "not-applicable")
-                    continue;
-                if (score._finalScore >= 80) {
-                    highPriority.push(score.testType);
-                }
-                else if (score._finalScore >= 60) {
-                    mediumPriority.push(score.testType);
-                }
-                else {
-                    lowPriority.push(score.testType);
-                }
-            }
-            // Extract context factors
-            const contextFactors = { applied: [] };
-            if (analysis.infrastructure.hasKubernetes) {
-                contextFactors.applied.push({
-                    factor: "hasKubernetes",
-                    impact: "Increases load and integration test importance",
-                    multiplier: 1.2,
-                });
-            }
-            if (analysis.infrastructure.hasDockerCompose) {
-                contextFactors.applied.push({
-                    factor: "hasDockerCompose",
-                    impact: "Suggests scaled infrastructure",
-                    multiplier: 1.1,
-                });
-            }
-            if (analysis.infrastructure.hasCiCd) {
-                contextFactors.applied.push({
-                    factor: "hasCiCd",
-                    impact: "Increases smoke test importance",
-                    multiplier: 1.1,
-                });
-            }
-            const mapping = {
-                priorityScores,
-                contextFactors,
-                summary: { highPriority, mediumPriority, lowPriority },
-            };
-            // Save results using StateManager — reuse session from input stateFile if provided
-            const stateManager = params.stateFile
-                ? StateManager.fromStatePath(params.stateFile)
-                : new StateManager("recommendation");
-            const stateData = {
-                repositoryPath: repositoryPath ?? "",
-                analysisScope,
-                analysis,
-                mapping,
-            };
-            await stateManager.writeData(stateData, {
-                repositoryPath,
-                step: "map-tests",
-            });
-            const stateFilePath = stateManager.getStatePath();
-            const sessionId = stateManager.getSessionId();
-            const stateSize = await stateManager.getSizeFormatted();
-            logger.info(`Saved test mapping to: ${stateFilePath} (${stateSize}), repositoryPath: ${repositoryPath ?? "unknown"}`);
-            // Format output
-            const output = `# Test Priority Mapping
-
-## Summary
-- **High Priority**: ${mapping.summary.highPriority.join(", ") || "None"}
-- **Medium Priority**: ${mapping.summary.mediumPriority.join(", ") || "None"}
-- **Low Priority**: ${mapping.summary.lowPriority.join(", ") || "None"}
-
-## Test Type Priorities (Ordered by Score)
-
-${mapping.priorityScores
-                .map((score) => `### ${score.testType.toUpperCase()}
-- **Feasibility**: ${score.feasibility}
-- **Available Artifacts**: ${score.requiredArtifacts.available.join(", ") || "None"}
-- **Missing Artifacts**: ${score.requiredArtifacts.missing.join(", ") || "None"}
-- **Reasoning**: ${score.reasoning}
-`)
-                .join("\n")}
-
-## Context Factors Applied
-
-${mapping.contextFactors.applied
-                .map((factor) => `- **${factor.factor}**: ${factor.impact} (×${factor.multiplier})`)
-                .join("\n")}
-
-## Results Saved
-
-**State File**: \`${stateFilePath}\`
-**Session ID**: \`${sessionId}\`
-
-**Next Step**: Call \`skyramp_recommend_tests\` with stateFile: \`${stateFilePath}\``;
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: output,
-                    },
-                ],
-                isError: false,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error("Map tests tool failed", { error: errorMessage });
-            errorResult = {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error mapping tests: ${errorMessage}`,
-                    },
-                ],
-                isError: true,
-            };
-            return errorResult;
-        }
-        finally {
-            AnalyticsService.pushMCPToolEvent(TOOL_NAME, errorResult, {});
-        }
-    });
-}

package/build/types/TestMapping.js

@@ -1,173 +0,0 @@
-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)),
-    }),
-});