@skyramp/mcp 0.0.59 → 0.0.60-rc.2

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

@@ -1,174 +1,18 @@
 import { z } from "zod";
-import { simpleGit } from "simple-git";
+import * as crypto from "crypto";
+import * as path from "path";
 import { logger } from "../../utils/logger.js";
-import { getRepositoryAnalysisPrompt } from "../../prompts/test-recommendation/repository-analysis-prompt.js";
 import { AnalyticsService } from "../../services/AnalyticsService.js";
-import { StateManager, } from "../../utils/AnalysisStateManager.js";
-const MAX_DIFF_LENGTH = 50_000;
-/**
- * Parse the list of changed files from a unified diff string by scanning
- * for `diff --git a/... b/<file>` header lines.
- */
-function parseChangedFilesFromDiff(diffContent) {
-    const files = [];
-    for (const line of diffContent.split("\n")) {
-        const match = line.match(/^diff --git a\/.+ b\/(.+)$/);
-        if (match) {
-            files.push(match[1]);
-        }
-    }
-    return files;
-}
-/**
- * Extract an API endpoint definition from a single diff line.
- * Handles FastAPI, Flask, Express, and Spring patterns.
- */
-function parseRouteLine(line, sourceFile) {
-    const stripped = line.replace(/^[+-]\s*/, "").trim();
-    // FastAPI / Starlette: @router.get("/path") or @app.post("/path")
-    const decoratorMatch = stripped.match(/@(?:\w+)\.(get|post|put|patch|delete|head|options)\s*\(\s*["']([^"'?#]+)/i);
-    if (decoratorMatch) {
-        return {
-            method: decoratorMatch[1].toUpperCase(),
-            path: decoratorMatch[2],
-            sourceFile,
-        };
-    }
-    // Flask: @app.route("/path", methods=["GET"])
-    const flaskMatch = stripped.match(/@\w+\.route\s*\(\s*["']([^"'?#]+)["'][^)]*methods\s*=\s*\[["'](\w+)["']/i);
-    if (flaskMatch) {
-        return {
-            method: flaskMatch[2].toUpperCase(),
-            path: flaskMatch[1],
-            sourceFile,
-        };
-    }
-    // Express: router.get('/path', ...) or app.post('/path', ...)
-    const expressMatch = stripped.match(/(?:router|app)\.(get|post|put|patch|delete)\s*\(\s*["']([^"'?#]+)/i);
-    if (expressMatch) {
-        return {
-            method: expressMatch[1].toUpperCase(),
-            path: expressMatch[2],
-            sourceFile,
-        };
-    }
-    // Spring: @GetMapping("/path") or @PostMapping("/path")
-    const springMatch = stripped.match(/@(Get|Post|Put|Patch|Delete)Mapping\s*(?:\(\s*(?:value\s*=\s*)?["']([^"'?#]+)["'])?/i);
-    // Only capture Spring endpoints when an explicit path is provided.
-    // When no path argument is given, Spring uses the class-level @RequestMapping path,
-    // which we do not track here.
-    if (springMatch && springMatch[2]) {
-        return {
-            method: springMatch[1].toUpperCase(),
-            path: springMatch[2],
-            sourceFile,
-        };
-    }
-    return null;
-}
-/**
- * Parse a unified diff and extract new/modified API endpoints.
- * Processes diffContent entirely inside the tool — never embedded in the response.
- */
-function parseEndpointsFromDiff(diffData) {
-    const lines = diffData.diffContent.split("\n");
-    const addedRoutes = [];
-    const removedKeys = new Set();
-    let currentFile = "";
-    for (const line of lines) {
-        const fileMatch = line.match(/^diff --git a\/.+ b\/(.+)$/);
-        if (fileMatch) {
-            currentFile = fileMatch[1];
-            continue;
-        }
-        if (line.startsWith("+") && !line.startsWith("+++")) {
-            const ep = parseRouteLine(line, currentFile);
-            if (ep)
-                addedRoutes.push(ep);
-        }
-        else if (line.startsWith("-") && !line.startsWith("---")) {
-            const ep = parseRouteLine(line, currentFile);
-            if (ep)
-                removedKeys.add(`${ep.method} ${ep.path}`);
-        }
-    }
-    const newEndpoints = [];
-    const modifiedEndpoints = [];
-    for (const ep of addedRoutes) {
-        if (removedKeys.has(`${ep.method} ${ep.path}`)) {
-            modifiedEndpoints.push(ep);
-        }
-        else {
-            newEndpoints.push(ep);
-        }
-    }
-    // Infer services from changed file paths (e.g. src/services/order-service.ts)
-    const servicePattern = /(?:services?|modules?|apps?)\/([a-z0-9_-]+)/i;
-    const affectedServices = [
-        ...new Set(diffData.changedFiles
-            .map((f) => f.match(servicePattern)?.[1])
-            .filter((s) => !!s)),
-    ];
-    return {
-        currentBranch: diffData.currentBranch,
-        baseBranch: diffData.baseBranch,
-        changedFiles: diffData.changedFiles,
-        diffStat: diffData.diffStat,
-        newEndpoints,
-        modifiedEndpoints,
-        affectedServices,
-    };
-}
-async function computeBranchDiff(repositoryPath, providedBaseBranch) {
-    const git = simpleGit(repositoryPath);
-    const isRepo = await git.checkIsRepo();
-    if (!isRepo) {
-        throw new Error(`"${repositoryPath}" is not a Git repository.`);
-    }
-    const branchInfo = await git.branch();
-    const currentBranch = branchInfo.current || "HEAD";
-    let baseBranch;
-    if (providedBaseBranch) {
-        // Use the PR's base branch when explicitly provided (e.g. from testbot)
-        baseBranch = `origin/${providedBaseBranch}`;
-    }
-    else {
-        // Fall back to auto-detecting origin/main or origin/master
-        baseBranch = "origin/main";
-        try {
-            const remoteBranches = await git.branch(["-r"]);
-            if (remoteBranches.all.some((b) => b.endsWith("/main"))) {
-                baseBranch = "origin/main";
-            }
-            else if (remoteBranches.all.some((b) => b.endsWith("/master"))) {
-                baseBranch = "origin/master";
-            }
-        }
-        catch {
-            logger.debug("Could not determine remote default branch, falling back to origin/main");
-        }
-    }
-    const changedFilesRaw = await git.diff([
-        `${baseBranch}...HEAD`,
-        "--name-only",
-    ]);
-    const changedFiles = changedFilesRaw
-        .split("\n")
-        .map((f) => f.trim())
-        .filter((f) => f.length > 0);
-    const diffStat = await git.diff([`${baseBranch}...HEAD`, "--stat"]);
-    let diffContent = await git.diff([`${baseBranch}...HEAD`]);
-    if (diffContent.length > MAX_DIFF_LENGTH) {
-        diffContent =
-            diffContent.substring(0, MAX_DIFF_LENGTH) +
-                `\n\n... [diff truncated at ${MAX_DIFF_LENGTH} chars, ${changedFiles.length} files total] ...`;
-    }
-    return { currentBranch, baseBranch, changedFiles, diffContent, diffStat };
-}
-/**
- * Analyze Repository Tool
- * MCP tool for comprehensive repository analysis
- */
+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()
@@ -181,10 +25,6 @@ const analyzeRepositorySchema = z.object({
         .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."),
-    focusAreas: z
-        .array(z.string())
-        .optional()
-        .describe("Optional: Specific areas to focus on (e.g., ['api', 'frontend', 'infrastructure'])"),
     baseBranch: z
         .string()
         .optional()
@@ -219,7 +59,8 @@ This tool performs comprehensive repository analysis including:
 - Infrastructure configuration (Docker, Kubernetes, CI/CD)
 - Existing test coverage assessment
 
-The analysis provides structured data that can be used by skyramp_map_tests to calculate test priorities.
+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.
 
@@ -237,8 +78,18 @@ Example usage:
 
 Output: Detailed RepositoryAnalysis JSON object with all repository characteristics.`,
         inputSchema: analyzeRepositorySchema.shape,
-    }, async (params) => {
+    }, 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", {
@@ -246,8 +97,10 @@ Output: Detailed RepositoryAnalysis JSON object with all repository characterist
                 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", {
@@ -262,53 +115,332 @@ Output: Detailed RepositoryAnalysis JSON object with all repository characterist
                     throw new Error(`Failed to obtain branch diff: ${msg}`);
                 }
             }
-            // Parse the diff content inside the tool — never embed raw diff in the response.
+            await sendProgress(30, 100, "Parsing endpoints from diff...");
             const parsedDiff = diffData ? parseEndpointsFromDiff(diffData) : undefined;
-            const analysisPrompt = getRepositoryAnalysisPrompt(params.repositoryPath, analysisScope, parsedDiff);
-            const stateManager = new StateManager("recommendation");
-            const stateFilePath = stateManager.getStatePath();
-            logger.info("Created state file for analysis", {
-                stateFile: stateFilePath,
+            // 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 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: { statusCode: 200, description: "OK" },
+                            }],
+                    })),
+                }))
+                : (parsedDiff
+                    ? [...parsedDiff.newEndpoints, ...parsedDiff.modifiedEndpoints].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: [{
+                                method: ep.method,
+                                description: "",
+                                queryParams: [],
+                                authRequired: true,
+                                sourceFile: ep.sourceFile,
+                                interactions: [{
+                                        description: `${ep.method} ${ep.path}`,
+                                        type: "success",
+                                        request: {},
+                                        response: { statusCode: 200, description: "OK" },
+                                    }],
+                            }],
+                    }))
+                    : []);
+            const diffContext = parsedDiff ? {
+                currentBranch: parsedDiff.currentBranch,
+                baseBranch: parsedDiff.baseBranch,
+                changedFiles: parsedDiff.changedFiles,
+                newEndpoints: parsedDiff.newEndpoints.map((ep) => ({
+                    path: ep.path,
+                    methods: [{ method: ep.method, sourceFile: ep.sourceFile, interactionCount: 0 }],
+                })),
+                modifiedEndpoints: parsedDiff.modifiedEndpoints.map((ep) => ({
+                    path: ep.path,
+                    methods: [{ method: ep.method, sourceFile: ep.sourceFile, changeType: "modified" }],
+                })),
+                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) {
+                    const normalizedPath = entry.path.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})`,
+                                    },
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            // 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,
+                        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,
             });
-            // Compact diff section built entirely from pre-parsed data — no raw content
-            const diffSection = parsedDiff
-                ? `
-## Branch Diff Context
-**Branch**: \`${parsedDiff.currentBranch}\` → base: \`${parsedDiff.baseBranch}\`
-**Changed Files** (${parsedDiff.changedFiles.length}): ${parsedDiff.changedFiles.join(", ")}
-**New Endpoints** (${parsedDiff.newEndpoints.length}): ${parsedDiff.newEndpoints.map((e) => `${e.method} ${e.path}`).join(", ") || "none detected"}
-**Modified Endpoints** (${parsedDiff.modifiedEndpoints.length}): ${parsedDiff.modifiedEndpoints.map((e) => `${e.method} ${e.path}`).join(", ") || "none detected"}
-**Affected Services**: ${parsedDiff.affectedServices.join(", ") || "none detected"}
-`
-                : "";
+            // 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: `# Repository Analysis Request
-
-Please analyze the repository at: \`${params.repositoryPath}\`
-**Analysis Scope**: \`${analysisScope}\`
-
-${params.focusAreas ? `Focus on: ${params.focusAreas.join(", ")}\n` : ""}
-${diffSection}
-Use the following tools to gather information:
-- \`codebase_search\` - to understand code patterns and structure
-- \`grep\` - to find specific patterns (route definitions, dependencies, etc.)
-- \`glob_file_search\` - to find files by pattern (OpenAPI specs, config files, trace files, etc.)
-- \`read_file\` - to read specific files (package.json, requirements.txt, etc.)
-- \`list_dir\` - to explore directory structure
-
-${analysisPrompt}
-
-After gathering all information:
-1. Construct the RepositoryAnalysis JSON${analysisScope === "current_branch_diff" ? " (include branchDiffContext)" : ""}
-2. Save the complete JSON to this file: \`${stateFilePath}\`
-3. Then call \`skyramp_map_tests\` with:
-   - stateFile: \`${stateFilePath}\`
-   - analysisScope: \`${analysisScope}\`
-   Do NOT pass the JSON inline as analysisReport — use stateFile to avoid serialization issues with large JSON.`,
-                    },
+                    { type: "text", text: `\`\`\`json\n${structuredSummary}\n\`\`\`\n\n${outputText}` },
                 ],
                 isError: false,
             };