@skyramp/mcp 0.2.8 → 0.2.10-rc.1

package/build/utils/routeParsers.test.js

@@ -1,5 +1,5 @@
 // @ts-ignore
-import { nextjsFileToApiPath, parseRouteLine, parseFileEndpoints, extractResourceFromPath, classifyEndpointsByChangedFiles } from "./routeParsers.js";
+import { nextjsFileToApiPath, parseRouteLine, parseFileEndpoints, extractResourceFromPath, classifyEndpointsByChangedFiles, selectRemovalCandidateFiles, recoverRemovedEndpointsFromBase, parseChangedLinesByFile } from "./routeParsers.js";
 describe("nextjsFileToApiPath", () => {
     it("converts pages/api route to API path", () => {
         expect(nextjsFileToApiPath("pages/api/users/index.ts")).toBe("/api/users");
@@ -147,8 +147,8 @@ describe("parseFileEndpoints", () => {
       }
     `;
         const eps = parseFileEndpoints(content, "UserController.java");
-        expect(eps).toContainEqual({ method: "GET", path: "/api/v1/users/{id}", sourceFile: "UserController.java" });
-        expect(eps).toContainEqual({ method: "POST", path: "/api/v1/users", sourceFile: "UserController.java" });
+        expect(eps).toContainEqual(expect.objectContaining({ method: "GET", path: "/api/v1/users/{id}", sourceFile: "UserController.java" }));
+        expect(eps).toContainEqual(expect.objectContaining({ method: "POST", path: "/api/v1/users", sourceFile: "UserController.java" }));
     });
     it("Spring: class without prefix emits method paths as-is", () => {
         const content = `
@@ -158,7 +158,7 @@ describe("parseFileEndpoints", () => {
       }
     `;
         const eps = parseFileEndpoints(content, "ProductController.java");
-        expect(eps).toContainEqual({ method: "GET", path: "/products", sourceFile: "ProductController.java" });
+        expect(eps).toContainEqual(expect.objectContaining({ method: "GET", path: "/products", sourceFile: "ProductController.java" }));
     });
     it("Spring: second class in file does not inherit first class prefix", () => {
         const content = `
@@ -173,9 +173,9 @@ describe("parseFileEndpoints", () => {
       }
     `;
         const eps = parseFileEndpoints(content, "Controllers.java");
-        expect(eps).toContainEqual({ method: "GET", path: "/api/orders/{id}", sourceFile: "Controllers.java" });
-        expect(eps).toContainEqual({ method: "GET", path: "/health", sourceFile: "Controllers.java" });
-        expect(eps).not.toContainEqual({ method: "GET", path: "/api/orders/health", sourceFile: "Controllers.java" });
+        expect(eps).toContainEqual(expect.objectContaining({ method: "GET", path: "/api/orders/{id}", sourceFile: "Controllers.java" }));
+        expect(eps).toContainEqual(expect.objectContaining({ method: "GET", path: "/health", sourceFile: "Controllers.java" }));
+        expect(eps).not.toContainEqual(expect.objectContaining({ method: "GET", path: "/api/orders/health", sourceFile: "Controllers.java" }));
     });
     it("NestJS: combines @Controller prefix with @Get path", () => {
         const content = `
@@ -186,7 +186,7 @@ describe("parseFileEndpoints", () => {
       }
     `;
         const eps = parseFileEndpoints(content, "users.controller.ts");
-        expect(eps).toContainEqual({ method: "GET", path: "users/:id", sourceFile: "users.controller.ts" });
+        expect(eps).toContainEqual(expect.objectContaining({ method: "GET", path: "/users/:id", sourceFile: "users.controller.ts" }));
     });
     it("NestJS: @Post() with no path uses controller root", () => {
         const content = `
@@ -199,8 +199,8 @@ describe("parseFileEndpoints", () => {
       }
     `;
         const eps = parseFileEndpoints(content, "users.controller.ts");
-        expect(eps).toContainEqual({ method: "POST", path: "users", sourceFile: "users.controller.ts" });
-        expect(eps).toContainEqual({ method: "GET", path: "users", sourceFile: "users.controller.ts" });
+        expect(eps).toContainEqual(expect.objectContaining({ method: "POST", path: "/users", sourceFile: "users.controller.ts" }));
+        expect(eps).toContainEqual(expect.objectContaining({ method: "GET", path: "/users", sourceFile: "users.controller.ts" }));
     });
     it("ASP.NET: combines [Route] prefix with [HttpGet] path", () => {
         const content = `
@@ -214,8 +214,8 @@ describe("parseFileEndpoints", () => {
       }
     `;
         const eps = parseFileEndpoints(content, "OrdersController.cs");
-        expect(eps).toContainEqual({ method: "GET", path: "api/v1/orders/{id}", sourceFile: "OrdersController.cs" });
-        expect(eps).toContainEqual({ method: "POST", path: "api/v1/orders", sourceFile: "OrdersController.cs" });
+        expect(eps).toContainEqual(expect.objectContaining({ method: "GET", path: "/api/v1/orders/{id}", sourceFile: "OrdersController.cs" }));
+        expect(eps).toContainEqual(expect.objectContaining({ method: "POST", path: "/api/v1/orders", sourceFile: "OrdersController.cs" }));
     });
     it("non-class-based frameworks are unaffected (Express, Flask, Gin)", () => {
         const content = `
@@ -224,7 +224,7 @@ describe("parseFileEndpoints", () => {
       r.DELETE("/users/:id", deleteUser)
     `;
         const eps = parseFileEndpoints(content, "routes.ts");
-        expect(eps).toContainEqual({ method: "GET", path: "/api/products", sourceFile: "routes.ts" });
+        expect(eps).toContainEqual(expect.objectContaining({ method: "GET", path: "/api/products", sourceFile: "routes.ts" }));
     });
     it("FastAPI multi-line APIRouter prefix is combined with method decorators", () => {
         const content = `
@@ -243,9 +243,9 @@ async def get_order(): pass
 async def delete_order(): pass
     `;
         const eps = parseFileEndpoints(content, "routers/order.py");
-        expect(eps).toContainEqual({ method: "POST", path: "/orders", sourceFile: "routers/order.py" });
-        expect(eps).toContainEqual({ method: "GET", path: "/orders/{order_id}", sourceFile: "routers/order.py" });
-        expect(eps).toContainEqual({ method: "DELETE", path: "/orders/{order_id}", sourceFile: "routers/order.py" });
+        expect(eps).toContainEqual(expect.objectContaining({ method: "POST", path: "/orders", sourceFile: "routers/order.py" }));
+        expect(eps).toContainEqual(expect.objectContaining({ method: "GET", path: "/orders/{order_id}", sourceFile: "routers/order.py" }));
+        expect(eps).toContainEqual(expect.objectContaining({ method: "DELETE", path: "/orders/{order_id}", sourceFile: "routers/order.py" }));
     });
     it("FastAPI single-line APIRouter prefix is combined with method decorators", () => {
         const content = `
@@ -255,7 +255,7 @@ router = APIRouter(prefix="/products", tags=["products"])
 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" });
+        expect(eps).toContainEqual(expect.objectContaining({ method: "GET", path: "/products/{product_id}", sourceFile: "routers/product.py" }));
     });
     it("FastAPI multi-line method decorators capture path arguments", () => {
         const content = `
@@ -277,8 +277,8 @@ async def delete_flow(): pass
 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" });
+        expect(eps).toContainEqual(expect.objectContaining({ method: "DELETE", path: "/flows/{id:uuid}", sourceFile: "src/prefect/server/api/flows.py" }));
+        expect(eps).toContainEqual(expect.objectContaining({ 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", () => {
@@ -289,7 +289,7 @@ router.post(
 );
 `;
         const eps = parseFileEndpoints(content, "controllers/collections.ts");
-        expect(eps).toContainEqual({ method: "POST", path: "/:collection", sourceFile: "controllers/collections.ts" });
+        expect(eps).toContainEqual(expect.objectContaining({ method: "POST", path: "/:collection", sourceFile: "controllers/collections.ts" }));
     });
     it("Express multi-line: app.get( with path on next line", () => {
         const content = `
@@ -299,13 +299,13 @@ app.get(
 );
 `;
         const eps = parseFileEndpoints(content, "server.ts");
-        expect(eps).toContainEqual({ method: "GET", path: "/health", sourceFile: "server.ts" });
+        expect(eps).toContainEqual(expect.objectContaining({ 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" });
+        expect(eps[0]).toEqual(expect.objectContaining({ method: "GET", path: "/api/products", sourceFile: "routes.ts" }));
     });
     it("Express multi-line: handles multiple consecutive multi-line routes", () => {
         const content = `
@@ -326,9 +326,9 @@ router.delete(
 `;
         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" });
+        expect(eps).toContainEqual(expect.objectContaining({ method: "POST", path: "/", sourceFile: "controllers/items.ts" }));
+        expect(eps).toContainEqual(expect.objectContaining({ method: "GET", path: "/:pk", sourceFile: "controllers/items.ts" }));
+        expect(eps).toContainEqual(expect.objectContaining({ method: "DELETE", path: "/:pk", sourceFile: "controllers/items.ts" }));
     });
     it("Express multi-line: ignores component files (.tsx)", () => {
         const content = `
@@ -348,7 +348,7 @@ 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" });
+        expect(eps[0]).toEqual(expect.objectContaining({ method: "GET", path: "/fallback", sourceFile: "routes.ts" }));
     });
     it("Express multi-line: mixes single-line and multi-line routes", () => {
         const content = `
@@ -367,9 +367,9 @@ router.patch(
 `;
         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" });
+        expect(eps).toContainEqual(expect.objectContaining({ method: "GET", path: "/", sourceFile: "controllers/access.ts" }));
+        expect(eps).toContainEqual(expect.objectContaining({ method: "GET", path: "/:pk", sourceFile: "controllers/access.ts" }));
+        expect(eps).toContainEqual(expect.objectContaining({ method: "PATCH", path: "/:pk", sourceFile: "controllers/access.ts" }));
     });
 });
 describe("extractResourceFromPath", () => {
@@ -644,3 +644,253 @@ describe("classifyEndpointsByChangedFiles", () => {
         expect(result.removedEndpoints).toEqual([]);
     });
 });
+describe("selectRemovalCandidateFiles", () => {
+    function makeDiff(opts) {
+        return {
+            currentBranch: "feature/test",
+            baseBranch: "origin/main",
+            changedFiles: opts.changedFiles,
+            diffContent: "",
+            diffStat: "",
+            newFiles: opts.newFiles ?? [],
+            deletedFiles: opts.deletedFiles ?? [],
+        };
+    }
+    it("includes modified and deleted files but excludes newly-created files", () => {
+        // A route removed by editing a surviving file lives in a *modified* file, not a
+        // deleted one — so modified files must be candidates for removed-endpoint recovery.
+        const diff = makeDiff({
+            changedFiles: ["src/routes/recipe.py", "src/routes/brand_new.py", "src/routes/legacy.py"],
+            newFiles: ["src/routes/brand_new.py"],
+            deletedFiles: ["src/routes/legacy.py"],
+        });
+        expect(selectRemovalCandidateFiles(diff).sort()).toEqual(["src/routes/legacy.py", "src/routes/recipe.py"].sort());
+    });
+    it("returns empty when the only change is a newly-created file", () => {
+        const diff = makeDiff({
+            changedFiles: ["src/routes/brand_new.py"],
+            newFiles: ["src/routes/brand_new.py"],
+        });
+        expect(selectRemovalCandidateFiles(diff)).toEqual([]);
+    });
+});
+describe("recoverRemovedEndpointsFromBase", () => {
+    it("recovers a route removed by editing a surviving file (line-edit removal)", async () => {
+        // Base version of a MODIFIED router file had two routes; the current branch
+        // deleted only /suggestions (the /bulk-actions route survives).
+        const baseContent = `
+router = APIRouter(prefix="/api/recipes", tags=["recipes"])
+
+@router.get("/suggestions")
+async def suggest_recipes(): pass
+
+@router.post("/bulk-actions/categorize")
+async def categorize(): pass
+    `;
+        const fetchBaseContent = async (file) => file === "mealie/routes/recipe/recipe_crud_routes.py" ? baseContent : "";
+        const recovered = await recoverRemovedEndpointsFromBase(["mealie/routes/recipe/recipe_crud_routes.py"], fetchBaseContent);
+        // Both base-branch endpoints are parsed from the modified file.
+        expect(recovered.map((e) => e.path).sort()).toEqual(["/api/recipes/bulk-actions/categorize", "/api/recipes/suggestions"].sort());
+        // Feeding these to the classifier with the *current* catalog (which still has the
+        // surviving route) leaves only the genuinely-removed route in removedEndpoints.
+        const scanned = [
+            { path: "/api/recipes/bulk-actions/categorize", methods: ["POST"], sourceFile: "mealie/routes/recipe/recipe_crud_routes.py" },
+        ];
+        const diff = {
+            currentBranch: "feature/test",
+            baseBranch: "origin/main",
+            changedFiles: ["mealie/routes/recipe/recipe_crud_routes.py"],
+            diffContent: "",
+            diffStat: "",
+            newFiles: [],
+            deletedFiles: [],
+        };
+        const result = classifyEndpointsByChangedFiles(diff, scanned, recovered);
+        expect(result.removedEndpoints.map((e) => e.path)).toEqual(["/api/recipes/suggestions"]);
+    });
+    it("skips non-route files and tolerates fetch failures", async () => {
+        const fetchBaseContent = async (file) => {
+            if (file === "README.md")
+                throw new Error("should not be fetched");
+            throw new Error("git show failed");
+        };
+        const recovered = await recoverRemovedEndpointsFromBase(["README.md", "src/routes/orders.py"], fetchBaseContent);
+        expect(recovered).toEqual([]);
+    });
+});
+describe("parseFileEndpoints — declaration line numbers", () => {
+    it("records the 1-based declaration line of each single-line route", () => {
+        const content = [
+            "package main", // 1
+            "", // 2
+            "func Routes() {", // 3
+            '  r.GET("/users", h)', // 4
+            '  r.POST("/items", h)', // 5
+            "}", // 6
+        ].join("\n");
+        const eps = parseFileEndpoints(content, "main.go");
+        expect(eps.find((e) => e.path === "/users")?.line).toBe(4);
+        expect(eps.find((e) => e.path === "/items")?.line).toBe(5);
+    });
+    it("records the decorator start line for a multi-line FastAPI route", () => {
+        const content = [
+            "router = APIRouter()", // 1
+            "", // 2
+            "@router.get(", // 3  <- decorator start
+            '    "/flows",', // 4  <- path resolved here
+            ")", // 5
+            "def list_flows():", // 6
+            "    return []", // 7
+        ].join("\n");
+        const eps = parseFileEndpoints(content, "api/flows.py");
+        expect(eps[0].path).toBe("/flows");
+        expect(eps[0].line).toBe(3);
+    });
+});
+describe("parseChangedLinesByFile", () => {
+    it("collects new-side line numbers of added lines per file", () => {
+        const diffContent = [
+            "diff --git a/routers/api/v1/api.go b/routers/api/v1/api.go",
+            "--- a/routers/api/v1/api.go",
+            "+++ b/routers/api/v1/api.go",
+            "@@ -147,5 +147,6 @@ func Routes() {",
+            " m.Group(\"/misc\", func() {",
+            " existingA",
+            " existingB",
+            "+ m.Post(\"/markdown\", Markdown)",
+            " existingC",
+            " })",
+        ].join("\n");
+        const map = parseChangedLinesByFile(diffContent);
+        // new-side numbering from 147: 147 context, 148, 149, 150(+), 151, 152
+        expect([...(map.get("routers/api/v1/api.go") ?? [])]).toEqual([150]);
+    });
+    it("does not advance the new-side cursor on removed lines", () => {
+        const diffContent = [
+            "--- a/svc/orders.py",
+            "+++ b/svc/orders.py",
+            "@@ -10,4 +10,3 @@",
+            " keep",
+            "-gone",
+            "+added",
+            " keep2",
+        ].join("\n");
+        const map = parseChangedLinesByFile(diffContent);
+        // 10 context(keep), '-gone' no advance, '+added' at new line 11
+        expect([...(map.get("svc/orders.py") ?? [])]).toEqual([11]);
+    });
+    it("records the new-side position of a deletion-only hunk", () => {
+        const diffContent = [
+            "--- a/svc/orders.py",
+            "+++ b/svc/orders.py",
+            "@@ -20,3 +20,2 @@",
+            " keep",
+            "-gone",
+            " keep2",
+        ].join("\n");
+        const map = parseChangedLinesByFile(diffContent);
+        // 20 context(keep) -> cursor 21, '-gone' records 21 (no advance), keep2 -> 21
+        expect([...(map.get("svc/orders.py") ?? [])]).toEqual([21]);
+    });
+});
+describe("classifyEndpointsByChangedFiles — hunk-scoped (centralized routing)", () => {
+    // Gitea-shaped hub: every route registered in one api.go file, each on its own line.
+    const HUB = "routers/api/v1/api.go";
+    const hubEndpoints = [
+        { path: "/repos/{owner}/{repo}/issues", methods: ["GET", "POST"], sourceFile: HUB, line: 100 },
+        { path: "/markdown", methods: ["POST"], sourceFile: HUB, line: 150 },
+        { path: "/markup", methods: ["POST"], sourceFile: HUB, line: 151 },
+        { path: "/user/repos", methods: ["GET"], sourceFile: HUB, line: 200 },
+    ];
+    function diffAddingMarkdownRoute() {
+        // Adds one route line whose new-side line number is 150 (the /markdown decl).
+        return {
+            currentBranch: "feature/add-markdown",
+            baseBranch: "origin/main",
+            changedFiles: [HUB],
+            diffContent: [
+                `diff --git a/${HUB} b/${HUB}`,
+                `--- a/${HUB}`,
+                `+++ b/${HUB}`,
+                "@@ -147,5 +147,6 @@ func Routes() {",
+                " existingA",
+                " existingB",
+                " existingC",
+                "+ m.Post(\"/markdown\", Markdown)",
+                " existingD",
+            ].join("\n"),
+            diffStat: "",
+            newFiles: [],
+            deletedFiles: [],
+        };
+    }
+    it("scopes changed endpoints to the route line actually edited, not the whole hub file", () => {
+        const result = classifyEndpointsByChangedFiles(diffAddingMarkdownRoute(), hubEndpoints);
+        expect(result.changedEndpoints.map((e) => e.path)).toEqual(["/markdown"]);
+    });
+    it("attributes a handler-body edit to its enclosing route (decentralized, no over-scoping)", () => {
+        const recipe = [
+            { path: "/api/recipes", methods: ["GET", "POST"], sourceFile: "mealie/routes/recipe.py", line: 10 },
+        ];
+        const diff = {
+            currentBranch: "f", baseBranch: "origin/main",
+            changedFiles: ["mealie/routes/recipe.py"],
+            diffContent: [
+                "--- a/mealie/routes/recipe.py",
+                "+++ b/mealie/routes/recipe.py",
+                "@@ -24,2 +24,3 @@ def get_recipe():",
+                " x = 1",
+                "+ y = 2",
+                " return x",
+            ].join("\n"),
+            diffStat: "", newFiles: [], deletedFiles: [],
+        };
+        const result = classifyEndpointsByChangedFiles(diff, recipe);
+        expect(result.changedEndpoints.map((e) => e.path)).toEqual(["/api/recipes"]);
+    });
+    it("falls back to file-level scoping when endpoints carry no line info", () => {
+        const noLines = hubEndpoints.map(({ line: _line, ...rest }) => rest);
+        const result = classifyEndpointsByChangedFiles(diffAddingMarkdownRoute(), noLines);
+        expect(result.changedEndpoints).toHaveLength(4);
+    });
+    it("falls back to file-level scoping when diffContent is empty", () => {
+        const diff = { ...diffAddingMarkdownRoute(), diffContent: "" };
+        const result = classifyEndpointsByChangedFiles(diff, hubEndpoints);
+        expect(result.changedEndpoints).toHaveLength(4);
+    });
+    it("scopes a deletion-only edit to the route that owns the deleted position", () => {
+        // A hunk that only removes lines (no additions) must still scope — otherwise
+        // a deletion in a hub file falls back to flagging the whole route table.
+        const diff = {
+            currentBranch: "f", baseBranch: "origin/main",
+            changedFiles: [HUB],
+            diffContent: [
+                `+++ b/${HUB}`,
+                "@@ -158,3 +158,2 @@",
+                " ctxA",
+                "- m.Get(\"/markup-legacy\", MarkupLegacy)",
+                " ctxB",
+            ].join("\n"),
+            diffStat: "", newFiles: [], deletedFiles: [],
+        };
+        // Deleted position is new-side 159, inside /markup's ownership range [151, 200).
+        const result = classifyEndpointsByChangedFiles(diff, hubEndpoints);
+        expect(result.changedEndpoints.map((e) => e.path)).toEqual(["/markup"]);
+    });
+    it("falls back to file-level when the change is above the first route (e.g. imports)", () => {
+        const diff = {
+            currentBranch: "f", baseBranch: "origin/main",
+            changedFiles: [HUB],
+            diffContent: [
+                `+++ b/${HUB}`,
+                "@@ -1,2 +1,3 @@",
+                " package v1",
+                "+ import \"fmt\"",
+                " import \"net/http\"",
+            ].join("\n"),
+            diffStat: "", newFiles: [], deletedFiles: [],
+        };
+        const result = classifyEndpointsByChangedFiles(diff, hubEndpoints);
+        expect(result.changedEndpoints).toHaveLength(4);
+    });
+});

package/build/utils/sourceRouteExtractor.js

@@ -184,11 +184,16 @@ function extractRoutesFromFile(filePath, cache) {
             return;
         }
         // 2. defineModule({ id, routes: [...] }) — Directus per-module aggregation.
+        //    createBrowserRouter([...]) — React Router data-router object form.
         if (ts.isCallExpression(node)) {
             const moduleRoutes = defineModuleRoutesFromCall(node, filePath, imports, localConsts, cache);
             if (moduleRoutes) {
                 routes.push(...moduleRoutes);
             }
+            const dataRouterRoutes = createRouterRoutesFromCall(node, filePath, imports, localConsts, cache);
+            if (dataRouterRoutes) {
+                routes.push(...dataRouterRoutes);
+            }
         }
     });
     // 3. Vue Router object-literal arrays (top-level, not inside defineModule).
@@ -203,21 +208,62 @@ function jsxRouteFromNode(node, filePath, imports, localConsts, cache) {
         return null;
     const attrs = jsxAttributesOf(node);
     const pathAttr = attrs.find((a) => a.name === "path");
-    if (!pathAttr)
-        return null;
-    const pathValue = resolveAttrToString(pathAttr, filePath, imports, localConsts, cache);
-    if (pathValue === null)
+    let ownPath;
+    if (pathAttr) {
+        ownPath = resolveAttrToString(pathAttr, filePath, imports, localConsts, cache);
+        if (ownPath === null)
+            return null;
+    }
+    else if (attrs.some((a) => a.name === "index")) {
+        // <Route index> has no path — it renders at the parent route's path.
+        ownPath = "";
+    }
+    else {
         return null;
+    }
     const componentAttr = attrs.find((a) => a.name === "element" || a.name === "component");
     if (!componentAttr || componentAttr.kind !== "identifier")
         return null;
+    // React Router child paths are relative to the enclosing <Route>; compose
+    // with the ancestor chain so nested routes yield full navigable URLs.
+    const parentPrefix = enclosingJsxRoutePath(node, filePath, imports, localConsts, cache);
     return {
-        path: pathValue,
+        path: composeRoutePath(parentPrefix, ownPath),
         componentName: componentAttr.value,
         componentFile: imports.get(componentAttr.value)?.filePath,
         declaredIn: filePath,
     };
 }
+/**
+ * Walk a JSX route node's ancestor chain and compose the paths of the enclosing
+ * `<Route>` elements (root → leaf). Returns "" for a top-level route with no
+ * enclosing route. Relies on `setParentNodes` being enabled when parsing.
+ */
+function enclosingJsxRoutePath(node, filePath, imports, localConsts, cache) {
+    const segments = [];
+    let cur = node.parent;
+    while (cur) {
+        // A non-leaf <Route> is passed as its opening element, whose parent is its
+        // OWN JsxElement — skip that so the route doesn't count its own path.
+        if (ts.isJsxElement(cur) && cur.openingElement !== node) {
+            const opening = cur.openingElement;
+            const tag = jsxTagOf(opening);
+            if (tag && ROUTE_TAG_NAMES.has(tag)) {
+                const pathAttr = jsxAttributesOf(opening).find((a) => a.name === "path");
+                if (pathAttr) {
+                    const p = resolveAttrToString(pathAttr, filePath, imports, localConsts, cache);
+                    if (p !== null)
+                        segments.unshift(p); // nearest ancestor seen first → prepend for root→leaf order
+                }
+            }
+        }
+        cur = cur.parent;
+    }
+    let prefix = "";
+    for (const seg of segments)
+        prefix = composeRoutePath(prefix, seg);
+    return prefix;
+}
 function scriptKindFor(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     switch (ext) {
@@ -682,6 +728,14 @@ function vueRouterRoutesFromFile(sf, filePath, imports, localConsts, cache) {
             return;
         if (isInsideDefineModule(node))
             return;
+        // createBrowserRouter objects are handled hierarchically (with children +
+        // path composition) by createRouterRoutesFromCall. Skip them here so a
+        // data-router object written in the { path, component } shape — which the
+        // Vue-style heuristic below also matches — isn't emitted a second time with
+        // an un-composed relative path. Objects using `element:` don't match that
+        // heuristic anyway, so this guard only bites the rarer `component:` form.
+        if (isInsideCreateRouter(node))
+            return;
         const r = routeFromObjectLiteral(node, "", filePath, imports, localConsts, cache);
         if (r)
             out.push(r);
@@ -700,6 +754,18 @@ function isInsideDefineModule(node) {
     }
     return false;
 }
+function isInsideCreateRouter(node) {
+    let cur = node.parent;
+    while (cur) {
+        if (ts.isCallExpression(cur)) {
+            const expr = cur.expression;
+            if (ts.isIdentifier(expr) && DATA_ROUTER_FNS.has(expr.text))
+                return true;
+        }
+        cur = cur.parent;
+    }
+    return false;
+}
 /**
  * Build a SourceRoute from an object literal that has the route shape
  * (`path` + `component` properties). Returns null when the shape doesn't
@@ -753,6 +819,109 @@ function composeRoutePath(prefix, child) {
     const normalizedChild = child.replace(/^\//, "");
     return normalizedPrefix + "/" + normalizedChild;
 }
+// ── createBrowserRouter data-router API (React Router) ─────────────────────
+/**
+ * Route-array factory functions from the React Router data-router API — all
+ * take the same `[{ path, element, children }]` array as their first argument.
+ * Includes the client routers (browser/hash/memory) and the SSR pair
+ * (createStaticRouter / createStaticHandler). The *Provider components
+ * (RouterProvider / StaticRouterProvider) are NOT here — they render a router
+ * instance via a `router` prop and declare no routes themselves.
+ */
+const DATA_ROUTER_FNS = new Set([
+    "createBrowserRouter",
+    "createHashRouter",
+    "createMemoryRouter",
+    "createStaticRouter",
+    "createStaticHandler",
+]);
+/**
+ * Detect a data-router factory call (`createBrowserRouter([...])` and the
+ * hash/memory/static variants) and yield routes from the object-literal array,
+ * recursing `children:` with the parent path composed in. Route objects use
+ * `element: <X/>` (JSX) or `component: X`, and `index: true` for the
+ * parent-path index route.
+ */
+function createRouterRoutesFromCall(call, filePath, imports, localConsts, cache) {
+    const callee = call.expression;
+    if (!ts.isIdentifier(callee) || !DATA_ROUTER_FNS.has(callee.text))
+        return null;
+    const arg = call.arguments[0];
+    if (!arg || !ts.isArrayLiteralExpression(arg))
+        return null;
+    return dataRouterRoutesFromArray(arg, "", filePath, imports, localConsts, cache);
+}
+function dataRouterRoutesFromArray(arr, prefix, filePath, imports, localConsts, cache) {
+    const out = [];
+    for (const elt of arr.elements) {
+        if (!ts.isObjectLiteralExpression(elt))
+            continue;
+        let hasPath = false;
+        let pathValue = null;
+        let isIndex = false;
+        let componentName;
+        let childrenArray;
+        for (const prop of elt.properties) {
+            if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+                continue;
+            const name = prop.name.text;
+            if (name === "path") {
+                hasPath = true;
+                pathValue = resolveExpressionToString(prop.initializer, filePath, imports, localConsts, cache, 0);
+            }
+            else if (name === "index") {
+                isIndex = prop.initializer.kind === ts.SyntaxKind.TrueKeyword;
+            }
+            else if (name === "element" || name === "component") {
+                componentName = componentIdentifierOf(prop.initializer);
+            }
+            else if (name === "children" && ts.isArrayLiteralExpression(prop.initializer)) {
+                childrenArray = prop.initializer;
+            }
+        }
+        // A path present but unresolvable would make every descendant URL wrong —
+        // skip this object and its subtree rather than emit bogus paths.
+        if (hasPath && pathValue === null)
+            continue;
+        let childPrefix = prefix;
+        if (hasPath) {
+            childPrefix = composeRoutePath(prefix, pathValue);
+            if (componentName) {
+                out.push({
+                    path: childPrefix,
+                    componentName,
+                    componentFile: imports.get(componentName)?.filePath,
+                    declaredIn: filePath,
+                });
+            }
+        }
+        else if (isIndex && componentName) {
+            out.push({
+                path: composeRoutePath(prefix, ""),
+                componentName,
+                componentFile: imports.get(componentName)?.filePath,
+                declaredIn: filePath,
+            });
+        }
+        // Pathless layout route (no path, not index): contributes no URL segment;
+        // its children inherit the current prefix unchanged.
+        if (childrenArray) {
+            out.push(...dataRouterRoutesFromArray(childrenArray, childPrefix, filePath, imports, localConsts, cache));
+        }
+    }
+    return out;
+}
+/** Resolve a route object's `element`/`component` value to a component name. */
+function componentIdentifierOf(init) {
+    if (ts.isIdentifier(init))
+        return init.text;
+    if (ts.isJsxSelfClosingElement(init) || ts.isJsxOpeningElement(init)) {
+        return jsxTagOf(init) ?? undefined;
+    }
+    if (ts.isJsxElement(init))
+        return jsxTagOf(init.openingElement) ?? undefined;
+    return undefined;
+}
 // ── defineModule aggregation (Directus) ────────────────────────────────────
 /**
  * Detect `defineModule({ id: 'foo', routes: [...] })` calls and yield routes