@skyramp/mcp 0.0.62 → 0.0.63-rc.2

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

@@ -1,505 +0,0 @@
-import { z } from "zod";
-import * as crypto from "crypto";
-import * as path from "path";
-import { logger } from "../../utils/logger.js";
-import { AnalyticsService } from "../../services/AnalyticsService.js";
-import { registerSession, storeSessionData, } from "../../utils/AnalysisStateManager.js";
-import { WorkspaceConfigManager } from "@skyramp/skyramp";
-import { TestDiscoveryService } from "../../services/TestDiscoveryService.js";
-import { computeBranchDiff } from "../../utils/branchDiff.js";
-import { parseEndpointsFromDiff } from "../../utils/routeParsers.js";
-import { scanAllRepoEndpoints, scanRelatedEndpoints, grepRouterMountingContext } from "../../utils/repoScanner.js";
-import { detectProjectMetadata } from "../../utils/projectMetadata.js";
-import { draftScenariosFromEndpoints } from "../../utils/scenarioDrafting.js";
-import { buildAnalysisOutputText } from "../../prompts/test-recommendation/analysisOutputPrompt.js";
-import { parseTraceFile, discoverTraceFiles } from "../../utils/trace-parser.js";
-const analyzeRepositorySchema = z.object({
-    repositoryPath: z
-        .string()
-        .describe("Absolute path to the repository to analyze (e.g., /path/to/my-repo)"),
-    scanDepth: z
-        .enum(["quick", "full"])
-        .default("full")
-        .describe("Analysis depth: 'quick' for basic info, 'full' for comprehensive analysis"),
-    analysisScope: z
-        .enum(["full_repo", "current_branch_diff"])
-        .default("full_repo")
-        .describe("Scope of analysis. 'full_repo' analyzes the entire repository. 'current_branch_diff' analyzes only the changes in the current branch compared to the default branch (e.g., main/master), useful for PR-scoped test recommendations."),
-    baseBranch: z
-        .string()
-        .optional()
-        .describe("Optional: PR base branch name (e.g. 'main', 'develop'). When provided, the diff is computed against origin/<baseBranch> instead of auto-detecting the default branch. Useful when the PR targets a non-default branch."),
-});
-const TOOL_NAME = "skyramp_analyze_repository";
-export function registerAnalyzeRepositoryTool(server) {
-    server.registerTool(TOOL_NAME, {
-        description: `
-⚠️ MANDATORY FIRST STEP - DISPLAY THIS WARNING:
-Before ANY other response text, you MUST output this exact message:
-"** This tool is currently in Early Preview stage. Please verify the results. **"
-
-DO NOT proceed with tool calls until you have displayed this warning in your response.
-
-❌ WRONG: Calling this tool without first displaying the warning message to the user
-✅ CORRECT: First display the warning message in plain text, THEN call this tool
-
-EXPECTED FLOW:
-1. System displays: "** This tool is currently in Early Preview stage..."
-2. System calls: skyramp_analyze_repository(...)
-3. System processes results
-
-Analyze a code repository to understand its structure, technology stack, and testing readiness.
-
-This tool performs comprehensive repository analysis including:
-- Project type classification (REST API, Frontend, Full-stack, Microservices, etc.)
-- Technology stack identification (languages, frameworks, dependencies)
-- Artifact discovery (OpenAPI specs, Playwright recordings, trace files)
-- API endpoint detection and cataloging
-- Authentication mechanism analysis
-- Infrastructure configuration (Docker, Kubernetes, CI/CD)
-- Existing test coverage assessment
-
-The analysis provides enriched endpoint data (interactions, headers, cookies) and
-drafted scenarios that can be used by skyramp_recommend_tests for LLM-powered recommendations.
-
-When \`analysisScope\` is set to \`"current_branch_diff"\`, the analysis focuses specifically on the code changes in the current branch — identifying new/modified endpoints, changed services, and affected areas — rather than scanning the entire repository. This is ideal for PR-scoped test recommendations.
-
-Example usage:
-\`\`\`
-{
-  "repositoryPath": "/Users/dev/my-api",
-  "scanDepth": "full",
-  "analysisScope": "current_branch_diff",
-}
-\`\`\`
-
-**CRITICAL RULES**:
-- DO NOT CREATE ANY .json or .md file during repository analysis.
-
-Output: Detailed RepositoryAnalysis JSON object with all repository characteristics.`,
-        inputSchema: analyzeRepositorySchema.shape,
-    }, async (params, extra) => {
-        let errorResult;
-        const sendProgress = async (progress, total, message) => {
-            const progressToken = extra._meta?.progressToken;
-            if (progressToken !== undefined) {
-                const notification = {
-                    method: "notifications/progress",
-                    params: { progressToken, progress, total, message },
-                };
-                await extra.sendNotification(notification);
-            }
-        };
-        try {
-            const analysisScope = params.analysisScope || "full_repo";
-            logger.info("Analyze repository tool invoked", {
-                repositoryPath: params.repositoryPath,
-                scanDepth: params.scanDepth,
-                analysisScope,
-            });
-            await sendProgress(0, 100, "Starting repository analysis...");
-            let diffData;
-            if (analysisScope === "current_branch_diff") {
-                await sendProgress(10, 100, "Computing branch diff...");
-                try {
-                    diffData = await computeBranchDiff(params.repositoryPath, params.baseBranch);
-                    logger.info("Branch diff computed via git", {
-                        currentBranch: diffData.currentBranch,
-                        baseBranch: diffData.baseBranch,
-                        changedFiles: diffData.changedFiles.length,
-                    });
-                }
-                catch (error) {
-                    const msg = error instanceof Error ? error.message : String(error);
-                    logger.error("Failed to obtain branch diff", { error: msg });
-                    throw new Error(`Failed to obtain branch diff: ${msg}`);
-                }
-            }
-            await sendProgress(30, 100, "Parsing endpoints from diff...");
-            const parsedDiff = diffData ? parseEndpointsFromDiff(diffData) : undefined;
-            // In PR mode, skip the expensive full-repo scan — the LLM will
-            // discover relevant endpoints from the diff and handler code.
-            // In full-repo mode, scan to give the LLM a head start.
-            let scannedEndpoints = [];
-            if (analysisScope !== "current_branch_diff") {
-                await sendProgress(40, 100, "Scanning repository for all endpoints...");
-                try {
-                    scannedEndpoints = scanAllRepoEndpoints(params.repositoryPath);
-                    logger.info("Pre-scanned repo endpoints", { count: scannedEndpoints.length });
-                }
-                catch (err) {
-                    logger.warning("Endpoint pre-scan failed, LLM will discover endpoints", {
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-            }
-            else if (diffData) {
-                await sendProgress(40, 100, "Scanning related endpoints from diff...");
-                try {
-                    scannedEndpoints = scanRelatedEndpoints(params.repositoryPath, diffData.changedFiles);
-                    logger.info("Scanned related endpoints for PR scope", { count: scannedEndpoints.length });
-                }
-                catch (err) {
-                    logger.warning("Related endpoint scan failed", {
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-                if (scannedEndpoints.length === 0) {
-                    await sendProgress(45, 100, "No related endpoints found, scanning full repo...");
-                    try {
-                        scannedEndpoints = scanAllRepoEndpoints(params.repositoryPath);
-                        logger.info("Fallback: scanned all repo endpoints", { count: scannedEndpoints.length });
-                    }
-                    catch (err) {
-                        logger.warning("Full repo endpoint scan also failed", {
-                            error: err instanceof Error ? err.message : String(err),
-                        });
-                    }
-                }
-            }
-            await sendProgress(50, 100, "Building analysis session...");
-            // Read workspace config for baseUrl and auth info
-            let wsBaseUrl = "";
-            let wsAuthHeader = "";
-            let wsSchemaPath = "";
-            let wsAuthMethod = "none";
-            try {
-                const wsMgr = new WorkspaceConfigManager(params.repositoryPath);
-                if (await wsMgr.exists()) {
-                    const wsConfig = await wsMgr.read();
-                    const svc = wsConfig.services?.[0];
-                    if (svc?.api?.baseUrl)
-                        wsBaseUrl = svc.api.baseUrl;
-                    if (svc?.api?.authHeader)
-                        wsAuthHeader = svc.api.authHeader;
-                    if (svc?.api?.schemaPath)
-                        wsSchemaPath = svc.api.schemaPath;
-                    if (wsAuthHeader) {
-                        wsAuthMethod = /cookie|session/i.test(wsAuthHeader) ? "session" : "bearer";
-                    }
-                }
-            }
-            catch {
-                // workspace config not available
-            }
-            // Auto-detect project metadata from files
-            const projectMeta = detectProjectMetadata(params.repositoryPath);
-            const sessionId = crypto.randomUUID();
-            // Build skeleton endpoints — from full scan or diff-only
-            const skeletonResponse = (method) => method === "POST" ? { statusCode: 201, description: "Created" }
-                : method === "DELETE" ? { statusCode: 204, description: "No Content" }
-                    : { statusCode: 200, description: "OK" };
-            const skeletonEndpoints = scannedEndpoints.length > 0
-                ? scannedEndpoints.map((ep) => ({
-                    path: ep.path,
-                    resourceGroup: ep.path.split("/").filter(Boolean).pop() || "unknown",
-                    pathParams: (ep.path.match(/\{(\w+)\}/g) || []).map((p) => ({
-                        name: p.slice(1, -1),
-                        type: "string",
-                        required: true,
-                    })),
-                    methods: ep.methods.map((m) => ({
-                        method: m,
-                        description: "",
-                        queryParams: [],
-                        authRequired: true,
-                        sourceFile: ep.sourceFile,
-                        interactions: [{
-                                description: `${m} ${ep.path}`,
-                                type: "success",
-                                request: {},
-                                response: skeletonResponse(m),
-                            }],
-                    })),
-                }))
-                : (parsedDiff
-                    ? (() => {
-                        const grouped = new Map();
-                        for (const ep of [...parsedDiff.newEndpoints, ...parsedDiff.modifiedEndpoints]) {
-                            let entry = grouped.get(ep.path);
-                            if (!entry) {
-                                entry = {
-                                    path: ep.path,
-                                    resourceGroup: ep.path.split("/").filter(Boolean).pop() || "unknown",
-                                    pathParams: (ep.path.match(/\{(\w+)\}/g) || []).map((p) => ({
-                                        name: p.slice(1, -1),
-                                        type: "string",
-                                        required: true,
-                                    })),
-                                    methods: [],
-                                };
-                                grouped.set(ep.path, entry);
-                            }
-                            entry.methods.push({
-                                method: ep.method,
-                                description: "",
-                                queryParams: [],
-                                authRequired: true,
-                                sourceFile: ep.sourceFile,
-                                interactions: [{
-                                        description: `${ep.method} ${ep.path}`,
-                                        type: "success",
-                                        request: {},
-                                        response: skeletonResponse(ep.method),
-                                    }],
-                            });
-                        }
-                        return Array.from(grouped.values());
-                    })()
-                    : []);
-            const diffContext = parsedDiff ? {
-                currentBranch: parsedDiff.currentBranch,
-                baseBranch: parsedDiff.baseBranch,
-                changedFiles: parsedDiff.changedFiles,
-                newEndpoints: (() => {
-                    const grouped = new Map();
-                    for (const ep of parsedDiff.newEndpoints) {
-                        let entry = grouped.get(ep.path);
-                        if (!entry) {
-                            entry = { path: ep.path, methods: [] };
-                            grouped.set(ep.path, entry);
-                        }
-                        entry.methods.push({ method: ep.method, sourceFile: ep.sourceFile, interactionCount: 0 });
-                    }
-                    return Array.from(grouped.values());
-                })(),
-                modifiedEndpoints: (() => {
-                    const grouped = new Map();
-                    for (const ep of parsedDiff.modifiedEndpoints) {
-                        let entry = grouped.get(ep.path);
-                        if (!entry) {
-                            entry = { path: ep.path, methods: [] };
-                            grouped.set(ep.path, entry);
-                        }
-                        entry.methods.push({ method: ep.method, sourceFile: ep.sourceFile, changeType: "modified" });
-                    }
-                    return Array.from(grouped.values());
-                })(),
-                affectedServices: parsedDiff.affectedServices,
-                summary: "",
-            } : undefined;
-            // Run TestDiscoveryService to find existing Skyramp-generated tests
-            let discoveredTests = {
-                frameworks: [], coverage: { unit: 0, integration: 0, e2e: 0, ui: 0, load: 0, contract: 0, smoke: 0 }, testLocations: {}, hasCoverageReports: false,
-            };
-            try {
-                const discoveryService = new TestDiscoveryService();
-                const discoveryResult = await discoveryService.discoverTests(params.repositoryPath);
-                const byType = new Map();
-                for (const test of discoveryResult.tests) {
-                    const type = test.testType || "unknown";
-                    if (!byType.has(type))
-                        byType.set(type, []);
-                    byType.get(type).push(test.testFile);
-                    if (test.framework && !discoveredTests.frameworks.includes(test.framework)) {
-                        discoveredTests.frameworks.push(test.framework);
-                    }
-                }
-                for (const [type, files] of byType) {
-                    discoveredTests.testLocations[type] = files.join(", ");
-                }
-                logger.info("Test discovery completed", { totalFiles: discoveryResult.tests.length, types: Object.fromEntries(Array.from(byType.entries()).map(([k, v]) => [k, v.length])) });
-            }
-            catch (err) {
-                logger.warning("TestDiscoveryService failed, existingTests will be empty", { error: err instanceof Error ? err.message : String(err) });
-            }
-            // I1/I2: Discover and parse trace files for enrichment
-            let traceResult;
-            const traceFiles = discoverTraceFiles(params.repositoryPath);
-            if (traceFiles.length > 0) {
-                try {
-                    traceResult = await parseTraceFile(traceFiles[0]);
-                    logger.info("Parsed trace file", {
-                        file: traceFiles[0],
-                        format: traceResult.format,
-                        entries: traceResult.entries.length,
-                        flows: traceResult.userFlows.length,
-                    });
-                }
-                catch (err) {
-                    logger.warning("Trace parsing failed", { error: err instanceof Error ? err.message : String(err) });
-                }
-            }
-            // I4: Merge trace-derived interactions into skeleton endpoints
-            if (traceResult && traceResult.entries.length > 0) {
-                for (const entry of traceResult.entries) {
-                    let rawPath = entry.path;
-                    try {
-                        rawPath = new URL(rawPath).pathname;
-                    }
-                    catch { /* already a path */ }
-                    const normalizedPath = rawPath.replace(/\/[0-9a-f-]{20,}/gi, "/{id}").replace(/\/\d+/g, "/{id}");
-                    const existing = skeletonEndpoints.find(ep => {
-                        const epNorm = ep.path.replace(/\{\w+\}/g, "/{id}");
-                        return epNorm === normalizedPath;
-                    });
-                    if (existing) {
-                        const methodObj = existing.methods.find((m) => m.method === entry.method);
-                        if (methodObj) {
-                            const alreadyHasStatus = methodObj.interactions.some((i) => i.response.statusCode === entry.statusCode);
-                            if (!alreadyHasStatus) {
-                                methodObj.interactions.push({
-                                    description: `${entry.method} ${entry.path} \u2192 ${entry.statusCode} (from trace)`,
-                                    type: "success",
-                                    request: entry.requestBody ? { body: entry.requestBody } : {},
-                                    response: {
-                                        statusCode: entry.statusCode,
-                                        description: `Observed in trace (${traceResult.format})`,
-                                        ...(entry.responseBody ? { body: entry.responseBody } : {}),
-                                    },
-                                });
-                            }
-                        }
-                    }
-                }
-            }
-            // Combine trace-derived + code-inferred scenarios
-            const codeInferredScenarios = draftScenariosFromEndpoints(skeletonEndpoints);
-            let allDraftedScenarios = codeInferredScenarios;
-            if (traceResult && traceResult.userFlows.length > 0) {
-                const traceScenarios = traceResult.userFlows.slice(0, 5).map((flow, idx) => ({
-                    scenarioName: `trace-flow-${idx + 1}`,
-                    description: `User flow from trace: ${flow.entries.map(e => `${e.method} ${e.path}`).join(" \u2192 ")}`,
-                    category: "workflow",
-                    priority: "high",
-                    steps: flow.entries.map((e, stepIdx) => ({
-                        order: stepIdx + 1,
-                        method: e.method,
-                        path: e.path,
-                        description: `${e.method} ${e.path} \u2192 ${e.statusCode}`,
-                        interactionType: e.statusCode < 400 ? "success" : "error",
-                        requestBody: e.requestBody,
-                        responseBody: e.responseBody,
-                        expectedStatusCode: e.statusCode,
-                    })),
-                    chainingKeys: [],
-                    requiresAuth: true,
-                    estimatedComplexity: flow.entries.length > 3 ? "complex" : "moderate",
-                    source: "trace",
-                }));
-                allDraftedScenarios = [...traceScenarios, ...codeInferredScenarios];
-            }
-            const skeletonState = {
-                repositoryPath: params.repositoryPath,
-                analysisScope,
-                analysis: {
-                    metadata: {
-                        repositoryName: path.basename(params.repositoryPath),
-                        analysisDate: new Date().toISOString(),
-                        scanDepth: params.scanDepth || "full",
-                        analysisScope,
-                    },
-                    projectClassification: {
-                        projectType: projectMeta.projectType,
-                        primaryLanguage: projectMeta.primaryLanguage,
-                        primaryFramework: projectMeta.primaryFramework,
-                        deploymentPattern: projectMeta.deploymentPattern,
-                    },
-                    technologyStack: { languages: projectMeta.languages, frameworks: projectMeta.frameworks, runtime: projectMeta.runtime, keyDependencies: [] },
-                    businessContext: {
-                        mainPurpose: "",
-                        userFlows: [],
-                        dataFlows: [],
-                        integrationPatterns: [],
-                        draftedScenarios: allDraftedScenarios,
-                    },
-                    artifacts: {
-                        openApiSpecs: wsSchemaPath ? [{
-                                path: wsSchemaPath,
-                                version: "from-workspace-config",
-                                endpointCount: 0,
-                                baseUrl: wsBaseUrl,
-                                authType: wsAuthMethod,
-                            }] : [],
-                        playwrightRecordings: [], traceFiles: [], notFound: [],
-                    },
-                    apiEndpoints: {
-                        totalCount: skeletonEndpoints.reduce((acc, ep) => acc + ep.methods.length, 0),
-                        baseUrl: wsBaseUrl,
-                        endpoints: skeletonEndpoints,
-                    },
-                    authentication: {
-                        method: wsAuthMethod,
-                        configLocation: wsAuthHeader ? ".skyramp/workspace.yml" : "",
-                        envVarsRequired: [],
-                        setupExample: wsAuthHeader ? `${wsAuthHeader}: <token>` : "",
-                    },
-                    infrastructure: { isContainerized: projectMeta.isContainerized, hasDockerCompose: projectMeta.hasDockerCompose, hasKubernetes: false, hasCiCd: projectMeta.hasCiCd },
-                    existingTests: discoveredTests,
-                    ...(diffContext ? { branchDiffContext: diffContext } : {}),
-                },
-            };
-            storeSessionData(sessionId, skeletonState);
-            registerSession(sessionId, `memory://${sessionId}`);
-            logger.info("Stored analysis skeleton in process memory", {
-                sessionId,
-                endpointCount: skeletonEndpoints.length,
-            });
-            // F2: Notify clients that new MCP resources are available
-            try {
-                await server.server.sendResourceListChanged();
-            }
-            catch {
-                // Client may not support resource list notifications
-            }
-            await sendProgress(70, 100, "Preparing LLM instructions...");
-            const routerMountContext = grepRouterMountingContext(params.repositoryPath);
-            await sendProgress(100, 100, "Analysis session ready.");
-            const outputText = buildAnalysisOutputText({
-                sessionId,
-                repositoryPath: params.repositoryPath,
-                analysisScope,
-                parsedDiff,
-                scannedEndpoints,
-                wsBaseUrl,
-                wsAuthHeader,
-                wsSchemaPath,
-                routerMountContext,
-            });
-            // B2: Structured JSON summary prepended to output
-            const structuredSummary = JSON.stringify({
-                sessionId,
-                summary: {
-                    repositoryName: path.basename(params.repositoryPath),
-                    projectType: projectMeta.projectType,
-                    primaryFramework: projectMeta.primaryFramework,
-                    endpointCount: skeletonEndpoints.reduce((acc, ep) => acc + ep.methods.length, 0),
-                    scenarioCount: skeletonState.analysis.businessContext.draftedScenarios.length,
-                    interactionCount: skeletonEndpoints.reduce((acc, ep) => acc + ep.methods.reduce((a2, m) => a2 + m.interactions.length, 0), 0),
-                },
-                resources: {
-                    summary: `skyramp://analysis/${sessionId}/summary`,
-                    endpoints: `skyramp://analysis/${sessionId}/endpoints`,
-                    scenarios: `skyramp://analysis/${sessionId}/scenarios`,
-                    diff: analysisScope === "current_branch_diff" ? `skyramp://analysis/${sessionId}/diff` : undefined,
-                },
-                nextStep: "Call skyramp_recommend_tests with sessionId, or read resources for details",
-            }, null, 2);
-            return {
-                content: [
-                    { type: "text", text: `\`\`\`json\n${structuredSummary}\n\`\`\`\n\n${outputText}` },
-                ],
-                isError: false,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error("Analyze repository tool failed", { error: errorMessage });
-            errorResult = {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error analyzing repository: ${errorMessage}`,
-                    },
-                ],
-                isError: true,
-            };
-            return errorResult;
-        }
-        finally {
-            AnalyticsService.pushMCPToolEvent(TOOL_NAME, errorResult, {
-                repositoryPath: params.repositoryPath,
-            });
-        }
-    });
-}