@skyramp/mcp 0.1.2 → 0.1.4

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

@@ -94,6 +94,11 @@ exist only in the LLM's reasoning context and are acted on by \`skyramp_actions\
                         .map((e) => e.methods ? e.methods.map((m) => `${m.method} ${e.path}`).join(", ") : `${e.method} ${e.path}`)
                         .join(", ")}`);
                 }
+                if (diff.removedEndpoints?.length > 0) {
+                    lines.push(`**Removed Endpoints** (${diff.removedEndpoints.length}): ${diff.removedEndpoints
+                        .map((e) => e.methods ? e.methods.map((m) => `${m.method} ${e.path}`).join(", ") : `${e.method} ${e.path}`)
+                        .join(", ")}`);
+                }
                 parsedDiffText = lines.join("\n");
             }
             const scannedEndpoints = stateData.repositoryAnalysis?.skeletonEndpoints || [];

package/build/types/RepositoryAnalysis.js

@@ -128,6 +128,14 @@ export const branchDiffContextSchema = z.object({
             changeType: z.enum(["added", "modified", "removed"]),
         })),
     })),
+    removedEndpoints: z.array(z.object({
+        path: z.string(),
+        methods: z.array(z.object({
+            method: z.string(),
+            sourceFile: z.string(),
+            changeType: z.literal("removed"),
+        })),
+    })).optional(),
     affectedServices: z.array(z.string()),
     summary: z.string().optional(),
 });

package/build/types/TestRecommendation.js

@@ -24,6 +24,8 @@ const CATEGORIES = [
 export const SCENARIO_CATEGORIES = [...INTERNAL_CATEGORIES, ...CATEGORIES];
 /** Categories valid for tool submissions (excludes internal-only categories). */
 export const TEST_CATEGORIES = CATEGORIES;
+/** Numeric ordering for priority tiers (higher = more important). */
+export const PRIORITY_TIER_ORDER = { CRITICAL: 4, HIGH: 3, MEDIUM: 2, LOW: 1 };
 /** Priority assignment for each category. */
 export const CATEGORY_PRIORITY = {
     new_endpoint: "CRITICAL",

package/build/utils/branchDiff.js

@@ -1,10 +1,30 @@
 import { simpleGit } from "simple-git";
 import { logger } from "./logger.js";
-const MAX_DIFF_LENGTH = 50_000;
 /**
  * Try a git diff against the given ref. Returns undefined if the ref doesn't exist
  * or the diff fails, so the caller can try the next candidate.
  */
+/** Parse diff headers to find newly created and deleted files. */
+function parseNewAndDeletedFiles(rawDiff) {
+    const newFiles = [];
+    const deletedFiles = [];
+    const lines = rawDiff.split("\n");
+    let currentFile = "";
+    for (const line of lines) {
+        const fileMatch = line.match(/^diff --git a\/.+ b\/(.+)$/);
+        if (fileMatch) {
+            currentFile = fileMatch[1];
+            continue;
+        }
+        if (line === "--- /dev/null" && currentFile) {
+            newFiles.push(currentFile);
+        }
+        else if (line === "+++ /dev/null" && currentFile) {
+            deletedFiles.push(currentFile);
+        }
+    }
+    return { newFiles, deletedFiles };
+}
 async function tryDiff(git, ref) {
     try {
         const changedFilesRaw = await git.diff([`${ref}...HEAD`, "--name-only"]);
@@ -13,13 +33,9 @@ async function tryDiff(git, ref) {
             .map((f) => f.trim())
             .filter((f) => f.length > 0);
         const diffStat = await git.diff([`${ref}...HEAD`, "--stat"]);
-        let diffContent = await git.diff([`${ref}...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 { changedFiles, diffContent, diffStat };
+        const fullDiff = await git.diff([`${ref}...HEAD`]);
+        const { newFiles, deletedFiles } = parseNewAndDeletedFiles(fullDiff);
+        return { changedFiles, diffContent: fullDiff, diffStat, newFiles, deletedFiles };
     }
     catch (err) {
         logger.debug(`tryDiff against ${ref} failed`, { error: err instanceof Error ? err.message : String(err) });

package/build/utils/featureFlags.js

@@ -32,3 +32,28 @@
 export function isContractConsumerModeEnabled() {
     return process.env.SKYRAMP_FEATURE_CONTRACT_CONSUMER_MODE === "1";
 }
+export function isTestbotMode() {
+    return process.env.SKYRAMP_FEATURE_TESTBOT === "1";
+}
+/**
+ * Returns the prompt phrasing for where to find service details.
+ *
+ * - Testbot mode: references the `<services>` XML block injected at the top of the prompt.
+ * - Normal MCP mode: references `.skyramp/workspace.yml`.
+ */
+export function resolveServiceDetailsRef() {
+    if (isTestbotMode()) {
+        return {
+            testDirRef: "the `<output_dir>` from the `<services>` block",
+            frontendTestDirRef: "the **frontend** service's `<output_dir>` from the `<services>` block",
+            baseUrlRef: "the `<base_url>` from the `<services>` block",
+            authSourceRef: "the `<services>` block",
+        };
+    }
+    return {
+        testDirRef: "the `testDirectory` from `.skyramp/workspace.yml`",
+        frontendTestDirRef: "the **frontend** service's `testDirectory` from `.skyramp/workspace.yml`",
+        baseUrlRef: "the `api.baseUrl` from `.skyramp/workspace.yml`",
+        authSourceRef: "`.skyramp/workspace.yml`",
+    };
+}

package/build/utils/httpDefaults.js

@@ -0,0 +1,12 @@
+/**
+ * Shared HTTP method defaults used across scenario drafting and test generation.
+ */
+/** Returns the conventional success status code for a given HTTP method. */
+export function inferExpectedStatus(method) {
+    const m = method.toUpperCase();
+    if (m === "POST")
+        return 201;
+    if (m === "DELETE")
+        return 204;
+    return 200;
+}

package/build/utils/repoScanner.js

@@ -1,13 +1,15 @@
 import * as fs from "fs";
 import * as path from "path";
 import { nextjsFileToApiPath, parseFileEndpoints, } from "./routeParsers.js";
+import { logger } from "./logger.js";
 function globRecursive(dir, extensions) {
     const results = [];
     let entries;
     try {
         entries = fs.readdirSync(dir, { withFileTypes: true });
     }
-    catch {
+    catch (err) {
+        logger.debug("globRecursive: skipping directory", { dir, error: err instanceof Error ? err.message : String(err) });
         return results;
     }
     for (const entry of entries) {
@@ -201,7 +203,19 @@ export function findCandidateRouteFiles(repositoryPath) {
             }
         }
     }
-    return [...byName, ...byContent].slice(0, MAX_CANDIDATE_FILES);
+    const combined = [...byName, ...byContent];
+    const contentPassSkipped = byName.length >= MAX_CANDIDATE_FILES;
+    const result = combined.slice(0, MAX_CANDIDATE_FILES);
+    if (combined.length > MAX_CANDIDATE_FILES) {
+        logger.warning("findCandidateRouteFiles: hit MAX_CANDIDATE_FILES cap — some route files may be excluded from LLM analysis", {
+            cap: MAX_CANDIDATE_FILES,
+            byName: byName.length,
+            byContent: byContent.length,
+            contentPassSkipped,
+            totalFound: combined.length,
+        });
+    }
+    return result;
 }
 export function scanAllRepoEndpoints(repositoryPath) {
     const endpointMap = new Map();

package/build/utils/routeParsers.js

@@ -82,6 +82,18 @@ export function parseRouteLine(line, sourceFile) {
             };
         }
     }
+    // Next.js guard clause: `if (req.method !== "POST")` means the handler IS for POST
+    const nextjsGuardMatch = stripped.match(/req\.method\s*!==?\s*["'](GET|POST|PUT|PATCH|DELETE)["']/i);
+    if (nextjsGuardMatch) {
+        const apiPath = nextjsFileToApiPath(sourceFile);
+        if (apiPath) {
+            return {
+                method: nextjsGuardMatch[1].toUpperCase(),
+                path: apiPath,
+                sourceFile,
+            };
+        }
+    }
     const appRouterExportMatch = stripped.match(/export\s+(?:async\s+)?function\s+(GET|POST|PUT|PATCH|DELETE)\s*\(/i);
     if (appRouterExportMatch) {
         const apiPath = nextjsFileToApiPath(sourceFile);
@@ -267,46 +279,75 @@ export function parseFileEndpoints(content, sourceFile) {
     }
     return results;
 }
-export 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}`);
-        }
+export const SKIP_PATH_SEGMENTS = new Set(["api", "v1", "v2", "v3", "public"]);
+/** Extract the primary resource name from an endpoint path (e.g. "/api/v1/orders/{id}" → "orders"). */
+export function extractResourceFromPath(endpointPath) {
+    const segments = endpointPath.split("/").filter(Boolean);
+    const meaningful = segments.filter((s) => !s.startsWith("{") && !SKIP_PATH_SEGMENTS.has(s));
+    return meaningful[meaningful.length - 1] || "unknown";
+}
+/**
+ * Classify endpoints by cross-referencing `changedFiles` against `scannedEndpoints[].sourceFile`.
+ *
+ * This replaces `parseEndpointsFromDiff` — instead of regex-parsing diff hunks for route
+ * annotations (fragile for 15+ frameworks), it uses the already-scanned endpoint catalog
+ * which has full, resolved paths and concrete HTTP methods.
+ *
+ * For deleted files, the caller must supply endpoints recovered from the base branch
+ * (via `parseFileEndpoints` on `git show base:<file>`) in `deletedFileEndpoints`.
+ */
+export function classifyEndpointsByChangedFiles(diffData, scannedEndpoints, deletedFileEndpoints) {
+    const newFileSet = new Set(diffData.newFiles);
+    const deletedFileSet = new Set(diffData.deletedFiles);
+    // Build sourceFile → ScannedEndpoint[] map from the post-change catalog
+    const bySourceFile = new Map();
+    for (const ep of scannedEndpoints) {
+        const existing = bySourceFile.get(ep.sourceFile);
+        if (existing)
+            existing.push(ep);
+        else
+            bySourceFile.set(ep.sourceFile, [ep]);
     }
-    const addedRouteKeys = new Set(addedRoutes.map((r) => r.path));
+    const changedEndpoints = [];
+    const newEndpoints = [];
+    const unmatchedFiles = [];
     for (const file of diffData.changedFiles) {
-        const apiPath = nextjsFileToApiPath(file);
-        if (apiPath && !addedRouteKeys.has(apiPath)) {
-            addedRoutes.push({ method: "MULTI", path: apiPath, sourceFile: file });
-            addedRouteKeys.add(apiPath);
+        // Deleted files won't appear in scanned catalog — handled separately below
+        if (deletedFileSet.has(file))
+            continue;
+        const eps = bySourceFile.get(file);
+        if (!eps || eps.length === 0) {
+            unmatchedFiles.push(file);
+            continue;
         }
-    }
-    const newEndpoints = [];
-    const modifiedEndpoints = [];
-    for (const ep of addedRoutes) {
-        if (removedKeys.has(`${ep.method} ${ep.path}`)) {
-            modifiedEndpoints.push(ep);
+        if (newFileSet.has(file)) {
+            newEndpoints.push(...eps);
         }
         else {
-            newEndpoints.push(ep);
+            changedEndpoints.push(...eps);
         }
     }
+    // Removed endpoints: from deleted files, recovered from the base branch.
+    // Filter out any endpoint that still exists in the current scanned catalog
+    // (i.e. was moved/refactored to another file, not truly deleted).
+    // Paths with a MULTI sentinel in the catalog are treated as present for all methods
+    // (Next.js catch-all handlers, Java @RequestMapping without explicit method, etc.).
+    const currentEndpointKeys = new Set(scannedEndpoints.flatMap((ep) => ep.methods.map((m) => `${m} ${ep.path}`)));
+    const multiPaths = new Set(scannedEndpoints.filter((ep) => ep.methods.includes("MULTI")).map((ep) => ep.path));
+    const currentPaths = new Set(scannedEndpoints.map((ep) => ep.path));
+    const removedEndpoints = (deletedFileEndpoints ?? [])
+        .map((ep) => ({
+        ...ep,
+        methods: ep.methods.filter((m) => {
+            // A deleted MULTI means the file was a catch-all (e.g. Next.js default export).
+            // If the path exists in the current catalog with any method, it was moved — not removed.
+            if (m === "MULTI")
+                return !currentPaths.has(ep.path);
+            return !currentEndpointKeys.has(`${m} ${ep.path}`) && !multiPaths.has(ep.path);
+        }),
+    }))
+        .filter((ep) => ep.methods.length > 0);
+    // Affected services: same heuristic as before
     const servicePattern = /(?:services?|modules?|apps?)\/([a-z0-9_-]+)/i;
     const affectedServices = [
         ...new Set(diffData.changedFiles
@@ -314,54 +355,13 @@ export function parseEndpointsFromDiff(diffData) {
             .filter((s) => !!s)),
     ];
     return {
+        changedEndpoints,
+        newEndpoints,
+        removedEndpoints,
+        unmatchedFiles,
+        changedFiles: diffData.changedFiles,
         currentBranch: diffData.currentBranch,
         baseBranch: diffData.baseBranch,
-        changedFiles: diffData.changedFiles,
-        diffStat: diffData.diffStat,
-        newEndpoints,
-        modifiedEndpoints,
         affectedServices,
     };
 }
-export const SKIP_PATH_SEGMENTS = new Set(["api", "v1", "v2", "v3", "public"]);
-/** Extract the primary resource name from an endpoint path (e.g. "/api/v1/orders/{id}" → "orders"). */
-export function extractResourceFromPath(endpointPath) {
-    const segments = endpointPath.split("/").filter(Boolean);
-    const meaningful = segments.filter(s => !s.startsWith("{") && !SKIP_PATH_SEGMENTS.has(s));
-    return meaningful[meaningful.length - 1] || "unknown";
-}
-/**
- * Resolve incomplete diff-parsed endpoint paths against the authoritative
- * scanned endpoint catalog. Route decorators in diffs often contain only the
- * handler-relative fragment (e.g. "/{order_id}") because the router prefix
- * (e.g. APIRouter(prefix="/api/v1/orders")) is outside the diff hunk.
- *
- * For each diff endpoint whose path doesn't match any known endpoint exactly,
- * find the scanned endpoint whose full path ends with the diff path and shares
- * the same HTTP method. Mutates the input array in place.
- */
-export function resolveEndpointPaths(diffEndpoints, knownEndpoints) {
-    if (diffEndpoints.length === 0 || knownEndpoints.length === 0)
-        return;
-    for (const ep of diffEndpoints) {
-        const alreadyFull = knownEndpoints.some(s => s.path === ep.path);
-        if (alreadyFull)
-            continue;
-        const candidates = knownEndpoints.filter(s => s.path.endsWith(ep.path) &&
-            s.path !== ep.path &&
-            s.methods.some(m => m.method === ep.method));
-        if (candidates.length === 1) {
-            ep.path = candidates[0].path;
-        }
-        else if (candidates.length > 1) {
-            const byFile = candidates.filter(s => s.methods.some(m => m.method === ep.method &&
-                m.sourceFile != null &&
-                (m.sourceFile === ep.sourceFile ||
-                    m.sourceFile.endsWith(ep.sourceFile) ||
-                    ep.sourceFile.endsWith(m.sourceFile))));
-            if (byFile.length === 1) {
-                ep.path = byFile[0].path;
-            }
-        }
-    }
-}

package/build/utils/routeParsers.test.js

@@ -1,5 +1,5 @@
 // @ts-ignore
-import { nextjsFileToApiPath, parseRouteLine, parseFileEndpoints, resolveEndpointPaths, extractResourceFromPath } from "./routeParsers.js";
+import { nextjsFileToApiPath, parseRouteLine, parseFileEndpoints, extractResourceFromPath, classifyEndpointsByChangedFiles } from "./routeParsers.js";
 describe("nextjsFileToApiPath", () => {
     it("converts pages/api route to API path", () => {
         expect(nextjsFileToApiPath("pages/api/users/index.ts")).toBe("/api/users");
@@ -47,6 +47,18 @@ describe("parseRouteLine", () => {
         expect(result).not.toBeNull();
         expect(result.method).toBe("GET");
     });
+    it("parses Next.js guard clause (req.method !== 'POST')", () => {
+        const result = parseRouteLine('  if (req.method !== "POST") {', "pages/api/v1/collections/[id]/transfer.ts");
+        expect(result).not.toBeNull();
+        expect(result.method).toBe("POST");
+        expect(result.path).toBe("/api/v1/collections/{id}/transfer");
+    });
+    it("parses Next.js guard clause with != operator", () => {
+        const result = parseRouteLine("  if (req.method != 'DELETE') {", "pages/api/v1/items/[id].ts");
+        expect(result).not.toBeNull();
+        expect(result.method).toBe("DELETE");
+        expect(result.path).toBe("/api/v1/items/{id}");
+    });
     it("parses Gin route", () => {
         const result = parseRouteLine('r.GET("/users", getUsers)', "main.go");
         expect(result).toEqual({ method: "GET", path: "/users", sourceFile: "main.go" });
@@ -246,71 +258,6 @@ async def get_product(): pass
         expect(eps).toContainEqual({ method: "GET", path: "/products/{product_id}", sourceFile: "routers/product.py" });
     });
 });
-describe("resolveEndpointPaths", () => {
-    const knownEndpoints = [
-        { path: "/api/v1/orders", methods: [{ method: "POST", sourceFile: "routers/order.py" }, { method: "GET", sourceFile: "routers/order.py" }] },
-        { path: "/api/v1/orders/{order_id}", methods: [{ method: "GET", sourceFile: "routers/order.py" }, { method: "PUT", sourceFile: "routers/order.py" }, { method: "DELETE", sourceFile: "routers/order.py" }] },
-        { path: "/api/v1/products", methods: [{ method: "POST", sourceFile: "routers/product.py" }, { method: "GET", sourceFile: "routers/product.py" }] },
-        { path: "/api/v1/products/{product_id}", methods: [{ method: "GET", sourceFile: "routers/product.py" }, { method: "PUT", sourceFile: "routers/product.py" }, { method: "DELETE", sourceFile: "routers/product.py" }] },
-    ];
-    it("resolves router-relative path to full API path", () => {
-        const eps = [{ method: "PUT", path: "/{order_id}", sourceFile: "routers/order.py" }];
-        resolveEndpointPaths(eps, knownEndpoints);
-        expect(eps[0].path).toBe("/api/v1/orders/{order_id}");
-    });
-    it("leaves already-full paths unchanged", () => {
-        const eps = [{ method: "POST", path: "/api/v1/orders", sourceFile: "routers/order.py" }];
-        resolveEndpointPaths(eps, knownEndpoints);
-        expect(eps[0].path).toBe("/api/v1/orders");
-    });
-    it("resolves multiple endpoints in one call", () => {
-        const eps = [
-            { method: "PUT", path: "/{order_id}", sourceFile: "routers/order.py" },
-            { method: "DELETE", path: "/{order_id}", sourceFile: "routers/order.py" },
-        ];
-        resolveEndpointPaths(eps, knownEndpoints);
-        expect(eps[0].path).toBe("/api/v1/orders/{order_id}");
-        expect(eps[1].path).toBe("/api/v1/orders/{order_id}");
-    });
-    it("disambiguates by sourceFile when suffix matches multiple endpoints", () => {
-        const ambiguousKnown = [
-            { path: "/api/v1/orders/{id}", methods: [{ method: "PUT", sourceFile: "routers/order.py" }] },
-            { path: "/api/v1/products/{id}", methods: [{ method: "PUT", sourceFile: "routers/product.py" }] },
-        ];
-        const eps = [{ method: "PUT", path: "/{id}", sourceFile: "routers/order.py" }];
-        resolveEndpointPaths(eps, ambiguousKnown);
-        expect(eps[0].path).toBe("/api/v1/orders/{id}");
-    });
-    it("does not resolve when no match found", () => {
-        const eps = [{ method: "PATCH", path: "/{id}", sourceFile: "routers/unknown.py" }];
-        resolveEndpointPaths(eps, knownEndpoints);
-        expect(eps[0].path).toBe("/{id}");
-    });
-    it("does not resolve when ambiguous and sourceFile does not disambiguate", () => {
-        const ambiguousKnown = [
-            { path: "/api/v1/orders/{id}", methods: [{ method: "PUT" }] },
-            { path: "/api/v1/products/{id}", methods: [{ method: "PUT" }] },
-        ];
-        const eps = [{ method: "PUT", path: "/{id}", sourceFile: "shared.py" }];
-        resolveEndpointPaths(eps, ambiguousKnown);
-        expect(eps[0].path).toBe("/{id}");
-    });
-    it("handles empty arrays gracefully", () => {
-        const eps = [];
-        resolveEndpointPaths(eps, knownEndpoints);
-        expect(eps).toEqual([]);
-        const eps2 = [{ method: "PUT", path: "/{id}", sourceFile: "x.py" }];
-        resolveEndpointPaths(eps2, []);
-        expect(eps2[0].path).toBe("/{id}");
-    });
-    it("resolves collection-level relative paths (e.g. empty string becomes base)", () => {
-        const eps = [{ method: "POST", path: "", sourceFile: "routers/order.py" }];
-        resolveEndpointPaths(eps, knownEndpoints);
-        // Empty string — endsWith("") is always true, so multiple matches.
-        // sourceFile should disambiguate to orders.
-        expect(eps[0].path).toBe("/api/v1/orders");
-    });
-});
 describe("extractResourceFromPath", () => {
     it("extracts resource from simple path", () => {
         expect(extractResourceFromPath("/orders")).toBe("orders");
@@ -339,3 +286,182 @@ describe("extractResourceFromPath", () => {
         expect(extractResourceFromPath("api/v1/orders")).toBe("orders");
     });
 });
+describe("classifyEndpointsByChangedFiles", () => {
+    function makeDiffDataForClassify(opts) {
+        return {
+            currentBranch: "feature/test",
+            baseBranch: "origin/main",
+            changedFiles: opts.changedFiles,
+            diffContent: "",
+            diffStat: "",
+            newFiles: opts.newFiles ?? [],
+            deletedFiles: opts.deletedFiles ?? [],
+        };
+    }
+    const scannedEndpoints = [
+        { path: "/api/v1/orders/{order_id}", methods: ["GET", "PATCH"], sourceFile: "src/routes/orders.py" },
+        { path: "/api/v1/products/{product_id}", methods: ["GET", "POST"], sourceFile: "src/routes/products.py" },
+        { path: "/api/v1/users", methods: ["GET"], sourceFile: "src/routes/users.py" },
+    ];
+    it("classifies modified endpoints from changed files", () => {
+        const diff = makeDiffDataForClassify({ changedFiles: ["src/routes/orders.py"] });
+        const result = classifyEndpointsByChangedFiles(diff, scannedEndpoints);
+        expect(result.changedEndpoints).toHaveLength(1);
+        expect(result.changedEndpoints[0].path).toBe("/api/v1/orders/{order_id}");
+        expect(result.newEndpoints).toHaveLength(0);
+        expect(result.removedEndpoints).toHaveLength(0);
+    });
+    it("classifies new endpoints from newly-created files", () => {
+        const diff = makeDiffDataForClassify({ changedFiles: ["src/routes/products.py"], newFiles: ["src/routes/products.py"] });
+        const result = classifyEndpointsByChangedFiles(diff, scannedEndpoints);
+        expect(result.newEndpoints).toHaveLength(1);
+        expect(result.newEndpoints[0].path).toBe("/api/v1/products/{product_id}");
+        expect(result.changedEndpoints).toHaveLength(0);
+    });
+    it("puts files without endpoints into unmatchedFiles", () => {
+        const diff = makeDiffDataForClassify({ changedFiles: ["src/models/order.py", "src/routes/orders.py"] });
+        const result = classifyEndpointsByChangedFiles(diff, scannedEndpoints);
+        expect(result.unmatchedFiles).toEqual(["src/models/order.py"]);
+        expect(result.changedEndpoints).toHaveLength(1);
+    });
+    it("skips deleted files from changed classification", () => {
+        const deletedEndpoints = [{ path: "/api/v1/legacy", methods: ["GET"], sourceFile: "src/routes/legacy.py" }];
+        const diff = makeDiffDataForClassify({ changedFiles: ["src/routes/legacy.py", "src/routes/orders.py"], deletedFiles: ["src/routes/legacy.py"] });
+        const result = classifyEndpointsByChangedFiles(diff, scannedEndpoints, deletedEndpoints);
+        expect(result.removedEndpoints).toHaveLength(1);
+        expect(result.removedEndpoints[0].path).toBe("/api/v1/legacy");
+        expect(result.changedEndpoints).toHaveLength(1);
+        expect(result.changedEndpoints[0].path).toBe("/api/v1/orders/{order_id}");
+    });
+    it("handles multiple endpoints in the same file", () => {
+        const diff = makeDiffDataForClassify({ changedFiles: ["src/routes/orders.py"] });
+        const result = classifyEndpointsByChangedFiles(diff, scannedEndpoints);
+        expect(result.changedEndpoints).toHaveLength(1);
+        expect(result.changedEndpoints[0].methods).toEqual(["GET", "PATCH"]);
+    });
+    it("returns empty results when no changed files match endpoints", () => {
+        const diff = makeDiffDataForClassify({ changedFiles: ["README.md", "package.json"] });
+        const result = classifyEndpointsByChangedFiles(diff, scannedEndpoints);
+        expect(result.changedEndpoints).toHaveLength(0);
+        expect(result.newEndpoints).toHaveLength(0);
+        expect(result.removedEndpoints).toHaveLength(0);
+        expect(result.unmatchedFiles).toEqual(["README.md", "package.json"]);
+    });
+    it("computes affectedServices from changedFiles", () => {
+        const diff = makeDiffDataForClassify({ changedFiles: ["services/orders/routes.py", "services/users/models.py"] });
+        const result = classifyEndpointsByChangedFiles(diff, []);
+        expect(result.affectedServices).toContain("orders");
+        expect(result.affectedServices).toContain("users");
+    });
+    it("propagates branch metadata from diffData", () => {
+        const diff = makeDiffDataForClassify({ changedFiles: [] });
+        const result = classifyEndpointsByChangedFiles(diff, scannedEndpoints);
+        expect(result.currentBranch).toBe("feature/test");
+        expect(result.baseBranch).toBe("origin/main");
+        expect(result.changedFiles).toEqual([]);
+    });
+    it("handles empty scannedEndpoints (all files unmatched)", () => {
+        const diff = makeDiffDataForClassify({ changedFiles: ["src/routes/orders.py"] });
+        const result = classifyEndpointsByChangedFiles(diff, []);
+        expect(result.changedEndpoints).toHaveLength(0);
+        expect(result.newEndpoints).toHaveLength(0);
+        expect(result.removedEndpoints).toHaveLength(0);
+        expect(result.unmatchedFiles).toEqual(["src/routes/orders.py"]);
+    });
+    it("does not double-count a file that is both new and has endpoints", () => {
+        const diff = makeDiffDataForClassify({
+            changedFiles: ["src/routes/products.py", "src/routes/orders.py"],
+            newFiles: ["src/routes/products.py"],
+        });
+        const result = classifyEndpointsByChangedFiles(diff, scannedEndpoints);
+        // products.py is new → newEndpoints; orders.py is changed → changedEndpoints
+        expect(result.newEndpoints).toHaveLength(1);
+        expect(result.newEndpoints[0].sourceFile).toBe("src/routes/products.py");
+        expect(result.changedEndpoints).toHaveLength(1);
+        expect(result.changedEndpoints[0].sourceFile).toBe("src/routes/orders.py");
+    });
+    it("includes deleted-file endpoints in removedEndpoints when not in current catalog", () => {
+        const deleted = [
+            { path: "/api/v1/removed", methods: ["GET", "POST"], sourceFile: "src/routes/removed.py" },
+        ];
+        const diff = makeDiffDataForClassify({
+            changedFiles: ["src/routes/removed.py"],
+            deletedFiles: ["src/routes/removed.py"],
+        });
+        const result = classifyEndpointsByChangedFiles(diff, scannedEndpoints, deleted);
+        expect(result.removedEndpoints).toHaveLength(1);
+        expect(result.removedEndpoints[0].path).toBe("/api/v1/removed");
+        expect(result.removedEndpoints[0].methods).toEqual(["GET", "POST"]);
+        // The deleted file should NOT appear in changedEndpoints or unmatchedFiles
+        expect(result.changedEndpoints.every(ep => ep.sourceFile !== "src/routes/removed.py")).toBe(true);
+        expect(result.unmatchedFiles).not.toContain("src/routes/removed.py");
+    });
+    it("filters moved endpoints from removedEndpoints when they exist in current catalog", () => {
+        // Endpoint was in a deleted file but the same METHOD+path exists in scanned catalog
+        // (moved to another file) — should NOT appear in removedEndpoints
+        const deleted = [
+            { path: "/api/v1/orders/{order_id}", methods: ["GET", "DELETE"], sourceFile: "src/routes/old-orders.py" },
+        ];
+        const diff = makeDiffDataForClassify({
+            changedFiles: ["src/routes/old-orders.py"],
+            deletedFiles: ["src/routes/old-orders.py"],
+        });
+        // scannedEndpoints has GET /api/v1/orders/{order_id} (from orders.py) → moved, filter out
+        // DELETE /api/v1/orders/{order_id} is NOT in scannedEndpoints → truly removed, keep
+        const result = classifyEndpointsByChangedFiles(diff, scannedEndpoints, deleted);
+        expect(result.removedEndpoints).toHaveLength(1);
+        expect(result.removedEndpoints[0].path).toBe("/api/v1/orders/{order_id}");
+        expect(result.removedEndpoints[0].methods).toEqual(["DELETE"]);
+    });
+    it("filters out entirely moved endpoints (all methods exist in catalog)", () => {
+        const deleted = [
+            { path: "/api/v1/orders/{order_id}", methods: ["GET", "PATCH"], sourceFile: "src/routes/old-orders.py" },
+        ];
+        const diff = makeDiffDataForClassify({
+            changedFiles: ["src/routes/old-orders.py"],
+            deletedFiles: ["src/routes/old-orders.py"],
+        });
+        // Both GET and PATCH for /api/v1/orders/{order_id} exist in scannedEndpoints → fully filtered
+        const result = classifyEndpointsByChangedFiles(diff, scannedEndpoints, deleted);
+        expect(result.removedEndpoints).toHaveLength(0);
+    });
+    it("treats MULTI sentinel in current catalog as wildcard when filtering moved endpoints", () => {
+        // Deleted file had explicit GET+POST methods, but current catalog has MULTI for the same path
+        // (e.g. moved to a Next.js catch-all handler) — should be fully filtered out
+        const catalogWithMulti = [
+            ...scannedEndpoints,
+            { path: "/api/v1/legacy", methods: ["MULTI"], sourceFile: "pages/api/legacy.ts" },
+        ];
+        const deleted = [
+            { path: "/api/v1/legacy", methods: ["GET", "POST"], sourceFile: "src/routes/legacy.py" },
+        ];
+        const diff = makeDiffDataForClassify({
+            changedFiles: ["src/routes/legacy.py"],
+            deletedFiles: ["src/routes/legacy.py"],
+        });
+        const result = classifyEndpointsByChangedFiles(diff, catalogWithMulti, deleted);
+        expect(result.removedEndpoints).toHaveLength(0);
+    });
+    it("treats MULTI sentinel in deleted endpoints as wildcard when path exists in catalog", () => {
+        // Deleted file was a Next.js catch-all (MULTI), but path now exists with concrete methods
+        // in the current catalog — should be filtered out as moved, not flagged as removed
+        const deleted = [
+            { path: "/api/v1/orders/{order_id}", methods: ["MULTI"], sourceFile: "pages/api/orders/[order_id].ts" },
+        ];
+        const diff = makeDiffDataForClassify({
+            changedFiles: ["pages/api/orders/[order_id].ts"],
+            deletedFiles: ["pages/api/orders/[order_id].ts"],
+        });
+        // scannedEndpoints already has GET+PATCH for /api/v1/orders/{order_id}
+        const result = classifyEndpointsByChangedFiles(diff, scannedEndpoints, deleted);
+        expect(result.removedEndpoints).toHaveLength(0);
+    });
+    it("defaults removedEndpoints to empty when deletedFileEndpoints is omitted", () => {
+        const diff = makeDiffDataForClassify({
+            changedFiles: ["src/routes/legacy.py"],
+            deletedFiles: ["src/routes/legacy.py"],
+        });
+        const result = classifyEndpointsByChangedFiles(diff, scannedEndpoints);
+        expect(result.removedEndpoints).toEqual([]);
+    });
+});