@skyramp/mcp 0.1.1 → 0.1.3

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([]);
+    });
+});

package/build/utils/scenarioDrafting.js

@@ -87,6 +87,9 @@ export function inferResourceRelationships(endpoints) {
     // ── Signal 2: FK fields in request body interactions ──
     // Collect all known resource names first so we can validate FK targets.
     const knownResources = new Set(endpoints.map(ep => extractResourceName(ep.path)).filter(Boolean));
+    // Map singular form → actual resource name to handle irregular plurals.
+    // e.g. singularize("companies") = "company", so "company_id" resolves to "companies".
+    const singularToResource = new Map([...knownResources].map(r => [singularize(r), r]));
     for (const ep of endpoints) {
         const resource = extractResourceName(ep.path);
         if (!resource)
@@ -104,14 +107,19 @@ export function inferResourceRelationships(endpoints) {
                     if (!key.endsWith("_id"))
                         continue;
                     const depSingular = key.slice(0, -3); // "product_id" → "product"
-                    const depPlural = depSingular + "s"; // → "products"
-                    // Only create relationship when the dependency actually exists as an endpoint
+                    const depPlural = depSingular + "s"; // naive plural, fine for regular nouns
+                    // Only create relationship when the dependency actually exists as an endpoint.
+                    // Check naive plural first (products), then exact singular (product),
+                    // then reverse-singularize to catch irregular plurals (company → companies).
                     if (knownResources.has(depPlural)) {
                         addRelationship(resource, depPlural);
                     }
                     else if (knownResources.has(depSingular)) {
                         addRelationship(resource, depSingular);
                     }
+                    else if (singularToResource.has(depSingular)) {
+                        addRelationship(resource, singularToResource.get(depSingular));
+                    }
                 }
             }
         }

package/build/utils/versions.js

@@ -1,3 +1,3 @@
-export const SKYRAMP_IMAGE_VERSION = "v1.3.22";
+export const SKYRAMP_IMAGE_VERSION = "v1.3.23";
 export const EXECUTOR_DOCKER_IMAGE = `skyramp/executor:${SKYRAMP_IMAGE_VERSION}`;
 export const WORKER_DOCKER_IMAGE = `skyramp/worker:${SKYRAMP_IMAGE_VERSION}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyramp/mcp",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "main": "build/index.js",
   "exports": {
     ".": "./build/index.js",
@@ -55,7 +55,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.24.3",
     "@playwright/test": "^1.55.0",
-    "@skyramp/skyramp": "1.3.22",
+    "@skyramp/skyramp": "1.3.23",
     "dockerode": "^5.0.0",
     "fast-glob": "^3.3.3",
     "js-yaml": "^4.1.1",