@skyramp/mcp 0.2.6 → 0.2.8-rc.1

package/build/tools/test-management/actionsTool.d.ts

@@ -0,0 +1,10 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Compute a suggested new filename when an endpoint is renamed.
+ */
+export declare function computeRenamedTestFile(testFile: string, renames: Array<{
+    oldPath: string;
+    newPath: string;
+    method: string;
+}>): string | null;
+export declare function registerActionsTool(server: McpServer): void;

package/build/tools/test-management/actionsTool.js

@@ -6,6 +6,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { AnalyticsService } from "../../services/AnalyticsService.js";
 import { toolError } from "../../utils/utils.js";
+import { stageGeneratedPaths } from "../../utils/gitStaging.js";
 import { buildRenameStrategy, buildFileRenameStrategy, buildUpdateStrategy, buildRegenerateStrategy, buildUpdateFileInstruction, buildRegenerateFileInstruction, } from "../../prompts/test-maintenance/actionsInstructions.js";
 /**
  * Compute a suggested new filename when an endpoint is renamed.
@@ -87,6 +88,10 @@ const actionsSchema = {
         .string()
         .refine((p) => path.isAbsolute(p), { message: "stateFile must be an absolute path" })
         .describe("Path to state file from skyramp_analyze_changes"),
+    repository: z
+        .string()
+        .optional()
+        .describe("The owner/repo whose analysis section to act on (e.g. 'letsramp/api-insight'). In a multi-repo run, ALWAYS set it — the primary's owner/repo for the primary repo's tests, or a related repo's owner/repo for that repo's section — within the run-scoped stateFile. Omit only for a single-repo run."),
     recommendations: z
         .array(recommendationSchema)
         .optional()
@@ -106,12 +111,12 @@ export function registerActionsTool(server) {
     }, async (args) => {
         let errorResult;
         try {
-            logger.info("Performing Actions (unified test-management)");
-            // Load UnifiedAnalysisState from state file
+            logger.info(`Performing Actions (unified test-management)${args.repository ? ` for repository ${args.repository}` : ""}`);
+            // Load UnifiedAnalysisState for the requested repo section (primary when
+            // repository omitted/matches the root) from the run-scoped state file.
             const stateManager = StateManager.fromStatePath(args.stateFile);
-            const stateData = await stateManager.readData();
-            const fullState = await stateManager.readFullState();
-            const repositoryPath = fullState?.metadata.repositoryPath || "";
+            const stateData = await stateManager.readRepoData(args.repository);
+            const repositoryPath = (await stateManager.getRepoRepositoryPath(args.repository)) || "";
             if (!stateData) {
                 errorResult = toolError(`State file is empty or invalid: ${args.stateFile}. Call skyramp_analyze_changes first to generate a valid state file.`);
                 return errorResult;
@@ -365,6 +370,15 @@ export function registerActionsTool(server) {
                 });
                 llmInstructionsObj.regenerate_strategy = buildRegenerateStrategy();
             }
+            // Stage UPDATE and REGENERATE target paths so testbot's re-stage step
+            // commits the agent's edits even when files are outside testDirectory.
+            const stagedPaths = [
+                ...updateRecommendations.map((r) => r.testFile),
+                ...regenerateRecommendations.map((r) => r.testFile),
+            ];
+            for (const p of stagedPaths) {
+                await stageGeneratedPaths(p).catch((e) => logger.warning(`Failed to stage maintained file ${p}: ${e.message}`));
+            }
             const llmInstructions = JSON.stringify(llmInstructionsObj, null, 2);
             const contentBlocks = [
                 {
@@ -394,8 +408,8 @@ export function registerActionsTool(server) {
         finally {
             let repositoryPath = "";
             try {
-                const fullState = await StateManager.fromStatePath(args.stateFile).readFullState();
-                repositoryPath = fullState?.metadata.repositoryPath || "";
+                repositoryPath =
+                    (await StateManager.fromStatePath(args.stateFile).getRepoRepositoryPath(args.repository)) || "";
             }
             catch (analyticsError) {
                 logger.error(`Failed to read state for analytics in actions tool: ${analyticsError?.message ?? analyticsError}`, analyticsError);

package/build/tools/test-management/analyzeChangesTool.d.ts

@@ -0,0 +1,27 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { CandidateUiPage } from "../../utils/uiPageEnumerator.js";
+import { TraceFile } from "../../types/RepositoryAnalysis.js";
+import { ScannedEndpoint } from "../../utils/repoScanner.js";
+import { TraceParseResult } from "../../utils/trace-parser.js";
+/** Exported for testing: maps a parsed trace result to a TraceFile. */
+export declare function buildTraceFileEntry(tracePath: string, result: TraceParseResult): TraceFile;
+export declare function isSecurityRelevantDiff(diffContent: string): boolean;
+export declare function filterEndpointsBySpec(scannedEndpoints: ScannedEndpoint[], specPaths: Set<string>, specPathItems: Record<string, any>, diffChangedPaths: Set<string>): ScannedEndpoint[];
+export declare function isGraphQLFile(filePath: string, repositoryPath: string): Promise<boolean>;
+export declare function filterUnsupportedGraphQLEndpoints(endpoints: ScannedEndpoint[], repositoryPath: string): Promise<ScannedEndpoint[]>;
+export declare const analyzeChangesInputSchema: {
+    repositoryPath: z.ZodString;
+    scope: z.ZodOptional<z.ZodDefault<z.ZodEnum<["full_repo", "branch_diff"]>>>;
+    baseBranch: z.ZodOptional<z.ZodString>;
+    testDirectory: z.ZodOptional<z.ZodString>;
+    topN: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    maxGenerate: z.ZodOptional<z.ZodNumber>;
+    prNumber: z.ZodOptional<z.ZodNumber>;
+    repository: z.ZodOptional<z.ZodString>;
+    testsRepoDir: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+};
+export declare const NO_UI_INSTRUCTIONS = "No UI changes detected \u2014 no blueprint capture needed.";
+export declare const NO_RESOLVABLE_URLS_INSTRUCTIONS = "Frontend changes detected but no candidate URLs could be resolved (workspace baseUrl missing or no router files matched). UI recommendations will be source-grounded only.";
+export declare function buildCaptureInstructions(pages: CandidateUiPage[]): string;
+export declare function registerAnalyzeChangesTool(server: McpServer): void;

package/build/tools/test-management/analyzeChangesTool.js

@@ -8,7 +8,7 @@ import { simpleGit } from "simple-git";
 import { logger } from "../../utils/logger.js";
 import { parseWorkspaceAuthType, getDefaultAuthHeader, WorkspaceAuthType, readWorkspaceConfigRaw } from "../../utils/workspaceAuth.js";
 import { AnalyticsService } from "../../services/AnalyticsService.js";
-import { StateManager, registerSession, storeSessionData, setTestsRepoDir, } from "../../utils/AnalysisStateManager.js";
+import { StateManager, registerSession, storeSessionData, setTestsRepoDir, getActiveRunStatePath, setActiveRunStatePath, } from "../../utils/AnalysisStateManager.js";
 import { buildRecommendationPrompt } from "../../prompts/test-recommendation/test-recommendation-prompt.js";
 import { hasFlutterSdkDep, isFrontendFile, isTestFile } from "../../prompts/test-recommendation/scopeAssessment.js";
 import { enumerateCandidateUiPages } from "../../utils/uiPageEnumerator.js";
@@ -24,6 +24,32 @@ import { buildAnalysisOutputText } from "../../prompts/test-recommendation/analy
 import { parseTraceFile, discoverTraceFiles, discoverPlaywrightZips, } from "../../utils/trace-parser.js";
 import { TestSource } from "../../types/TestAnalysis.js";
 import { parsePRComments } from "../../utils/pr-comment-parser.js";
+// Generic module names that appear as imports in virtually every router file.
+// Matching against these would extract ALL prefix= tokens from mount files,
+// flooding changedResources with unrelated resources.
+const GENERIC_MODULE_NAMES = new Set([
+    "models", "utils", "helpers", "schemas", "types", "constants",
+    "config", "settings", "exceptions", "errors", "base", "common",
+    "app", "main", "index", "server", "init", "deps", "dependencies",
+]);
+function resolveMountPrefixTokens(mountFileContents, changedFiles) {
+    const tokens = changedFiles.flatMap((file) => {
+        const mod = path.basename(file).replace(/\.[^.]+$/, "").toLowerCase();
+        if (GENERIC_MODULE_NAMES.has(mod))
+            return [];
+        const modRe = new RegExp(`\\b${mod.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`);
+        return mountFileContents.flatMap((content) => {
+            if (!modRe.test(content.toLowerCase()))
+                return [];
+            const matches = [...content.matchAll(/prefix\s*=\s*["'](\/?[^"']+)/g)];
+            return matches.flatMap((m) => {
+                const token = extractResourceFromPath(m[1]);
+                return token !== "unknown" ? [token] : [];
+            });
+        });
+    });
+    return [...new Set(tokens)];
+}
 /** Exported for testing: maps a parsed trace result to a TraceFile. */
 export function buildTraceFileEntry(tracePath, result) {
     return {
@@ -339,17 +365,44 @@ export const analyzeChangesInputSchema = {
         .number()
         .optional()
         .describe("GitHub PR number. When provided, fetches previous TestBot comments on this PR and skips re-recommending tests already suggested in earlier commits — reduces duplicate recommendations across multiple pushes to the same PR."),
-    stateOutputFile: z
+    repository: z
         .string()
-        .refine((v) => path.isAbsolute(v), { message: "stateOutputFile must be an absolute path" })
         .optional()
-        .describe("Absolute path where the state file should be written. When provided, overrides the default auto-generated temp path so the caller can locate it without log parsing."),
+        .describe("The owner/repo this call analyzes (e.g. 'letsramp/api-insight'). In a multi-repo run, ALWAYS set it — for the primary AND every related repo. All calls in one Testbot run share ONE state file automatically (you do NOT pass a file path); each repo's analysis is stored as its own section within it. The primary's analysis is kept at the root and tagged with its owner/repo; related repos are stored as keyed sections. Omit only for a single-repo run."),
     testsRepoDir: z
         .string()
         .refine((v) => path.isAbsolute(v), { message: "testsRepoDir must be an absolute path" })
         .optional()
         .describe("Absolute path to a separate test repository clone. When set, existing test discovery scans this directory instead of repositoryPath. Used in cross-repo test delivery mode where tests live in a separate repo."),
 };
+// ── UI blueprint-capture instructions ──
+// Moved here from the former skyramp_ui_analyze_changes pre-flight tool. These
+// strings + buildCaptureInstructions are appended to the tool output so the
+// agent captures browser_blueprints on the candidate UI pages after this call.
+// The captures stay in its tool-result history and serve as element vocabulary
+// for UI recommendation reasoning (enforced at submit time by the Blueprint
+// Citation Invariant in the testbot prompt).
+export const NO_UI_INSTRUCTIONS = `No UI changes detected — no blueprint capture needed.`;
+export const NO_RESOLVABLE_URLS_INSTRUCTIONS = `Frontend changes detected but no candidate URLs could be resolved (workspace baseUrl missing or no router files matched). UI recommendations will be source-grounded only.`;
+export function buildCaptureInstructions(pages) {
+    const pagesYaml = pages
+        .map((p, i) => `  ${i + 1}. ${p.url}  (sourcedFrom: ${p.sourcedFrom.join(", ") || "(none)"}, strategy: ${p.strategy})`)
+        .join("\n");
+    return `Frontend changes detected. **Before writing any UI recommendation \`reasoning\`, capture blueprints on the candidate UI pages below.** Those captures stay in your tool-result history and serve as element vocabulary — the recommendation catalog further down gives you the authoring rules; you bring the observed elements.
+
+**Candidate URLs:**
+${pagesYaml}
+
+**For each candidate URL:**
+  - \`browser_navigate\` to the URL
+  - \`browser_blueprint\` to capture the page
+
+You don't need to thread the blueprints back into a tool call — they're in your context once captured.
+
+If a candidate URL 404s or redirects unexpectedly, navigate from the workspace baseUrl and explore (admin apps mount routes under base prefixes the source extraction can't see). If the page rendered but lacks the changed feature (gated UI: modal, dropdown, accordion), do NOT iterate further during this step — UI recs will fall back to source-grounded prose for those, and the agent's later trace recording (Task 2) will navigate into the gate via capture-act-capture.
+
+If \`browser_blueprint\` fails on every candidate URL (app unreachable, all 404s), proceed and log an \`issuesFound\` info entry. Recommendations will be source-grounded; non-UI work is unaffected.`;
+}
 export function registerAnalyzeChangesTool(server) {
     server.registerTool(TOOL_NAME, {
         annotations: {
@@ -540,6 +593,30 @@ export function registerAnalyzeChangesTool(server) {
             // testsRepoDir is a cross-repo path override — honour it when set.
             // Otherwise always scan the full repo root.
             const testDir = params.testsRepoDir ?? undefined;
+            const routerMountContext = grepRouterMountingContext(params.repositoryPath);
+            // Read contents once — used for token extraction and LLM prompt injection.
+            const ROUTER_INLINE_LIMIT = 4096;
+            const routerMountContextContents = routerMountContext.map((f) => {
+                try {
+                    const abs = path.isAbsolute(f) ? f : path.join(params.repositoryPath, f);
+                    if (fs.statSync(abs).size > ROUTER_INLINE_LIMIT * 10)
+                        return ""; // skip very large files
+                    return fs.readFileSync(abs, "utf-8");
+                }
+                catch {
+                    return "";
+                }
+            });
+            // Size-capped subset for LLM prompt injection.
+            const ROUTER_INLINE_MAX_FILES = 3;
+            const routerFileContents = routerMountContext
+                .slice(0, ROUTER_INLINE_MAX_FILES)
+                .flatMap((f, i) => {
+                const content = routerMountContextContents[i] ?? "";
+                if (!content || content.length > ROUTER_INLINE_LIMIT)
+                    return [];
+                return [{ file: f, content: content.trimEnd() }];
+            });
             // Compute changedResources from classified endpoints for test discovery filtering.
             // undefined    → full-repo mode (no diff context)
             // []           → PR mode, no endpoints found → skip external tests
@@ -568,14 +645,22 @@ export function registerAnalyzeChangesTool(server) {
                     }
                     else {
                         // All endpoints resolved to "unknown" (e.g. NestJS relative paths) —
-                        // extract resource names from changed file paths instead.
-                        const candidateFiles = classifiedEndpoints.unmatchedFiles.length > 0
-                            ? classifiedEndpoints.unmatchedFiles
-                            : classifiedEndpoints.changedFiles ?? [];
-                        const fromFiles = candidateFiles
-                            .map((f) => extractResourceFromPath(f.replace(/\.[^./]+$/, "").replace(FRAMEWORK_SUFFIX_RE, "")))
-                            .filter((r, i, arr) => r !== "unknown" && arr.indexOf(r) === i);
-                        changedResources = fromFiles.length > 0 ? fromFiles : ["unknown"];
+                        // first try to extract resource names from router mount prefixes.
+                        const changedSourceFiles = classifiedEndpoints.changedFiles ?? [];
+                        const mountedResources = resolveMountPrefixTokens(routerMountContextContents, changedSourceFiles);
+                        if (mountedResources.length > 0) {
+                            changedResources = mountedResources;
+                        }
+                        else {
+                            // Fall back to extracting resource names from changed file paths.
+                            const candidateFiles = classifiedEndpoints.unmatchedFiles.length > 0
+                                ? classifiedEndpoints.unmatchedFiles
+                                : classifiedEndpoints.changedFiles ?? [];
+                            const fromFiles = candidateFiles
+                                .map((f) => extractResourceFromPath(f.replace(/\.[^./]+$/, "").replace(FRAMEWORK_SUFFIX_RE, "")))
+                                .filter((r, i, arr) => r !== "unknown" && arr.indexOf(r) === i);
+                            changedResources = fromFiles.length > 0 ? fromFiles : ["unknown"];
+                        }
                     }
                 }
                 else if (classifiedEndpoints.unmatchedFiles.length > 0) {
@@ -594,7 +679,15 @@ export function registerAnalyzeChangesTool(server) {
                     changedResources = fromFiles.length > 0 ? fromFiles : ["unknown"];
                 }
                 else {
-                    changedResources = [];
+                    // No endpoints and no unmatched files — the diff touches only non-route
+                    // files (e.g. schema, model, DTO). Extract resource tokens from the
+                    // changed file paths so tests that import the changed symbol are still
+                    // surfaced for drift assessment. Fall back to [] only if extraction
+                    // yields nothing (e.g. a file with a non-resource name like utils.py).
+                    const fromChangedFiles = (classifiedEndpoints.changedFiles ?? [])
+                        .map((f) => extractResourceFromPath(f.replace(/\.[^./]+$/, "").replace(FRAMEWORK_SUFFIX_RE, "")))
+                        .filter((r, i, arr) => r !== "unknown" && arr.indexOf(r) === i);
+                    changedResources = fromChangedFiles.length > 0 ? fromChangedFiles : [];
                 }
             }
             let existingTests = [];
@@ -875,10 +968,15 @@ export function registerAnalyzeChangesTool(server) {
                         sourceFile: m.sourceFile ?? "",
                     })))
                     : [];
+            const removedEndpointsForDrafting = classifiedEndpoints?.removedEndpoints.flatMap((ep) => ep.methods.map((m) => ({
+                method: m,
+                path: ep.path,
+                sourceFile: ep.sourceFile,
+            }))) ?? [];
             const codeInferredScenarios = draftScenariosFromEndpoints(skeletonEndpoints, scenarioDraftSeed, wsAuthType, {
                 changedEndpoints: changedEndpointsForSecurityExpansion,
                 securityRelevantDiff,
-            });
+            }, removedEndpointsForDrafting);
             let allDraftedScenarios = codeInferredScenarios;
             if (traceResult && traceResult.userFlows.length > 0) {
                 const traceScenarios = traceResult.userFlows
@@ -1081,7 +1179,6 @@ export function registerAnalyzeChangesTool(server) {
             // can be persisted to the state file for downstream tools (health, drift).
             // Without them, analyzeTestHealth would work only off the static catalog
             // which has wrong paths for nested resources and unsupported frameworks.
-            const routerMountContext = grepRouterMountingContext(params.repositoryPath);
             const routeLikeUnmatchedFiles = [];
             for (const file of classifiedEndpoints?.unmatchedFiles ?? []) {
                 const routeLike = SOURCE_EXTS.test(file) &&
@@ -1110,25 +1207,6 @@ export function registerAnalyzeChangesTool(server) {
                 diffFilePath = path.join(os.tmpdir(), `skyramp-diff-${sessionId}.diff`);
                 await fs.promises.writeFile(diffFilePath, diffData.diffContent, { encoding: "utf-8", mode: 0o600 });
             }
-            // Read router mount files server-side (size-capped) so the LLM has them
-            // inline and doesn't need an extra read step when no spec is available.
-            const ROUTER_INLINE_LIMIT = 4096; // bytes — skip files larger than ~4 KB
-            const ROUTER_INLINE_MAX_FILES = 3;
-            const routerFileContents = routerMountContext
-                .slice(0, ROUTER_INLINE_MAX_FILES)
-                .flatMap((f) => {
-                try {
-                    const absPath = path.isAbsolute(f) ? f : path.join(params.repositoryPath, f);
-                    const stat = fs.statSync(absPath);
-                    if (stat.size > ROUTER_INLINE_LIMIT)
-                        return [];
-                    const content = fs.readFileSync(absPath, "utf-8").trimEnd();
-                    return [{ file: f, content }];
-                }
-                catch {
-                    return [];
-                }
-            });
             // Compute UI context from the diff's changed files using the shared
             // `isFrontendFile` classifier. Persisting this in the stateFile lets
             // skyramp_analyze_test_health and the recommendation prompt consume the
@@ -1136,9 +1214,9 @@ export function registerAnalyzeChangesTool(server) {
             //
             // candidateUiPages is enumerated programmatically via the strategy
             // ladder in uiPageEnumerator (framework route grep, source-grounded
-            // routes, root fallback). The same enumeration powers the
-            // skyramp_ui_analyze_changes pre-flight tool that the testbot prompt
-            // calls before this tool, so both code paths see the same candidates.
+            // routes, root fallback). The agent uses these to capture
+            // browser_blueprints — see uiInstructions below, which this tool returns
+            // so the agent captures element vocabulary for UI rec reasoning.
             const uiContext = await (async () => {
                 const changedFiles = classifiedEndpoints?.changedFiles ?? [];
                 if (changedFiles.length === 0)
@@ -1149,9 +1227,8 @@ export function registerAnalyzeChangesTool(server) {
                 // enumeration in.
                 // Compute hasFlutterSdkDep once and pass it through so .dart files
                 // in a Flutter project are recognised as frontend. See Confluence
-                // "Flutter support in Testbot" — this is the second budget-driving
-                // call site that must thread the flag (the other is
-                // uiAnalyzeChangesTool). Both must agree to avoid silent divergence.
+                // "Flutter support in Testbot" — this is the budget-driving call site
+                // that must thread the flag so a Flutter PR enters the UI pipeline.
                 const flutterSdk = hasFlutterSdkDep(params.repositoryPath);
                 const frontendFiles = changedFiles.filter((f) => isFrontendFile(f, { hasFlutterSdkDep: flutterSdk }) && !isTestFile(f));
                 if (frontendFiles.length === 0)
@@ -1162,6 +1239,16 @@ export function registerAnalyzeChangesTool(server) {
                     candidateUiPages,
                 };
             })();
+            // Derive the UI blueprint-capture instructions the agent acts on after
+            // this call. Mirrors the branching of the former skyramp_ui_analyze_changes
+            // pre-flight tool, now folded in here so the agent makes one analysis call
+            // instead of two. The captures stay in the agent's tool-result history and
+            // serve as element vocabulary when it writes UI recommendation reasoning.
+            const uiInstructions = !uiContext || uiContext.changedFrontendFiles.length === 0
+                ? NO_UI_INSTRUCTIONS
+                : uiContext.candidateUiPages.length === 0
+                    ? NO_RESOLVABLE_URLS_INSTRUCTIONS
+                    : buildCaptureInstructions(uiContext.candidateUiPages);
             const unifiedState = {
                 existingTests,
                 newEndpoints: newEndpointsForDrafting,
@@ -1215,22 +1302,37 @@ export function registerAnalyzeChangesTool(server) {
                     relevantExternalTestPaths,
                 },
             };
-            // Clean up old state files (>24 hours) before creating new one
-            const stateDir = params.stateOutputFile
-                ? path.dirname(path.resolve(params.stateOutputFile))
-                : undefined;
+            // Clean up old state files (>24 hours) before creating new one.
             try {
-                await StateManager.cleanupOldFiles(24, stateDir);
+                await StateManager.cleanupOldFiles(24);
             }
             catch (error) {
                 logger.warning(`Failed to cleanup old state files: ${error.message}`);
             }
-            const stateManager = new StateManager("analysis", sessionId, undefined, params.stateOutputFile);
-            await stateManager.writeData(unifiedState, {
+            // Resolve the state file. Multi-repo (`repository` set): all calls in one
+            // Testbot run share ONE state file — the first call creates it and records
+            // the run anchor; later related-repo calls reuse it (no agent-provided path,
+            // which previously caused filename hallucinations). Single-repo (`repository`
+            // absent): always a fresh per-call file — byte-identical to prior behavior.
+            const activeRunPath = params.repository
+                ? getActiveRunStatePath()
+                : undefined;
+            const stateManager = activeRunPath
+                ? StateManager.fromStatePath(activeRunPath)
+                : new StateManager("analysis", sessionId);
+            // `repository` identifies which repo this analysis belongs to. The primary
+            // (first write of the run, or matching the root's recorded repository) is
+            // stored at the root; a related repo is stored as a keyed section within the
+            // same run-scoped stateFile.
+            await stateManager.writeRepoData(unifiedState, {
+                repo: params.repository,
                 repositoryPath: params.repositoryPath,
                 step: "analyze_changes",
             });
             const stateFile = stateManager.getStatePath();
+            // Anchor the run's state file so subsequent related-repo calls reuse it.
+            if (params.repository)
+                setActiveRunStatePath(stateFile);
             registerSession(sessionId, stateFile);
             try {
                 await server.server.sendResourceListChanged();
@@ -1348,7 +1450,7 @@ export function registerAnalyzeChangesTool(server) {
                 content: [
                     {
                         type: "text",
-                        text: `\`\`\`json\n${structuredSummary}\n\`\`\`\n\n${outputText}\n\n---\n\n## Pre-built Test Catalog — Fill in placeholders from source code, then display verbatim\n⚠️ Do NOT reformat, rename sections, or generate a new catalog. Replace \`<…from source>\` values, then show this output exactly as-is, grouped by test type.\n\n${recommendationPrompt}`,
+                        text: `\`\`\`json\n${structuredSummary}\n\`\`\`\n\n## UI Blueprint Capture — do this BEFORE writing UI recommendation reasoning\n${uiInstructions}\n\n${outputText}\n\n---\n\n## Pre-built Test Catalog — Fill in placeholders from source code, then display verbatim\n⚠️ Do NOT reformat, rename sections, or generate a new catalog. Replace \`<…from source>\` values, then show this output exactly as-is, grouped by test type.\n\n${recommendationPrompt}`,
                     },
                 ],
                 isError: false,

package/build/tools/test-management/analyzeChangesTool.test.d.ts

@@ -0,0 +1 @@
+export {};