@skyramp/mcp 0.1.8 → 0.2.0-rc.2

package/build/utils/repoScanner.test.js

@@ -0,0 +1,92 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { scanAllRepoEndpoints, scanRelatedEndpoints } from "./repoScanner.js";
+import { classifyEndpointsByChangedFiles } from "./routeParsers.js";
+describe("scanAllRepoEndpoints", () => {
+    const tempRepos = [];
+    afterEach(() => {
+        for (const repo of tempRepos.splice(0)) {
+            fs.rmSync(repo, { recursive: true, force: true });
+        }
+    });
+    function makeTempRepo() {
+        const repo = fs.mkdtempSync(path.join(os.tmpdir(), "repo-scanner-"));
+        tempRepos.push(repo);
+        return repo;
+    }
+    it("preserves same router-relative paths from different source files", () => {
+        const repo = makeTempRepo();
+        const apiDir = path.join(repo, "src/prefect/server/api");
+        fs.mkdirSync(apiDir, { recursive: true });
+        fs.writeFileSync(path.join(apiDir, "flows.py"), `
+@router.delete(
+    "/{id:uuid}",
+    status_code=204,
+)
+async def delete_flow(): pass
+
+@router.post("/bulk_delete")
+async def bulk_delete_flows(): pass
+`);
+        fs.writeFileSync(path.join(apiDir, "deployments.py"), `
+@router.delete(
+    "/{id:uuid}",
+    status_code=204,
+)
+async def delete_deployment(): pass
+
+@router.post("/bulk_delete")
+async def bulk_delete_deployments(): pass
+`);
+        const endpoints = scanAllRepoEndpoints(repo);
+        const relatedEndpoints = scanRelatedEndpoints(repo, ["src/prefect/server/api/flows.py"]);
+        expect(endpoints).toEqual(expect.arrayContaining([
+            { path: "/{id:uuid}", methods: ["DELETE"], sourceFile: "src/prefect/server/api/flows.py" },
+            { path: "/bulk_delete", methods: ["POST"], sourceFile: "src/prefect/server/api/flows.py" },
+            { path: "/{id:uuid}", methods: ["DELETE"], sourceFile: "src/prefect/server/api/deployments.py" },
+            { path: "/bulk_delete", methods: ["POST"], sourceFile: "src/prefect/server/api/deployments.py" },
+        ]));
+        expect(relatedEndpoints).toEqual(expect.arrayContaining([
+            { path: "/{id:uuid}", methods: ["DELETE"], sourceFile: "src/prefect/server/api/flows.py" },
+            { path: "/bulk_delete", methods: ["POST"], sourceFile: "src/prefect/server/api/flows.py" },
+        ]));
+        const classified = classifyEndpointsByChangedFiles({
+            currentBranch: "feature/admin-key",
+            baseBranch: "origin/main",
+            changedFiles: ["src/prefect/server/api/flows.py"],
+            diffContent: "",
+            diffStat: "",
+            newFiles: [],
+            deletedFiles: [],
+        }, endpoints);
+        expect(classified.changedEndpoints).toEqual(expect.arrayContaining([
+            { path: "/{id:uuid}", methods: ["DELETE"], sourceFile: "src/prefect/server/api/flows.py" },
+            { path: "/bulk_delete", methods: ["POST"], sourceFile: "src/prefect/server/api/flows.py" },
+        ]));
+        expect(classified.changedEndpoints).not.toEqual(expect.arrayContaining([
+            { path: "/{id:uuid}", methods: ["DELETE"], sourceFile: "src/prefect/server/api/deployments.py" },
+        ]));
+    });
+    it("does not suppress removed router-relative endpoints with same-path siblings", () => {
+        const classified = classifyEndpointsByChangedFiles({
+            currentBranch: "feature/remove-flows",
+            baseBranch: "origin/main",
+            changedFiles: ["src/prefect/server/api/flows.py"],
+            diffContent: "",
+            diffStat: "",
+            newFiles: [],
+            deletedFiles: ["src/prefect/server/api/flows.py"],
+        }, [
+            { path: "/{id:uuid}", methods: ["DELETE"], sourceFile: "src/prefect/server/api/deployments.py" },
+            { path: "/bulk_delete", methods: ["POST"], sourceFile: "src/prefect/server/api/deployments.py" },
+        ], [
+            { path: "/{id:uuid}", methods: ["DELETE"], sourceFile: "src/prefect/server/api/flows.py" },
+            { path: "/bulk_delete", methods: ["POST"], sourceFile: "src/prefect/server/api/flows.py" },
+        ]);
+        expect(classified.removedEndpoints).toEqual(expect.arrayContaining([
+            { path: "/{id:uuid}", methods: ["DELETE"], sourceFile: "src/prefect/server/api/flows.py" },
+            { path: "/bulk_delete", methods: ["POST"], sourceFile: "src/prefect/server/api/flows.py" },
+        ]));
+    });
+});

package/build/utils/routeParsers.js

@@ -20,6 +20,22 @@ export function nextjsFileToApiPath(filePath) {
 }
 // UI component file extensions are unambiguously frontend — never route definitions.
 const UI_COMPONENT_EXT = /\.(jsx|tsx|vue|svelte)$/i;
+// Frontend-file extensions for UI-change detection (broader than UI_COMPONENT_EXT —
+// includes template/markup files that backend-only PRs won't touch). Used by
+// testbot-prompts.ts to gate the UI pre-scan and capture-act-capture sections,
+// and anywhere else that needs to ask "does this PR touch the frontend?".
+// Single source of truth for that question.
+export const UI_FILE_EXTENSIONS = ['tsx', 'jsx', 'vue', 'svelte', 'html', 'xml'];
+// Git pathspec form of the UI-file filter — usable directly with `git diff`'s
+// trailing pathspec args, no external tool needed. Avoids the "agent shell
+// has grep aliased to rg" failure mode where `grep -E` becomes `rg -E`
+// (which means `--encoding`, not extended regex). Each entry is `*.ext`;
+// pass them as `-- '*.tsx' '*.jsx' ...` to git diff.
+export const UI_FILE_GIT_PATHSPEC = UI_FILE_EXTENSIONS.map(ext => `'*.${ext}'`).join(' ');
+// Pipe-joined form of the UI extensions for use inside an extended regex
+// (e.g. `grep -E '\\.(tsx|jsx|vue|svelte|html|xml) '`). Mirrors
+// UI_FILE_GIT_PATHSPEC but for grep over a pre-computed diff file.
+export const UI_FILE_EXTENSIONS_PIPED = UI_FILE_EXTENSIONS.join('|');
 export function parseRouteLine(line, sourceFile) {
     const stripped = line.replace(/^[+-]\s*/, "").trim();
     const isComponent = UI_COMPONENT_EXT.test(sourceFile);
@@ -174,6 +190,8 @@ export function parseFileEndpoints(content, sourceFile) {
     // FastAPI APIRouter / Flask Blueprint: variable name → prefix
     const routerPrefixes = new Map();
     let pendingRouterVar = ""; // variable name being accumulated in a multi-line declaration
+    let pendingPythonDecorator = null;
+    let pendingExpressMethod = ""; // HTTP method from a multi-line Express route (e.g. "POST" from `router.post(\n`)
     for (const line of content.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("*"))
@@ -235,6 +253,73 @@ export function parseFileEndpoints(content, sourceFile) {
                 continue;
             }
         }
+        if (pendingPythonDecorator) {
+            // FastAPI decorators commonly split the route path onto the next line:
+            //   @router.delete(
+            //       "/{id}",
+            //       ...
+            //   )
+            const pathMatch = trimmed.match(/^(?:path\s*=\s*)?["']([^"'?#]*)/) ||
+                trimmed.match(/^value\s*=\s*["']([^"'?#]*)/);
+            if (pathMatch) {
+                const routerPrefix = routerPrefixes.get(pendingPythonDecorator.routerVar);
+                const prefix = routerPrefix?.replace(/\/$/, "");
+                const suffix = pathMatch[1].replace(/^\//, "");
+                const path = prefix
+                    ? (suffix ? `${prefix}/${suffix}` : prefix)
+                    : pathMatch[1];
+                results.push({
+                    method: pendingPythonDecorator.method,
+                    path,
+                    sourceFile,
+                });
+                pendingPythonDecorator = null;
+                continue;
+            }
+            if (/^[\]\)\}]+[;,)]*\s*(?:#.*)?$/.test(trimmed) ||
+                trimmed.startsWith("@") ||
+                /^async\s+def\b|^def\b/.test(trimmed)) {
+                pendingPythonDecorator = null;
+            }
+            else {
+                continue;
+            }
+        }
+        // ── Multi-line Express route state machine ────────────────────────────────
+        // Handles patterns like:
+        //   router.post(
+        //       '/:collection',
+        //       middleware,
+        //       handler
+        //   );
+        if (pendingExpressMethod) {
+            // Look for the first path-like string literal on this line
+            const pathMatch = trimmed.match(/["'](\/[^"'?#]*|:[^"'?#]+)["']/);
+            if (pathMatch) {
+                const isComponent = UI_COMPONENT_EXT.test(sourceFile);
+                if (!isComponent) {
+                    results.push({
+                        method: pendingExpressMethod,
+                        path: pathMatch[1],
+                        sourceFile,
+                    });
+                }
+                pendingExpressMethod = "";
+                continue;
+            }
+            // If we hit a closing delimiter-only line or another route call, abandon the pending state
+            if (/^[\]\)\}]+[;,)]*\s*(?:\/\/.*)?$/.test(trimmed)) {
+                pendingExpressMethod = "";
+                continue;
+            }
+            if (/(?:router|app)\.(get|post|put|patch|delete)\s*\(/i.test(trimmed)) {
+                // New route call — reset and fall through to parse this line normally
+                pendingExpressMethod = "";
+            }
+            else {
+                continue; // Skip middleware/handler lines
+            }
+        }
         // ── Non-annotation line → clear any dangling pendingPrefix ───────────────
         // Prevents method-level @RequestMapping (no method=) from being misidentified
         if (pendingPrefix && !trimmed.startsWith("@") && !trimmed.startsWith("[")) {
@@ -248,8 +333,24 @@ export function parseFileEndpoints(content, sourceFile) {
             if (nestjsNoPath)
                 ep = { method: nestjsNoPath[1].toUpperCase(), path: "", sourceFile };
         }
-        if (!ep)
+        if (!ep) {
+            // Detect multi-line FastAPI/Flask-style decorators with the path on a later line.
+            const pythonDecoratorMultiLine = trimmed.match(/@(\w+)\.(get|post|put|patch|delete|head|options)\s*\(\s*$/i);
+            if (pythonDecoratorMultiLine) {
+                pendingPythonDecorator = {
+                    routerVar: pythonDecoratorMultiLine[1],
+                    method: pythonDecoratorMultiLine[2].toUpperCase(),
+                };
+                continue;
+            }
+            // Detect multi-line Express route: method call with no path string on same line
+            // e.g. "router.post(" or "app.get(\n"
+            const expressMultiLine = trimmed.match(/(?:router|app)\.(get|post|put|patch|delete)\s*\(\s*$/i);
+            if (expressMultiLine && !UI_COMPONENT_EXT.test(sourceFile)) {
+                pendingExpressMethod = expressMultiLine[1].toUpperCase();
+            }
             continue;
+        }
         // ── Apply prefix ──────────────────────────────────────────────────────────
         if (classPrefix) {
             // Class-based prefix (Spring, NestJS, ASP.NET)
@@ -280,11 +381,30 @@ export function parseFileEndpoints(content, sourceFile) {
     return results;
 }
 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"). */
+/**
+ * Extract the primary resource key from an endpoint path for use as a dedup key.
+ *
+ * For top-level resources (e.g. "/api/v1/orders/{id}") returns the resource name ("orders").
+ * For sub-resources (e.g. "/orders/{id}/items") returns "orders_items" — including the
+ * parent prevents "/orders/{id}/items" and "/products/{id}/items" from colliding on "items".
+ */
 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";
+    if (meaningful.length === 0)
+        return "unknown";
+    // Sub-resource pattern: /…/<parent>/{param}/<child>
+    // Detected when the last raw segment is non-param and the second-to-last is a param.
+    const last = segments[segments.length - 1];
+    const secondLast = segments.length >= 2 ? segments[segments.length - 2] : "";
+    if (!last.startsWith("{") && secondLast.startsWith("{") && meaningful.length >= 2) {
+        return `${meaningful[meaningful.length - 2]}_${meaningful[meaningful.length - 1]}`;
+    }
+    return meaningful[meaningful.length - 1];
+}
+const GENERIC_ROUTE_BASENAMES = new Set(["api", "app", "handler", "handlers", "index", "route", "routes", "router", "server"]);
+function normalizeSourcePath(filePath) {
+    return filePath.replace(/\\/g, "/");
 }
 /**
  * Classify endpoints by cross-referencing `changedFiles` against `scannedEndpoints[].sourceFile`.
@@ -297,30 +417,33 @@ export function extractResourceFromPath(endpointPath) {
  * (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 newFileSet = new Set(diffData.newFiles.map(normalizeSourcePath));
+    const deletedFileSet = new Set(diffData.deletedFiles.map(normalizeSourcePath));
+    // Build sourceFile -> ScannedEndpoint[] map from the post-change catalog.
+    // Git diffs use POSIX separators; scanner output can reflect OS-native paths.
     const bySourceFile = new Map();
     for (const ep of scannedEndpoints) {
-        const existing = bySourceFile.get(ep.sourceFile);
+        const sourceKey = normalizeSourcePath(ep.sourceFile);
+        const existing = bySourceFile.get(sourceKey);
         if (existing)
             existing.push(ep);
         else
-            bySourceFile.set(ep.sourceFile, [ep]);
+            bySourceFile.set(sourceKey, [ep]);
     }
     const changedEndpoints = [];
     const newEndpoints = [];
     const unmatchedFiles = [];
     for (const file of diffData.changedFiles) {
+        const fileKey = normalizeSourcePath(file);
         // Deleted files won't appear in scanned catalog — handled separately below
-        if (deletedFileSet.has(file))
+        if (deletedFileSet.has(fileKey))
             continue;
-        const eps = bySourceFile.get(file);
+        const eps = bySourceFile.get(fileKey);
         if (!eps || eps.length === 0) {
             unmatchedFiles.push(file);
             continue;
         }
-        if (newFileSet.has(file)) {
+        if (newFileSet.has(fileKey)) {
             newEndpoints.push(...eps);
         }
         else {
@@ -328,23 +451,55 @@ export function classifyEndpointsByChangedFiles(diffData, scannedEndpoints, dele
         }
     }
     // 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));
+    // Filter out endpoints that still exist in the current catalog as moved/refactored.
+    // Same router-relative paths can exist in sibling files, so only treat them as moved
+    // when the source resource also matches.
+    function endpointSourceResource(ep) {
+        const sourceSegments = ep.sourceFile.split(/[\\/]/).filter(Boolean);
+        const base = sourceSegments.at(-1)?.replace(/\.[^.]+$/, "") ?? "";
+        const normalizedBase = base.replace(/^(?:old|new)[-_]/i, "").toLowerCase();
+        const isDynamicBase = /^\[.*\]$/.test(normalizedBase) || /^\{.*\}$/.test(normalizedBase);
+        if (normalizedBase && !isDynamicBase && !GENERIC_ROUTE_BASENAMES.has(normalizedBase)) {
+            return normalizedBase;
+        }
+        if (normalizedBase && GENERIC_ROUTE_BASENAMES.has(normalizedBase)) {
+            const contextSegment = [...sourceSegments]
+                .slice(0, -1)
+                .reverse()
+                .map((segment) => segment.replace(/\.[^.]+$/, "").replace(/^(?:old|new)[-_]/i, "").toLowerCase())
+                .find((segment) => segment && !GENERIC_ROUTE_BASENAMES.has(segment) && !/^\[.*\]$/.test(segment) && !/^\{.*\}$/.test(segment));
+            if (contextSegment)
+                return `${contextSegment}/${normalizedBase}`;
+        }
+        const staticSegments = ep.path.split("/").filter(Boolean).filter((segment) => !/^[:{[]/.test(segment));
+        return staticSegments[staticSegments.length - 1]?.toLowerCase() ?? normalizedBase;
+    }
+    const currentMethodKeys = new Set();
+    const currentPathResourceKeys = new Set();
+    const currentMultiKeys = new Set();
+    const movedKey = (path, resource, method) => method ? `${path}::${resource}::${method}` : `${path}::${resource}`;
+    for (const current of scannedEndpoints) {
+        const currentResource = endpointSourceResource(current);
+        const pathResourceKey = movedKey(current.path, currentResource);
+        currentPathResourceKeys.add(pathResourceKey);
+        for (const method of current.methods) {
+            if (method === "MULTI")
+                currentMultiKeys.add(pathResourceKey);
+            currentMethodKeys.add(movedKey(current.path, currentResource, method));
+        }
+    }
+    function isMovedEndpoint(deleted, method) {
+        const deletedResource = endpointSourceResource(deleted);
+        const pathResourceKey = movedKey(deleted.path, deletedResource);
+        if (method === "MULTI")
+            return currentPathResourceKeys.has(pathResourceKey);
+        return currentMultiKeys.has(pathResourceKey) ||
+            currentMethodKeys.has(movedKey(deleted.path, deletedResource, method));
+    }
     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);
-        }),
+        methods: ep.methods.filter((m) => !isMovedEndpoint(ep, m)),
     }))
         .filter((ep) => ep.methods.length > 0);
     // Affected services: same heuristic as before

package/build/utils/routeParsers.test.js

@@ -257,6 +257,120 @@ async def get_product(): pass
         const eps = parseFileEndpoints(content, "routers/product.py");
         expect(eps).toContainEqual({ method: "GET", path: "/products/{product_id}", sourceFile: "routers/product.py" });
     });
+    it("FastAPI multi-line method decorators capture path arguments", () => {
+        const content = `
+router = APIRouter(
+    prefix="/flows",
+    tags=["flows"],
+)
+
+@router.delete(
+    "/{id:uuid}",
+    status_code=204,
+)
+async def delete_flow(): pass
+
+@router.post(
+    "/bulk_delete",
+    status_code=204,
+)
+async def bulk_delete_flows(): pass
+    `;
+        const eps = parseFileEndpoints(content, "src/prefect/server/api/flows.py");
+        expect(eps).toContainEqual({ method: "DELETE", path: "/flows/{id:uuid}", sourceFile: "src/prefect/server/api/flows.py" });
+        expect(eps).toContainEqual({ method: "POST", path: "/flows/bulk_delete", sourceFile: "src/prefect/server/api/flows.py" });
+    });
+    // ── Multi-line Express route patterns ──────────────────────────────────────
+    it("Express multi-line: router.post( with path on next line", () => {
+        const content = `
+router.post(
+\t'/:collection',
+\tasyncHandler(async (req, res, next) => {})
+);
+`;
+        const eps = parseFileEndpoints(content, "controllers/collections.ts");
+        expect(eps).toContainEqual({ method: "POST", path: "/:collection", sourceFile: "controllers/collections.ts" });
+    });
+    it("Express multi-line: app.get( with path on next line", () => {
+        const content = `
+app.get(
+\t'/health',
+\t(req, res) => res.json({ status: 'ok' })
+);
+`;
+        const eps = parseFileEndpoints(content, "server.ts");
+        expect(eps).toContainEqual({ method: "GET", path: "/health", sourceFile: "server.ts" });
+    });
+    it("Express multi-line: does not fire for single-line routes", () => {
+        const content = `router.get('/api/products', handler)`;
+        const eps = parseFileEndpoints(content, "routes.ts");
+        expect(eps).toHaveLength(1);
+        expect(eps[0]).toEqual({ method: "GET", path: "/api/products", sourceFile: "routes.ts" });
+    });
+    it("Express multi-line: handles multiple consecutive multi-line routes", () => {
+        const content = `
+router.post(
+\t'/',
+\tasyncHandler(async (req, res) => {})
+);
+
+router.get(
+\t'/:pk',
+\tasyncHandler(async (req, res) => {})
+);
+
+router.delete(
+\t'/:pk',
+\tasyncHandler(async (req, res) => {})
+);
+`;
+        const eps = parseFileEndpoints(content, "controllers/items.ts");
+        expect(eps).toHaveLength(3);
+        expect(eps).toContainEqual({ method: "POST", path: "/", sourceFile: "controllers/items.ts" });
+        expect(eps).toContainEqual({ method: "GET", path: "/:pk", sourceFile: "controllers/items.ts" });
+        expect(eps).toContainEqual({ method: "DELETE", path: "/:pk", sourceFile: "controllers/items.ts" });
+    });
+    it("Express multi-line: ignores component files (.tsx)", () => {
+        const content = `
+router.post(
+\t'/:collection',
+\thandler
+);
+`;
+        const eps = parseFileEndpoints(content, "components/Form.tsx");
+        expect(eps).toHaveLength(0);
+    });
+    it("Express multi-line: abandons pending state on closing paren without path", () => {
+        const content = `
+router.post(
+);
+router.get('/fallback', handler);
+`;
+        const eps = parseFileEndpoints(content, "routes.ts");
+        expect(eps).toHaveLength(1);
+        expect(eps[0]).toEqual({ method: "GET", path: "/fallback", sourceFile: "routes.ts" });
+    });
+    it("Express multi-line: mixes single-line and multi-line routes", () => {
+        const content = `
+router.get('/', validateBatch('read'), readHandler, respond);
+
+router.get(
+\t'/:pk',
+\tasyncHandler(async (req, res, next) => {})
+);
+
+router.patch(
+\t'/:pk',
+\tvalidateBatch('update'),
+\tasyncHandler(async (req, res, next) => {})
+);
+`;
+        const eps = parseFileEndpoints(content, "controllers/access.ts");
+        expect(eps).toHaveLength(3);
+        expect(eps).toContainEqual({ method: "GET", path: "/", sourceFile: "controllers/access.ts" });
+        expect(eps).toContainEqual({ method: "GET", path: "/:pk", sourceFile: "controllers/access.ts" });
+        expect(eps).toContainEqual({ method: "PATCH", path: "/:pk", sourceFile: "controllers/access.ts" });
+    });
 });
 describe("extractResourceFromPath", () => {
     it("extracts resource from simple path", () => {
@@ -271,7 +385,7 @@ describe("extractResourceFromPath", () => {
         expect(extractResourceFromPath("/api/v1/orders/{order_id}")).toBe("orders");
     });
     it("handles nested resources", () => {
-        expect(extractResourceFromPath("/api/v1/orders/{order_id}/items")).toBe("items");
+        expect(extractResourceFromPath("/api/v1/orders/{order_id}/items")).toBe("orders_items");
     });
     it("handles public prefix", () => {
         expect(extractResourceFromPath("/public/products")).toBe("products");
@@ -456,6 +570,71 @@ describe("classifyEndpointsByChangedFiles", () => {
         const result = classifyEndpointsByChangedFiles(diff, scannedEndpoints, deleted);
         expect(result.removedEndpoints).toHaveLength(0);
     });
+    it("matches POSIX diff paths against Windows-style scanned source files", () => {
+        const windowsScanned = [
+            { path: "/api/v1/orders/{order_id}", methods: ["GET"], sourceFile: "src\\routes\\orders.py" },
+            { path: "/api/v1/products/{product_id}", methods: ["POST"], sourceFile: "src\\routes\\products.py" },
+        ];
+        const diff = makeDiffDataForClassify({
+            changedFiles: ["src/routes/orders.py", "src/routes/products.py", "src/routes/legacy.py"],
+            newFiles: ["src/routes/products.py"],
+            deletedFiles: ["src/routes/legacy.py"],
+        });
+        const result = classifyEndpointsByChangedFiles(diff, windowsScanned, [
+            { path: "/api/v1/legacy", methods: ["DELETE"], sourceFile: "src\\routes\\legacy.py" },
+        ]);
+        expect(result.changedEndpoints).toEqual([windowsScanned[0]]);
+        expect(result.newEndpoints).toEqual([windowsScanned[1]]);
+        expect(result.removedEndpoints).toEqual([
+            { path: "/api/v1/legacy", methods: ["DELETE"], sourceFile: "src\\routes\\legacy.py" },
+        ]);
+        expect(result.unmatchedFiles).toEqual([]);
+        expect(result.changedFiles).toEqual(diff.changedFiles);
+    });
+    it("uses Windows path separators when comparing moved endpoint resources", () => {
+        const current = [
+            { path: "/api/v1/orders/{order_id}", methods: ["GET"], sourceFile: "src/routes/orders.py" },
+        ];
+        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"],
+        });
+        const result = classifyEndpointsByChangedFiles(diff, current, deleted);
+        expect(result.removedEndpoints).toHaveLength(1);
+        expect(result.removedEndpoints[0].methods).toEqual(["DELETE"]);
+    });
+    it("treats generic same-name route files in the same resource folder as moved", () => {
+        const current = [
+            { path: "/{id}", methods: ["GET", "DELETE"], sourceFile: "src/api/flows/server.py" },
+        ];
+        const deleted = [
+            { path: "/{id}", methods: ["GET", "DELETE"], sourceFile: "src/api/flows/old-server.py" },
+        ];
+        const diff = makeDiffDataForClassify({
+            changedFiles: ["src/api/flows/old-server.py"],
+            deletedFiles: ["src/api/flows/old-server.py"],
+        });
+        const result = classifyEndpointsByChangedFiles(diff, current, deleted);
+        expect(result.removedEndpoints).toHaveLength(0);
+    });
+    it("does not treat generic same-name route files in different resource folders as moved", () => {
+        const current = [
+            { path: "/{id}", methods: ["GET"], sourceFile: "src/api/deployments/server.py" },
+        ];
+        const deleted = [
+            { path: "/{id}", methods: ["GET", "DELETE"], sourceFile: "src/api/flows/server.py" },
+        ];
+        const diff = makeDiffDataForClassify({
+            changedFiles: ["src/api/flows/server.py"],
+            deletedFiles: ["src/api/flows/server.py"],
+        });
+        const result = classifyEndpointsByChangedFiles(diff, current, deleted);
+        expect(result.removedEndpoints).toHaveLength(1);
+        expect(result.removedEndpoints[0].methods).toEqual(["GET", "DELETE"]);
+    });
     it("defaults removedEndpoints to empty when deletedFileEndpoints is omitted", () => {
         const diff = makeDiffDataForClassify({
             changedFiles: ["src/routes/legacy.py"],