@skyramp/mcp 0.0.64-rc.8 → 0.0.64

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

@@ -1,274 +0,0 @@
-import { completable } from "@modelcontextprotocol/sdk/server/completable.js";
-import { z } from "zod";
-import { simpleGit } from "simple-git";
-import { StateManager, getSessionFilePath, getRegisteredSessions, getSessionData, hasSessionData, normalizeRecommendationState, } from "../../utils/AnalysisStateManager.js";
-import { logger } from "../../utils/logger.js";
-import { ANALYSIS_URI_PREFIX } from "../../resources/analysisResources.js";
-import { MAX_RECOMMENDATIONS, MAX_TESTS_TO_GENERATE } from "../../prompts/test-recommendation/recommendationSections.js";
-import { AnalyticsService } from "../../services/AnalyticsService.js";
-import { buildRecommendationPrompt } from "../../prompts/test-recommendation/test-recommendation-prompt.js";
-import { repositoryAnalysisSchema } from "../../types/RepositoryAnalysis.js";
-import { parsePRComments } from "../../utils/pr-comment-parser.js";
-import { getWorkspaceAuthConfig } from "../../utils/workspaceAuth.js";
-/**
- * Extract GitHub owner/repo from the origin remote URL.
- * Handles both SSH (git@github.com:owner/repo.git) and
- * HTTPS (https://github.com/owner/repo.git) formats.
- */
-async function getGitHubSlug(repoPath) {
-    try {
-        const git = simpleGit(repoPath);
-        const remotes = await git.getRemotes(true);
-        const origin = remotes.find((r) => r.name === "origin");
-        const url = origin?.refs?.fetch;
-        if (!url)
-            return null;
-        const sshMatch = url.match(/github\.com[:/]([^/]+)\/([^/.]+?)(?:\.git)?$/);
-        if (sshMatch)
-            return { owner: sshMatch[1], repo: sshMatch[2] };
-        const httpsMatch = url.match(/github\.com\/([^/]+)\/([^/.]+?)(?:\.git)?$/);
-        if (httpsMatch)
-            return { owner: httpsMatch[1], repo: httpsMatch[2] };
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-const recommendTestsSchema = {
-    sessionId: completable(z.string().optional().describe("Session ID from skyramp_analyze_repository. Optional if prNumber and repositoryPath are provided."), async (value) => {
-        return Array.from(getRegisteredSessions().keys()).filter((id) => id.startsWith(value?.toString() || ""));
-    }),
-    repositoryPath: z
-        .string()
-        .optional()
-        .describe("Absolute path to the repository. Required if sessionId is missing."),
-    topN: z
-        .number()
-        .default(MAX_RECOMMENDATIONS)
-        .describe(`Number of recommendations. Defaults to ${MAX_RECOMMENDATIONS}.`),
-    prNumber: z
-        .number()
-        .optional()
-        .describe("GitHub PR number. When provided, fetches previous TestBot comments to use as baseline recommendations."),
-};
-const TOOL_NAME = "skyramp_recommend_tests";
-export function registerRecommendTestsTool(server) {
-    server.registerTool(TOOL_NAME, {
-        description: `Generate actionable test recommendations based on enriched repository analysis.
-
-**PREREQUISITE**: Call skyramp_analyze_repository first to get the sessionId.
-
-This tool reads the enriched analysis (endpoints with interactions, drafted scenarios)
-and generates prioritized test recommendations using LLM reasoning over the actual data.
-
-For each recommended test, you'll get:
-- Priority (high/medium/low) with reasoning based on actual endpoint data
-- Specific test referencing concrete interactions (request→response pairs)
-- For integration/E2E: references to draftedScenarios by scenarioName
-- Which Skyramp tool to call for generation
-
-**Output guidelines:**
-- Use "high", "medium", or "low" for priority.
-- Never mark a test as blocked — recommend it with instructions for missing artifacts.
-- Reference specific interactions by description for contract/fuzz tests.
-- Reference draftedScenarios by scenarioName for integration/E2E tests.
-
-** This tool is currently in Early Preview stage. Please verify the results. **`,
-        inputSchema: recommendTestsSchema,
-    }, async (params) => {
-        let errorResult;
-        try {
-            logger.info("Recommend tests tool invoked", {
-                sessionId: params.sessionId,
-                topN: params.topN,
-                prNumber: params.prNumber,
-            });
-            let stateData = null;
-            let prContext = null;
-            let repositoryPath = params.repositoryPath || "";
-            let analysisScope = "current_branch_diff";
-            if (params.sessionId) {
-                // Load session data: try process memory first, then fall back to state file
-                if (hasSessionData(params.sessionId)) {
-                    stateData = getSessionData(params.sessionId);
-                    logger.info("Loaded analysis from process memory", { sessionId: params.sessionId });
-                }
-                else {
-                    // Fall back to state file for backward compatibility
-                    const registeredPath = getSessionFilePath(params.sessionId);
-                    const stateManager = registeredPath
-                        ? StateManager.fromStatePath(registeredPath)
-                        : StateManager.fromSessionId(params.sessionId);
-                    if (stateManager.exists()) {
-                        stateData = await stateManager.readData();
-                        logger.info("Loaded analysis from state file (legacy)", { sessionId: params.sessionId });
-                    }
-                }
-                if (!stateData) {
-                    throw new Error(`Analysis session not found: ${params.sessionId}.`);
-                }
-                stateData = normalizeRecommendationState(stateData);
-                repositoryPath = stateData.repositoryPath;
-                analysisScope = stateData.analysisScope;
-                prContext = stateData.prContext;
-            }
-            else if (params.prNumber && params.repositoryPath) {
-                // No sessionId provided — fetch PR context directly to use as baseline
-                const slug = await getGitHubSlug(params.repositoryPath);
-                if (slug) {
-                    try {
-                        prContext = await parsePRComments(slug.owner, slug.repo, params.prNumber);
-                        logger.info("Fetched PR context for baseline recommendations", { prNumber: params.prNumber });
-                    }
-                    catch (err) {
-                        throw new Error(`Failed to fetch PR context for baseline: ${err instanceof Error ? err.message : String(err)}`);
-                    }
-                }
-                else {
-                    throw new Error(`Could not determine GitHub repository slug for ${params.repositoryPath}`);
-                }
-                if (!prContext || prContext.previousRecommendations.length === 0) {
-                    throw new Error(`No previous recommendations found for PR #${params.prNumber}. A full analysis is required first.`);
-                }
-                // Build a minimal "analysis" from the previous recommendations to satisfy the prompt builder
-                stateData = {
-                    repositoryPath: params.repositoryPath,
-                    analysisScope: "current_branch_diff",
-                    analysis: {
-                        metadata: { repositoryName: slug.repo, analysisDate: new Date().toISOString(), scanDepth: "full", analysisScope: "current_branch_diff" },
-                        projectClassification: { projectType: "REST API", primaryLanguage: "unknown", primaryFramework: "unknown", deploymentPattern: "monolith" },
-                        technologyStack: { languages: [], frameworks: [], runtime: "", keyDependencies: [] },
-                        businessContext: { mainPurpose: "", userFlows: [], dataFlows: [], integrationPatterns: [], draftedScenarios: [] },
-                        apiEndpoints: { totalCount: 0, baseUrl: "", endpoints: [] },
-                        authentication: { method: "none", configLocation: "", envVarsRequired: [], setupExample: "" },
-                        infrastructure: { isContainerized: false, hasDockerCompose: false, hasKubernetes: false, hasCiCd: false },
-                        existingTests: { frameworks: [], coverage: { unit: 0, integration: 0, e2e: 0, ui: 0, load: 0, contract: 0, smoke: 0 }, testLocations: {}, hasCoverageReports: false },
-                    },
-                };
-            }
-            else {
-                throw new Error("Either sessionId or (prNumber and repositoryPath) must be provided.");
-            }
-            if (!stateData) {
-                throw new Error(`Failed to read analysis session: ${params.sessionId}. Run skyramp_analyze_repository first.`);
-            }
-            stateData = normalizeRecommendationState(stateData);
-            analysisScope = stateData.analysisScope;
-            repositoryPath = stateData.repositoryPath;
-            const { analysis } = stateData;
-            if (!analysis) {
-                throw new Error("Session is missing analysis data.");
-            }
-            // Validate analysis against the Zod schema to catch malformed LLM output early
-            const parseResult = repositoryAnalysisSchema.safeParse(analysis);
-            if (!parseResult.success) {
-                const issues = parseResult.error.issues.slice(0, 5).map((i) => `${i.path.join(".")}: ${i.message}`);
-                logger.warning("Analysis data has schema issues (proceeding with best-effort)", {
-                    issueCount: parseResult.error.issues.length,
-                    sample: issues,
-                });
-            }
-            // Guard critical nested fields the prompt builder accesses
-            if (!analysis.apiEndpoints?.endpoints) {
-                analysis.apiEndpoints = { totalCount: 0, baseUrl: "", endpoints: [] };
-            }
-            if (!analysis.businessContext?.draftedScenarios) {
-                analysis.businessContext = {
-                    ...(analysis.businessContext || { mainPurpose: "", userFlows: [], dataFlows: [], integrationPatterns: [] }),
-                    draftedScenarios: analysis.businessContext?.draftedScenarios || [],
-                };
-            }
-            if (!analysis.authentication) {
-                analysis.authentication = { method: "none", configLocation: "", envVarsRequired: [], setupExample: "" };
-            }
-            if (!analysis.existingTests) {
-                analysis.existingTests = {
-                    frameworks: [], coverage: { unit: 0, integration: 0, e2e: 0, ui: 0, load: 0, contract: 0, smoke: 0 },
-                    testLocations: {}, hasCoverageReports: false,
-                };
-            }
-            const scope = analysisScope || "full_repo";
-            const effectiveTopN = params.topN ?? MAX_RECOMMENDATIONS;
-            // Fetch PR context when prNumber is provided and in diff scope (if not already fetched)
-            if (!prContext && params.prNumber && scope === "current_branch_diff") {
-                const slug = await getGitHubSlug(repositoryPath);
-                if (slug) {
-                    try {
-                        prContext = await parsePRComments(slug.owner, slug.repo, params.prNumber);
-                    }
-                    catch (err) {
-                        logger.warning("Failed to fetch PR context", {
-                            error: err instanceof Error ? err.message : String(err),
-                        });
-                    }
-                }
-                else {
-                    logger.debug("Could not determine GitHub owner/repo from git remotes — skipping PR context");
-                }
-            }
-            const wsAuthConfig = repositoryPath
-                ? await getWorkspaceAuthConfig(repositoryPath)
-                : {};
-            const prompt = buildRecommendationPrompt(analysis, scope, effectiveTopN, prContext, wsAuthConfig.authHeader, wsAuthConfig.authType);
-            // H3: Mode-specific output header
-            const modeLabel = scope === "current_branch_diff" ? "PR Mode" : "Repo Mode";
-            const modeDesc = scope === "current_branch_diff"
-                ? `Focused on branch changes. Top ${effectiveTopN} recommendations — top 4 will be generated, remaining reported.`
-                : `Comprehensive test strategy. Top ${effectiveTopN} tests across the entire application.`;
-            // J4: PR awareness messaging
-            let prAwareness = "";
-            if (prContext && prContext.previousRecommendations.length > 0) {
-                const implemented = prContext.previousRecommendations.filter((r) => r.status === "implemented").length;
-                const pending = prContext.previousRecommendations.filter((r) => r.status === "recommended").length;
-                prAwareness = `\n**PR History**: ${implemented} tests already implemented, ${pending} previously recommended.`;
-                if (implemented > 0) {
-                    prAwareness += ` Building on existing coverage — new recommendations complement what\'s already been added.`;
-                }
-            }
-            // G4: Include totalConsidered instruction in output
-            const totalEndpointMethods = analysis.apiEndpoints.endpoints.reduce((acc, ep) => acc + (ep.methods?.length || 0), 0);
-            const totalInteractions = analysis.apiEndpoints.endpoints.reduce((acc, ep) => acc + (ep.methods || []).reduce((a2, m) => a2 + (m.interactions?.length || 0), 0), 0);
-            const totalScenarios = analysis.businessContext.draftedScenarios.length;
-            const resourcesSection = params.sessionId ? `
-## Available Resources
-- Summary: \`${ANALYSIS_URI_PREFIX}/${params.sessionId}/summary\`
-- Endpoints: \`${ANALYSIS_URI_PREFIX}/${params.sessionId}/endpoints\`
-- Scenarios: \`${ANALYSIS_URI_PREFIX}/${params.sessionId}/scenarios\`
-` : '';
-            const output = `# Test Recommendations (${modeLabel})
-
-${params.sessionId ? `**Session**: \`${params.sessionId}\`\n` : ''}**Repository**: \`${repositoryPath}\`
-**Mode**: ${modeLabel} — ${modeDesc}${prAwareness}
-**Catalog**: ${totalEndpointMethods} endpoint methods, ${totalInteractions} interactions, ${totalScenarios} scenarios
-**Target**: Top ${effectiveTopN} recommendations ranked by value. Top ${MAX_TESTS_TO_GENERATE} = generate & execute. #${MAX_TESTS_TO_GENERATE + 1}-#${effectiveTopN} = report as additional recommendations.
-${resourcesSection}
----
-
-${prompt}
-
-** This tool is currently in Early Preview stage. Please verify the results. **`;
-            return {
-                content: [{ type: "text", text: output }],
-                isError: false,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error("Recommend tests tool failed", { error: errorMessage });
-            errorResult = {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error generating recommendations: ${errorMessage}`,
-                    },
-                ],
-                isError: true,
-            };
-            return errorResult;
-        }
-        finally {
-            AnalyticsService.pushMCPToolEvent(TOOL_NAME, errorResult, {});
-        }
-    });
-}