@skyramp/mcp 0.1.2 → 0.1.4

package/build/tools/generate-tests/generateBatchScenarioRestTool.test.js

@@ -9,6 +9,7 @@ describe("stepSchema — requestBody validation", () => {
         const result = stepSchema.safeParse({
             method: "POST",
             path: "/api/v1/products",
+            statusCode: 201,
             requestBody: JSON.stringify({ name: "Widget-123", price: 9.99 }),
         });
         expect(result.success).toBe(true);
@@ -17,6 +18,7 @@ describe("stepSchema — requestBody validation", () => {
         const result = stepSchema.safeParse({
             method: "POST",
             path: "/api/v1/products",
+            statusCode: 201,
             requestBody: "{}",
         });
         expect(result.success).toBe(false);
@@ -28,6 +30,7 @@ describe("stepSchema — requestBody validation", () => {
         const result = stepSchema.safeParse({
             method: "PATCH",
             path: "/api/v1/orders/1",
+            statusCode: 200,
             requestBody: "{}",
         });
         expect(result.success).toBe(false);
@@ -37,6 +40,7 @@ describe("stepSchema — requestBody validation", () => {
         const result = stepSchema.safeParse({
             method: "PUT",
             path: "/api/v1/products/1",
+            statusCode: 200,
             requestBody: "{}",
         });
         expect(result.success).toBe(false);
@@ -49,6 +53,7 @@ describe("stepSchema — requestBody validation", () => {
         const result = stepSchema.safeParse({
             method: "POST",
             path: "/api/v1/products",
+            statusCode: 201,
         });
         expect(result.success).toBe(true);
     });
@@ -57,6 +62,7 @@ describe("stepSchema — requestBody validation", () => {
         const result = stepSchema.safeParse({
             method: "POST",
             path: "/api/v1/products",
+            statusCode: 201,
             requestBody: "null",
         });
         expect(result.success).toBe(true); // null is not an empty object — not rejected
@@ -65,6 +71,7 @@ describe("stepSchema — requestBody validation", () => {
         const result = stepSchema.safeParse({
             method: "GET",
             path: "/api/v1/products/1",
+            statusCode: 200,
         });
         expect(result.success).toBe(true);
     });
@@ -72,6 +79,7 @@ describe("stepSchema — requestBody validation", () => {
         const result = stepSchema.safeParse({
             method: "DELETE",
             path: "/api/v1/products/1",
+            statusCode: 204,
         });
         expect(result.success).toBe(true);
     });
@@ -81,6 +89,7 @@ describe("stepSchema — requestBody validation", () => {
         const result = stepSchema.safeParse({
             method: "GET",
             path: "/api/v1/products",
+            statusCode: 200,
             requestBody: "{}",
         });
         expect(result.success).toBe(true);

package/build/tools/submitReportTool.js

@@ -120,8 +120,9 @@ export function registerSubmitReportTool(server) {
                 .string()
                 .optional()
                 .default(DEFAULT_COMMIT_MESSAGE)
-                .describe("Succinct commit message (under 72 chars) summarizing what the testbot did, " +
-                "e.g. 'add contract tests for /products endpoint' or 'update smoke tests for order API changes'"),
+                .describe("Succinct commit message (if possible, under 72 chars) summarizing what Testbot did, " +
+                "e.g. 'add contract tests for /products endpoint' or 'update smoke tests for order API changes'. " +
+                "Used as both the git commit subject and the side PR title — the consumer applies truncation as needed."),
         },
         _meta: {
             keywords: ["report", "summary", "testbot", "submit"],
@@ -161,7 +162,7 @@ export function registerSubmitReportTool(server) {
             testResults: params.testResults,
             issuesFound: params.issuesFound,
             nextSteps: params.nextSteps ?? [],
-            commitMessage: (params.commitMessage ?? "").replace(/[\r\n]+/g, " ").trim().slice(0, 72) || DEFAULT_COMMIT_MESSAGE,
+            commitMessage: (params.commitMessage ?? "").replace(/[\r\n]+/g, " ").trim() || DEFAULT_COMMIT_MESSAGE,
         }, null, 2);
         logger.info("Submitting testbot report", {
             outputFile: params.summaryOutputFile,

package/build/tools/submitReportTool.test.js

@@ -128,7 +128,7 @@ describe("registerSubmitReportTool", () => {
         const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
         expect(written.commitMessage).toBe("Added recommendations by Skyramp Testbot.");
     });
-    it("should sanitize commitMessage (newlines, length)", async () => {
+    it("should sanitize commitMessage (collapse newlines, trim whitespace)", async () => {
         const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
         tmpDirs.push(tmpDir);
         const outputFile = path.join(tmpDir, "report.json");
@@ -139,7 +139,21 @@ describe("registerSubmitReportTool", () => {
         expect(result.isError).toBeUndefined();
         const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
         expect(written.commitMessage).toBe("line one line two line three");
-        expect(written.commitMessage.length).toBeLessThanOrEqual(72);
+        // No length cap — truncation is the consumer's responsibility (SKYR-3757).
+    });
+    it("should preserve commitMessage longer than 72 chars without truncation", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
+        tmpDirs.push(tmpDir);
+        const outputFile = path.join(tmpDir, "report.json");
+        const longMessage = "add contract and integration tests for the new PATCH /orders/{order_id} endpoint including discount recalculation and line-item edits";
+        const result = await handler({
+            ...sampleReportParams(outputFile),
+            commitMessage: longMessage,
+        });
+        expect(result.isError).toBeUndefined();
+        const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
+        expect(written.commitMessage).toBe(longMessage);
+        expect(written.commitMessage.length).toBeGreaterThan(72);
     });
     it("should use default commitMessage when provided as empty string", async () => {
         const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));

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

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import * as crypto from "crypto";
 import * as fs from "fs";
+import * as os from "os";
 import * as path from "path";
 import { simpleGit } from "simple-git";
 import { logger } from "../../utils/logger.js";
@@ -12,7 +13,7 @@ import { MAX_RECOMMENDATIONS, MAX_TESTS_TO_GENERATE } from "../../prompts/test-r
 import { TestDiscoveryService } from "../../services/TestDiscoveryService.js";
 import { ScenarioSource, AnalysisScope } from "../../types/RepositoryAnalysis.js";
 import { computeBranchDiff } from "../../utils/branchDiff.js";
-import { parseEndpointsFromDiff, resolveEndpointPaths, extractResourceFromPath, } from "../../utils/routeParsers.js";
+import { parseFileEndpoints, extractResourceFromPath, classifyEndpointsByChangedFiles, } from "../../utils/routeParsers.js";
 import { scanAllRepoEndpoints, scanRelatedEndpoints, grepRouterMountingContext, findCandidateRouteFiles, } from "../../utils/repoScanner.js";
 import { detectProjectMetadata } from "../../utils/projectMetadata.js";
 import { draftScenariosFromEndpoints } from "../../utils/scenarioDrafting.js";
@@ -151,6 +152,53 @@ const NON_APP_PATTERNS = [
 function isNonApplicationFile(filePath) {
     return NON_APP_PATTERNS.some((p) => p.test(filePath));
 }
+const ROUTE_FILE_PATTERN = /route|controller|endpoint|handler|view|urls|api|router/i;
+const SOURCE_EXTS = /\.(ts|tsx|js|jsx|py|java|kt|go|rb|php|rs|cs|ex|exs)$/;
+/**
+ * Recover endpoints from files deleted in this branch by reading their
+ * content from the base branch via `git show`. Only checks files whose
+ * name matches route-file heuristics to keep I/O bounded.
+ */
+async function recoverDeletedFileEndpoints(repositoryPath, baseBranch, deletedFiles) {
+    const candidates = deletedFiles.filter((f) => SOURCE_EXTS.test(f) && ROUTE_FILE_PATTERN.test(f));
+    if (candidates.length === 0)
+        return [];
+    const git = simpleGit(repositoryPath);
+    const results = [];
+    const endpointMap = new Map();
+    for (const file of candidates) {
+        try {
+            const content = await git.show([`${baseBranch}:${file}`]);
+            for (const ep of parseFileEndpoints(content, file)) {
+                const existing = endpointMap.get(ep.path);
+                if (existing) {
+                    existing.methods.add(ep.method);
+                }
+                else {
+                    endpointMap.set(ep.path, {
+                        methods: new Set([ep.method]),
+                        sourceFile: file,
+                    });
+                }
+            }
+        }
+        catch (err) {
+            logger.debug("Failed to recover endpoints from deleted file", {
+                file,
+                baseBranch,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    for (const [apiPath, data] of endpointMap) {
+        results.push({
+            path: apiPath,
+            methods: Array.from(data.methods),
+            sourceFile: data.sourceFile,
+        });
+    }
+    return results;
+}
 export const analyzeChangesInputSchema = {
     repositoryPath: z
         .string()
@@ -267,17 +315,10 @@ to produce a unified state file for the test health workflow.
                     };
                 }
             }
-            await sendProgress(25, 100, "Parsing endpoints from diff...");
-            const parsedDiff = diffData
-                ? parseEndpointsFromDiff(diffData)
-                : undefined;
-            const newEndpoints = parsedDiff
-                ? parsedDiff.newEndpoints
-                : [];
             // ── Step 2: Scan endpoints ──
             let scannedEndpoints = [];
             if (analysisScope !== AnalysisScope.CurrentBranchDiff) {
-                await sendProgress(35, 100, "Scanning all repository endpoints...");
+                await sendProgress(25, 100, "Scanning all repository endpoints...");
                 try {
                     scannedEndpoints = scanAllRepoEndpoints(params.repositoryPath);
                     logger.info("Pre-scanned repo endpoints", {
@@ -291,7 +332,7 @@ to produce a unified state file for the test health workflow.
                 }
             }
             else if (diffData) {
-                await sendProgress(35, 100, "Scanning related endpoints from diff...");
+                await sendProgress(25, 100, "Scanning related endpoints from diff...");
                 try {
                     scannedEndpoints = scanRelatedEndpoints(params.repositoryPath, diffData.changedFiles);
                     logger.info("Scanned related endpoints", {
@@ -303,32 +344,68 @@ to produce a unified state file for the test health workflow.
                         error: err instanceof Error ? err.message : String(err),
                     });
                 }
-                if (scannedEndpoints.length === 0) {
-                    try {
-                        scannedEndpoints = scanAllRepoEndpoints(params.repositoryPath);
-                        logger.info("Fallback: scanned all repo endpoints", {
-                            count: scannedEndpoints.length,
-                        });
-                    }
-                    catch (err) {
-                        logger.warning("Full repo scan fallback also failed", {
-                            error: err instanceof Error ? err.message : String(err),
-                        });
-                    }
-                }
+                // No fallback to scanAllRepoEndpoints in PR mode.
+                // If the scanner found 0 related endpoints, the PR likely touches
+                // non-route code (services, models, schemas, client SDK). Flooding
+                // all repo endpoints into the prompt causes the LLM to test
+                // irrelevant neighboring endpoints instead of focusing on the diff.
+            }
+            await sendProgress(40, 100, "Classifying changed endpoints...");
+            // ── Step 2.5: Classify endpoints by changed files ──
+            // Cross-reference changedFiles against scannedEndpoints[].sourceFile to
+            // identify new/modified/removed endpoints — replaces fragile regex parsing
+            // of diff hunks. Scanned endpoints always have full paths and concrete
+            // HTTP methods, eliminating the need for path resolution and MULTI sentinels.
+            let classifiedEndpoints;
+            if (diffData) {
+                // Recover endpoints from deleted files by reading base-branch content
+                const deletedFileEndpoints = diffData.deletedFiles.length > 0
+                    ? await recoverDeletedFileEndpoints(params.repositoryPath, diffData.baseBranch, diffData.deletedFiles)
+                    : [];
+                classifiedEndpoints = classifyEndpointsByChangedFiles(diffData, scannedEndpoints, deletedFileEndpoints);
+                logger.info("Classified endpoints from changed files", {
+                    changed: classifiedEndpoints.changedEndpoints.length,
+                    new: classifiedEndpoints.newEndpoints.length,
+                    removed: classifiedEndpoints.removedEndpoints.length,
+                    unmatched: classifiedEndpoints.unmatchedFiles.length,
+                });
             }
             await sendProgress(50, 100, "Discovering existing tests...");
             // ── Step 3: Discover existing tests ──
-            // In PR mode, extract resource names from the diff endpoints so that
-            // TestDiscoveryService can limit full extraction to relevant files only.
-            const changedResources = parsedDiff
-                ? [
-                    ...parsedDiff.newEndpoints,
-                    ...parsedDiff.modifiedEndpoints,
-                ]
-                    .map(ep => extractResourceFromPath(ep.path))
-                    .filter((r, i, arr) => r !== "unknown" && arr.indexOf(r) === i)
-                : [];
+            // Compute changedResources from classified endpoints for test discovery filtering.
+            // undefined    → full-repo mode (no diff context)
+            // []           → PR mode, no endpoints found → skip external tests
+            // [...names]   → PR mode with resolved resource names → filter external by relevance
+            let changedResources;
+            if (!classifiedEndpoints) {
+                changedResources = undefined;
+            }
+            else {
+                const allClassified = [
+                    ...classifiedEndpoints.changedEndpoints,
+                    ...classifiedEndpoints.newEndpoints,
+                    ...classifiedEndpoints.removedEndpoints,
+                ];
+                if (allClassified.length > 0) {
+                    // Scanned endpoints always have full paths — extractResourceFromPath
+                    // never returns "unknown" for properly resolved paths.
+                    const resolved = allClassified
+                        .map((ep) => extractResourceFromPath(ep.path))
+                        .filter((r, i, arr) => r !== "unknown" && arr.indexOf(r) === i);
+                    changedResources = resolved.length > 0 ? resolved : ["unknown"];
+                }
+                else if (classifiedEndpoints.unmatchedFiles.length > 0) {
+                    // Changed files don't map to any endpoint (e.g. schema, model, or
+                    // migration changes near route files). Use ["unknown"] so external
+                    // tests get name-only entries — enough for the LLM to infer coverage
+                    // from filenames without flooding context with full extraction of
+                    // hundreds of irrelevant test files.
+                    changedResources = ["unknown"];
+                }
+                else {
+                    changedResources = [];
+                }
+            }
             let existingTests = [];
             let discoveredRelevantExternalPaths = [];
             try {
@@ -427,71 +504,30 @@ to produce a unified state file for the test health workflow.
                 : 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 skeletonEndpoints = 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),
+                        },
+                    ],
+                })),
+            }));
             // ── Step 8: Merge trace interactions ──
             if (traceResult && traceResult.entries.length > 0) {
                 for (const entry of traceResult.entries) {
@@ -536,16 +572,23 @@ to produce a unified state file for the test health workflow.
                     }
                 }
             }
-            // ── Step 8.5: Resolve diff-parsed endpoint paths ──
-            // The diff parser extracts route-decorator-relative paths (e.g. "/{order_id}")
-            // because the router prefix is usually outside the diff hunk. Match against
-            // the authoritative scanned endpoints to recover the full API path.
-            if (parsedDiff && skeletonEndpoints.length > 0) {
-                resolveEndpointPaths(parsedDiff.newEndpoints, skeletonEndpoints);
-                resolveEndpointPaths(parsedDiff.modifiedEndpoints, skeletonEndpoints);
-            }
             // ── Step 9: Draft scenarios ──
-            const codeInferredScenarios = draftScenariosFromEndpoints(skeletonEndpoints, parsedDiff?.newEndpoints ?? []);
+            // New and changed endpoints get minimal intent-marker scenarios (contract + integration
+            // for mutating methods) via draftMinimalScenarios. The LLM enriches these with
+            // prerequisite steps and error paths during source-code analysis. Removed endpoints
+            // are handled by the LLM from the diffContext.removedEndpoints signal.
+            // Classified endpoints have full paths and concrete methods (no MULTI sentinels).
+            const newEndpointsForDrafting = classifiedEndpoints?.newEndpoints.flatMap((ep) => ep.methods.map((m) => ({
+                method: m,
+                path: ep.path,
+                sourceFile: ep.sourceFile,
+            }))) ?? [];
+            const changedEndpointsForDrafting = classifiedEndpoints?.changedEndpoints.flatMap((ep) => ep.methods.map((m) => ({
+                method: m,
+                path: ep.path,
+                sourceFile: ep.sourceFile,
+            }))) ?? [];
+            const codeInferredScenarios = draftScenariosFromEndpoints(skeletonEndpoints, newEndpointsForDrafting, changedEndpointsForDrafting);
             let allDraftedScenarios = codeInferredScenarios;
             if (traceResult && traceResult.userFlows.length > 0) {
                 const traceScenarios = traceResult.userFlows
@@ -642,35 +685,37 @@ to produce a unified state file for the test health workflow.
             const relevantExternalTestPaths = discoveredRelevantExternalPaths.map(p => path.relative(params.repositoryPath, p));
             // Build the full RepositoryAnalysis object — same structure as analyzeRepositoryTool
             // so buildRecommendationPrompt can reason over enriched endpoint + scenario data
-            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,
+            // Build diffContext from classifiedEndpoints — ScannedEndpoint already
+            // has full paths and concrete methods, so no grouping/MULTI handling needed.
+            const diffContext = classifiedEndpoints ? {
+                currentBranch: classifiedEndpoints.currentBranch,
+                baseBranch: classifiedEndpoints.baseBranch,
+                changedFiles: classifiedEndpoints.changedFiles,
+                newEndpoints: classifiedEndpoints.newEndpoints.map((ep) => ({
+                    path: ep.path,
+                    methods: ep.methods.map((m) => ({
+                        method: m,
+                        sourceFile: ep.sourceFile,
+                        interactionCount: 0,
+                    })),
+                })),
+                modifiedEndpoints: classifiedEndpoints.changedEndpoints.map((ep) => ({
+                    path: ep.path,
+                    methods: ep.methods.map((m) => ({
+                        method: m,
+                        sourceFile: ep.sourceFile,
+                        changeType: "modified",
+                    })),
+                })),
+                removedEndpoints: classifiedEndpoints.removedEndpoints.map((ep) => ({
+                    path: ep.path,
+                    methods: ep.methods.map((m) => ({
+                        method: m,
+                        sourceFile: ep.sourceFile,
+                        changeType: "removed",
+                    })),
+                })),
+                affectedServices: classifiedEndpoints.affectedServices,
                 summary: "",
             } : undefined;
             const fullAnalysis = {
@@ -752,7 +797,7 @@ to produce a unified state file for the test health workflow.
                 : undefined;
             const unifiedState = {
                 existingTests,
-                newEndpoints,
+                newEndpoints: newEndpointsForDrafting,
                 analysisScope,
                 repositoryAnalysis: {
                     skeletonEndpoints,
@@ -764,7 +809,35 @@ to produce a unified state file for the test health workflow.
                     wsSchemaPath,
                     wsAuthMethod,
                     scenarios: allDraftedScenarios,
-                    diff: parsedDiff,
+                    diff: classifiedEndpoints
+                        ? {
+                            currentBranch: classifiedEndpoints.currentBranch,
+                            baseBranch: classifiedEndpoints.baseBranch,
+                            changedFiles: classifiedEndpoints.changedFiles,
+                            newEndpoints: classifiedEndpoints.newEndpoints.map((ep) => ({
+                                path: ep.path,
+                                methods: ep.methods.map((m) => ({
+                                    method: m,
+                                    sourceFile: ep.sourceFile,
+                                })),
+                            })),
+                            modifiedEndpoints: classifiedEndpoints.changedEndpoints.map((ep) => ({
+                                path: ep.path,
+                                methods: ep.methods.map((m) => ({
+                                    method: m,
+                                    sourceFile: ep.sourceFile,
+                                })),
+                            })),
+                            removedEndpoints: classifiedEndpoints.removedEndpoints.map((ep) => ({
+                                path: ep.path,
+                                methods: ep.methods.map((m) => ({
+                                    method: m,
+                                    sourceFile: ep.sourceFile,
+                                })),
+                            })),
+                            affectedServices: classifiedEndpoints.affectedServices,
+                        }
+                        : undefined,
                     sessionId,
                     routerMountContext,
                     candidateRouteFiles,
@@ -780,6 +853,24 @@ to produce a unified state file for the test health workflow.
             catch (error) {
                 logger.warning(`Failed to cleanup old state files: ${error.message}`);
             }
+            // Clean up old diff temp files (>24 hours) from previous invocations
+            try {
+                const tmpDir = os.tmpdir();
+                const entries = await fs.promises.readdir(tmpDir);
+                const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+                for (const entry of entries) {
+                    if (!entry.startsWith("skyramp-diff-") || !entry.endsWith(".diff"))
+                        continue;
+                    const fullPath = path.join(tmpDir, entry);
+                    const stat = await fs.promises.stat(fullPath).catch(() => null);
+                    if (stat && stat.mtimeMs < cutoff) {
+                        await fs.promises.unlink(fullPath).catch(() => { });
+                    }
+                }
+            }
+            catch {
+                // Non-critical — temp cleanup failure should not block analysis
+            }
             const stateManager = new StateManager("analysis", sessionId, undefined, params.stateOutputFile);
             await stateManager.writeData(unifiedState, {
                 repositoryPath: params.repositoryPath,
@@ -842,18 +933,51 @@ to produce a unified state file for the test health workflow.
                     projectType: projectMeta.projectType,
                     primaryFramework: projectMeta.primaryFramework,
                     existingTestCount: existingTests.length,
-                    newEndpointCount: newEndpoints.length,
+                    newEndpointCount: classifiedEndpoints?.newEndpoints.length ?? 0,
                     endpointCount: skeletonEndpoints.reduce((acc, ep) => acc + ep.methods.length, 0),
                 },
                 stateFileSize: stateSize,
                 nextStep: "Call skyramp_analyze_test_health with stateFile to run drift analysis and health scoring",
             }, null, 2);
+            // Build a DiffSummary for buildAnalysisOutputText from classified endpoints.
+            const parsedDiffShim = classifiedEndpoints
+                ? {
+                    currentBranch: classifiedEndpoints.currentBranch,
+                    baseBranch: classifiedEndpoints.baseBranch,
+                    changedFiles: classifiedEndpoints.changedFiles,
+                    diffStat: diffData?.diffStat ?? "",
+                    newEndpoints: classifiedEndpoints.newEndpoints.flatMap((ep) => ep.methods.map((m) => ({
+                        method: m,
+                        path: ep.path,
+                        sourceFile: ep.sourceFile,
+                    }))),
+                    modifiedEndpoints: classifiedEndpoints.changedEndpoints.flatMap((ep) => ep.methods.map((m) => ({
+                        method: m,
+                        path: ep.path,
+                        sourceFile: ep.sourceFile,
+                    }))),
+                    removedEndpoints: classifiedEndpoints.removedEndpoints.flatMap((ep) => ep.methods.map((m) => ({
+                        method: m,
+                        path: ep.path,
+                        sourceFile: ep.sourceFile,
+                    }))),
+                    affectedServices: classifiedEndpoints.affectedServices,
+                }
+                : undefined;
+            // Write the full diff to a temp file so the LLM can read it on demand
+            // rather than embedding potentially large content inline in the prompt.
+            let diffFilePath;
+            if (diffData?.diffContent) {
+                diffFilePath = path.join(os.tmpdir(), `skyramp-diff-${sessionId}.diff`);
+                await fs.promises.writeFile(diffFilePath, diffData.diffContent, { encoding: "utf-8", mode: 0o600 });
+            }
             const outputText = buildAnalysisOutputText({
                 sessionId,
                 stateFile,
                 repositoryPath: params.repositoryPath,
                 analysisScope,
-                parsedDiff,
+                parsedDiff: parsedDiffShim,
+                diffFilePath,
                 diffContent: diffData?.diffContent,
                 candidateRouteFiles,
                 scannedEndpoints,

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

@@ -21,7 +21,9 @@ jest.mock("../../utils/branchDiff.js", () => ({
     computeBranchDiff: jest.fn(),
 }));
 jest.mock("../../utils/routeParsers.js", () => ({
-    parseEndpointsFromDiff: jest.fn(),
+    classifyEndpointsByChangedFiles: jest.fn(),
+    extractResourceFromPath: jest.fn(),
+    parseFileEndpoints: jest.fn(),
 }));
 jest.mock("../../utils/repoScanner.js", () => ({
     scanAllRepoEndpoints: jest.fn(),