devlensio 0.4.3 → 0.6.0

package/dist/graph/edges/apiFetchEdges.js

@@ -1,6 +1,7 @@
 // This file detects the backend routes of the NEXTjs only
 import { Project, SyntaxKind } from "ts-morph";
 import path from "node:path";
+import { extractUrlFromArg, normalizeUrl, urlPathtoRegex } from "./helpers/routeMatching.js";
 const CALLER_CONFIG = {
     "fetch": { inferMethod: "from-options", defaultMethod: "GET" },
     "axios.get": { inferMethod: "fixed", method: "GET" },
@@ -20,16 +21,6 @@ const CALLER_CONFIG = {
     "useSWR": { inferMethod: "fixed", method: "GET" },
     "useSWRMutation": { inferMethod: "fixed", method: "UNKNOWN" },
 };
-function urlPathtoRegex(urlPath) {
-    const pattern = urlPath.split("/").map(segment => {
-        if (segment.startsWith(":") && segment.endsWith("*"))
-            return ".+"; // catch-all :slug*
-        if (segment.startsWith(":"))
-            return "[^/]+"; // dynamic :id
-        return segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // escape static segments
-    }).join("\\/");
-    return new RegExp(`^${pattern}$`);
-}
 // Groups Next.js API ROUTE nodes by HTTP method for efficient lookup.
 // Each route node carries a concrete method, so it is indexed under that one
 // method key. Callers with an UNKNOWN method (e.g. useSWRMutation) are handled
@@ -54,97 +45,6 @@ function buildRouteIndex(nodes) {
     }
     return index;
 }
-/*
-Extracts string value from an initializer node.
-Handles 3 cases:
-  'string literal'           → returns value directly
-  `no-substitution template` → returns value directly
-  `template ${expr} literal` → preserves ${...} as-is so normalizeUrl handles it later
-*/
-function resolveVariableValue(initializer) {
-    const kind = initializer.getKind();
-    if (kind === SyntaxKind.StringLiteral) {
-        return initializer.getLiteralText();
-    }
-    if (kind === SyntaxKind.NoSubstitutionTemplateLiteral) {
-        return initializer.getLiteralText();
-    }
-    if (kind === SyntaxKind.TemplateExpression) {
-        const head = initializer.getHead().getLiteralText();
-        const spans = initializer.getTemplateSpans().map((span) => `\${${span.getExpression().getText()}}${span.getLiteral().getLiteralText()}`);
-        return head + spans.join("");
-    }
-    return null; // object, function, computed — can't resolve
-}
-/*
-Resolves a variable name to its string value.
-Strategy:
-  1. Look in the same file
-  2. Walk named imports → find the source file → look there
-  Files not yet in the project are added lazily so we don't pre-load everything.
- */
-function resolveUrlVariable(varName, sourceFile, project) {
-    //case 1 -> Variable exists in same file
-    const localDecl = sourceFile.getVariableDeclaration(varName);
-    if (localDecl) {
-        const init = localDecl.getInitializer();
-        if (init)
-            return resolveVariableValue(init);
-    }
-    //case 2 -> named imports
-    for (const importDecl of sourceFile.getImportDeclarations()) {
-        const match = importDecl.getNamedImports().find(n => n.getName() === varName);
-        if (!match)
-            continue;
-        // Try to get the source file — it may not be in the project yet
-        let importedFile = importDecl.getModuleSpecifierSourceFile();
-        if (!importedFile) {
-            // Lazily add the file to the project
-            const specifier = importDecl.getModuleSpecifierValue();
-            const currentDir = path.dirname(sourceFile.getFilePath());
-            const base = path.resolve(currentDir, specifier);
-            for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
-                try {
-                    importedFile = project.addSourceFileAtPath(base + ext);
-                    break;
-                }
-                catch {
-                    continue;
-                }
-            }
-        }
-        if (!importedFile)
-            continue;
-        const importedDecl = importedFile.getVariableDeclaration(varName);
-        if (importedDecl) {
-            const init = importedDecl.getInitializer();
-            if (init)
-                return resolveVariableValue(init);
-        }
-    }
-    return null;
-}
-//  URL Normalization 
-// Converts a raw URL string from the call site into a normalized form
-// that can be compared against route index entries.
-// Examples:
-//   `/api/users/${id}`        → /api/users/:dynamic
-//   `/api/users/${org}/${id}` → /api/users/:dynamic/:dynamic
-//   /api/users?foo=bar        → /api/users
-//   /api/users/               → /api/users
-function normalizeUrl(rawUrl) {
-    // Skip external URLs
-    if (rawUrl.startsWith("http://") || rawUrl.startsWith("https://"))
-        return null;
-    // Must start with /
-    if (!rawUrl.startsWith("/"))
-        return null;
-    return rawUrl
-        .split("?")[0] // strip query string
-        .replace(/\$\{[^}]+\}/g, ":dynamic") // ${anything} → :dynamic
-        .replace(/\/+$/, "") // strip trailing slash
-        || "/"; // fallback to root if empty
-}
 //  Route Matching 
 // Matches a normalized URL + HTTP method against the route index.
 // Rules:
@@ -167,42 +67,6 @@ function matchRouteEntries(normalizedUrl, method, routeIndex) {
     // e.g. "/api/users/:dynamic" matches the regex for route "/api/users/:id".
     return candidates.filter(e => e.isDynamic && e.urlRegex.test(normalizedUrl));
 }
-//  URL Argument Extraction 
-// Shared helper — reconstructs a template literal preserving ${...} as-is
-// so normalizeUrl can replace them with :dynamic later.
-// Same logic as resolveVariableValue's TemplateExpression branch.
-function reconstructTemplate(templateExpr) {
-    const head = templateExpr.getHead().getLiteralText();
-    const spans = templateExpr.getTemplateSpans().map((span) => `\${${span.getExpression().getText()}}${span.getLiteral().getLiteralText()}`);
-    return head + spans.join("");
-}
-// Extracts a URL string from a call argument.
-// Handles 4 cases:
-//   '/api/users'          → string literal      → return directly
-//   `/api/users`          → no-sub template     → return directly
-//   `/api/users/${id}`    → template expression → preserve ${...}
-//   API_URL               → identifier          → resolve via resolveUrlVariable
-// Returns null if the arg is an object / array / expression we can't resolve.
-function extractUrlFromArg(arg, sourceFile, project) {
-    const kind = arg.getKind();
-    if (kind === SyntaxKind.StringLiteral ||
-        kind === SyntaxKind.NoSubstitutionTemplateLiteral) {
-        const url = arg.getLiteralText();
-        return { rawUrl: url, resolvedUrl: url };
-    }
-    if (kind === SyntaxKind.TemplateExpression) {
-        const url = reconstructTemplate(arg);
-        return { rawUrl: url, resolvedUrl: url };
-    }
-    if (kind === SyntaxKind.Identifier) {
-        const varName = arg.getText();
-        const resolved = resolveUrlVariable(varName, sourceFile, project);
-        if (!resolved)
-            return null;
-        return { rawUrl: varName, resolvedUrl: resolved };
-    }
-    return null;
-}
 // Scans EVERY call expression in a source file exactly once.
 // For each call matching CALLER_CONFIG:
 //   - infers the HTTP method

package/dist/graph/edges/helpers/routeMatching.d.ts

@@ -0,0 +1,8 @@
+import { Project, SourceFile } from "ts-morph";
+export declare function urlPathtoRegex(urlPath: string): RegExp;
+export declare function normalizeUrl(rawUrl: string): string | null;
+export declare function reconstructTemplate(templateExpr: any): string;
+export declare function extractUrlFromArg(arg: any, sourceFile: SourceFile, project: Project): {
+    rawUrl: string;
+    resolvedUrl: string;
+} | null;

package/dist/graph/edges/helpers/routeMatching.js

@@ -0,0 +1,122 @@
+// Shared route/URL matching helpers used by both the Next.js API-call detector
+// (apiFetchEdges.ts) and the navigation detector (navigationEdges.ts).
+import { SyntaxKind } from "ts-morph";
+import path from "node:path";
+// Converts a route urlPath into a matching RegExp.
+//   :id    → [^/]+   (dynamic segment)
+//   :slug* → .+      (catch-all)
+//   static → escaped literally
+export function urlPathtoRegex(urlPath) {
+    const pattern = urlPath.split("/").map(segment => {
+        if (segment.startsWith(":") && segment.endsWith("*"))
+            return ".+"; // catch-all :slug*
+        if (segment.startsWith(":"))
+            return "[^/]+"; // dynamic :id
+        return segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // escape static segments
+    }).join("\\/");
+    return new RegExp(`^${pattern}$`);
+}
+// Converts a raw URL string from a call site into a normalized form comparable
+// against route index entries.
+//   `/api/users/${id}` → /api/users/:dynamic
+//   /api/users?foo=bar → /api/users
+//   /api/users/        → /api/users
+// Returns null for external (http/https) or non-"/"-prefixed URLs.
+export function normalizeUrl(rawUrl) {
+    if (rawUrl.startsWith("http://") || rawUrl.startsWith("https://"))
+        return null;
+    if (!rawUrl.startsWith("/"))
+        return null;
+    return rawUrl
+        .split("?")[0] // strip query string
+        .replace(/\$\{[^}]+\}/g, ":dynamic") // ${anything} → :dynamic
+        .replace(/\/+$/, "") // strip trailing slash
+        || "/"; // fallback to root if empty
+}
+// Reconstructs a template literal preserving ${...} as-is so normalizeUrl can
+// replace them with :dynamic later.
+export function reconstructTemplate(templateExpr) {
+    const head = templateExpr.getHead().getLiteralText();
+    const spans = templateExpr.getTemplateSpans().map((span) => `\${${span.getExpression().getText()}}${span.getLiteral().getLiteralText()}`);
+    return head + spans.join("");
+}
+// Extracts a string value from an initializer node (literal / template / etc).
+function resolveVariableValue(initializer) {
+    const kind = initializer.getKind();
+    if (kind === SyntaxKind.StringLiteral) {
+        return initializer.getLiteralText();
+    }
+    if (kind === SyntaxKind.NoSubstitutionTemplateLiteral) {
+        return initializer.getLiteralText();
+    }
+    if (kind === SyntaxKind.TemplateExpression) {
+        const head = initializer.getHead().getLiteralText();
+        const spans = initializer.getTemplateSpans().map((span) => `\${${span.getExpression().getText()}}${span.getLiteral().getLiteralText()}`);
+        return head + spans.join("");
+    }
+    return null; // object, function, computed — can't resolve
+}
+// Resolves a variable name to its string value (same file first, then named imports).
+function resolveUrlVariable(varName, sourceFile, project) {
+    const localDecl = sourceFile.getVariableDeclaration(varName);
+    if (localDecl) {
+        const init = localDecl.getInitializer();
+        if (init)
+            return resolveVariableValue(init);
+    }
+    for (const importDecl of sourceFile.getImportDeclarations()) {
+        const match = importDecl.getNamedImports().find(n => n.getName() === varName);
+        if (!match)
+            continue;
+        let importedFile = importDecl.getModuleSpecifierSourceFile();
+        if (!importedFile) {
+            const specifier = importDecl.getModuleSpecifierValue();
+            const currentDir = path.dirname(sourceFile.getFilePath());
+            const base = path.resolve(currentDir, specifier);
+            for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
+                try {
+                    importedFile = project.addSourceFileAtPath(base + ext);
+                    break;
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        if (!importedFile)
+            continue;
+        const importedDecl = importedFile.getVariableDeclaration(varName);
+        if (importedDecl) {
+            const init = importedDecl.getInitializer();
+            if (init)
+                return resolveVariableValue(init);
+        }
+    }
+    return null;
+}
+// Extracts a URL string from a call/attr argument node.
+//   '/api/users'        → string literal      → return directly
+//   `/api/users`        → no-sub template     → return directly
+//   `/api/users/${id}`  → template expression → preserve ${...}
+//   API_URL             → identifier          → resolve via resolveUrlVariable
+// Returns null for objects/arrays/expressions we can't resolve.
+export function extractUrlFromArg(arg, sourceFile, project) {
+    const kind = arg.getKind();
+    if (kind === SyntaxKind.StringLiteral ||
+        kind === SyntaxKind.NoSubstitutionTemplateLiteral) {
+        const url = arg.getLiteralText();
+        return { rawUrl: url, resolvedUrl: url };
+    }
+    if (kind === SyntaxKind.TemplateExpression) {
+        const url = reconstructTemplate(arg);
+        return { rawUrl: url, resolvedUrl: url };
+    }
+    if (kind === SyntaxKind.Identifier) {
+        const varName = arg.getText();
+        const resolved = resolveUrlVariable(varName, sourceFile, project);
+        if (!resolved)
+            return null;
+        return { rawUrl: varName, resolvedUrl: resolved };
+    }
+    return null;
+}

package/dist/graph/edges/navigationEdges.d.ts

@@ -0,0 +1,5 @@
+import { CodeEdge, CodeNode } from "../../types.js";
+export declare function detectNavigationEdges(nodes: CodeNode[], repoPath: string): {
+    edges: CodeEdge[];
+    ghostNodes: CodeNode[];
+};

package/dist/graph/edges/navigationEdges.js

@@ -0,0 +1,339 @@
+// Detects client-side navigation and emits NAVIGATES_TO edges from
+// COMPONENT/HOOK/FUNCTION nodes to ROUTE nodes. Covers React Router (v5/v6),
+// TanStack Router, wouter, Next.js (next/link, next/navigation, next/router),
+// and native window.location / window.history navigation.
+//
+// Structure mirrors apiFetchEdges.ts: one ts-morph Project, each candidate
+// file scanned once, calls attributed to the innermost owning node by line
+// range, paths normalized + matched against a route index, edges deduped.
+import { Project, SyntaxKind } from "ts-morph";
+import path from "node:path";
+import { extractUrlFromArg, normalizeUrl, urlPathtoRegex } from "./helpers/routeMatching.js";
+// Recognized routing libraries (import-source gating).
+const RR_LIBS = ["react-router-dom", "react-router", "wouter", "@tanstack/react-router"];
+const NEXT_LINK_LIBS = ["next/link"];
+const NEXT_ROUTER_LIBS = ["next/navigation", "next/router"];
+// Build the route index from navigable ROUTE nodes (NOT API routes).
+function buildNavRouteIndex(nodes) {
+    const staticByPath = new Map();
+    const dynamic = [];
+    const routeNodes = nodes.filter(n => n.type === "ROUTE" &&
+        (n.metadata.routeNodeType === "PAGE" || n.metadata.routeNodeType === "REACT_ROUTER_ROUTE") &&
+        typeof n.metadata.urlPath === "string");
+    for (const routeNode of routeNodes) {
+        const urlPath = routeNode.metadata.urlPath;
+        const isDynamic = Boolean(routeNode.metadata.isDynamic);
+        const entry = { routeNode, urlPath, isDynamic, urlRegex: urlPathtoRegex(urlPath) };
+        if (isDynamic)
+            dynamic.push(entry);
+        else if (!staticByPath.has(urlPath))
+            staticByPath.set(urlPath, entry);
+    }
+    return { staticByPath, dynamic };
+}
+// Two-pass match: static exact first, then dynamic regex.
+function matchNavRoute(normalizedUrl, index) {
+    const exact = index.staticByPath.get(normalizedUrl);
+    if (exact)
+        return exact;
+    for (const e of index.dynamic) {
+        if (e.urlRegex.test(normalizedUrl))
+            return e;
+    }
+    return null;
+}
+// Per-file map: local imported name → module specifier.
+function buildImportSourceMap(sourceFile) {
+    const map = new Map();
+    for (const importDecl of sourceFile.getImportDeclarations()) {
+        const spec = importDecl.getModuleSpecifierValue();
+        for (const named of importDecl.getNamedImports()) {
+            const local = named.getAliasNode()?.getText() ?? named.getName();
+            map.set(local, spec);
+        }
+        const def = importDecl.getDefaultImport();
+        if (def)
+            map.set(def.getText(), spec);
+        const ns = importDecl.getNamespaceImport();
+        if (ns)
+            map.set(ns.getText(), spec);
+    }
+    return map;
+}
+// Track local vars bound to navigate fn / router obj / history obj — only when
+// the producing hook is imported from a recognized routing library.
+function buildNavBindingMaps(sourceFile, importMap) {
+    const navigateVars = new Set(); // useNavigate (RR / TanStack)
+    const routerVars = new Set(); // useRouter   (Next.js)
+    const historyVars = new Set(); // useHistory  (RR v5)
+    // Use descendants, not getVariableDeclarations() — the latter only returns
+    // top-level declarations, but `const navigate = useNavigate()` lives inside
+    // the component/hook body.
+    for (const decl of sourceFile.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+        const init = decl.getInitializer();
+        if (!init || init.getKind() !== SyntaxKind.CallExpression)
+            continue;
+        const callee = init.getExpression().getText();
+        const src = importMap.get(callee);
+        if (!src)
+            continue;
+        const nameNode = decl.getNameNode();
+        if (nameNode.getKind() !== SyntaxKind.Identifier)
+            continue; // skip destructuring
+        const name = nameNode.getText();
+        if (callee === "useNavigate" && RR_LIBS.includes(src))
+            navigateVars.add(name);
+        else if (callee === "useRouter" && NEXT_ROUTER_LIBS.includes(src))
+            routerVars.add(name);
+        else if (callee === "useHistory" && RR_LIBS.includes(src))
+            historyVars.add(name);
+    }
+    return { navigateVars, routerVars, historyVars };
+}
+function getJsxAttrValueNode(attr) {
+    const init = attr.getInitializer?.();
+    if (!init)
+        return null;
+    const k = init.getKind();
+    if (k === SyntaxKind.StringLiteral)
+        return init;
+    if (k === SyntaxKind.JsxExpression)
+        return init.getExpression();
+    return null;
+}
+function extractNavCallsFromFile(sourceFile, project) {
+    const results = [];
+    const importMap = buildImportSourceMap(sourceFile);
+    const { navigateVars, routerVars, historyVars } = buildNavBindingMaps(sourceFile, importMap);
+    // ── Call expressions ─────────────────────────────────────────────────
+    for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+        const expr = call.getExpression();
+        const args = call.getArguments();
+        // navigate('/x') / navigate(`/x/${id}`) / navigate({ to: '/x' })
+        if (expr.getKind() === SyntaxKind.Identifier) {
+            const name = expr.getText();
+            if (!navigateVars.has(name) || args.length === 0)
+                continue;
+            const arg0 = args[0];
+            let urlResult = null;
+            if (arg0.getKind() === SyntaxKind.ObjectLiteralExpression) {
+                const toInit = arg0.getProperty("to")?.getInitializer?.();
+                urlResult = toInit ? extractUrlFromArg(toInit, sourceFile, project) : null;
+            }
+            else {
+                urlResult = extractUrlFromArg(arg0, sourceFile, project);
+            }
+            if (!urlResult)
+                continue;
+            results.push({ startLine: call.getStartLineNumber(), callerType: "navigate",
+                rawUrl: urlResult.rawUrl, resolvedUrl: urlResult.resolvedUrl, method: "navigate" });
+            continue;
+        }
+        // member calls
+        if (expr.getKind() === SyntaxKind.PropertyAccessExpression) {
+            const member = expr;
+            const propName = member.getName();
+            const objText = member.getExpression().getText();
+            const objLeaf = objText.split(".").pop();
+            // window.location.replace/assign('/x') — native, always eligible
+            if ((propName === "replace" || propName === "assign") && objText.endsWith("location")) {
+                if (args.length === 0)
+                    continue;
+                const urlResult = extractUrlFromArg(args[0], sourceFile, project);
+                if (!urlResult)
+                    continue;
+                results.push({ startLine: call.getStartLineNumber(), callerType: `location.${propName}`,
+                    rawUrl: urlResult.rawUrl, resolvedUrl: urlResult.resolvedUrl, method: "location" });
+                continue;
+            }
+            // window.history.pushState/replaceState(state, title, '/x') — native, url is arg[2]
+            if ((propName === "pushState" || propName === "replaceState") && objText.endsWith("history")) {
+                if (args.length < 3)
+                    continue;
+                const urlResult = extractUrlFromArg(args[2], sourceFile, project);
+                if (!urlResult)
+                    continue;
+                results.push({ startLine: call.getStartLineNumber(), callerType: `history.${propName}`,
+                    rawUrl: urlResult.rawUrl, resolvedUrl: urlResult.resolvedUrl, method: "history" });
+                continue;
+            }
+            // router.push/replace (Next) / history.push/replace (RR v5) — gated by binding maps
+            if (propName === "push" || propName === "replace") {
+                const eligible = routerVars.has(objText) || historyVars.has(objText) ||
+                    routerVars.has(objLeaf) || historyVars.has(objLeaf);
+                if (!eligible || args.length === 0)
+                    continue;
+                const arg0 = args[0];
+                let urlResult = null;
+                if (arg0.getKind() === SyntaxKind.ObjectLiteralExpression) {
+                    const pInit = arg0.getProperty("pathname")?.getInitializer?.();
+                    urlResult = pInit ? extractUrlFromArg(pInit, sourceFile, project) : null;
+                }
+                else {
+                    urlResult = extractUrlFromArg(arg0, sourceFile, project);
+                }
+                if (!urlResult)
+                    continue;
+                results.push({ startLine: call.getStartLineNumber(), callerType: `router.${propName}`,
+                    rawUrl: urlResult.rawUrl, resolvedUrl: urlResult.resolvedUrl, method: propName });
+                continue;
+            }
+        }
+    }
+    // ── window.location.href = '/x' / location.href = '/x' ───────────────
+    for (const bin of sourceFile.getDescendantsOfKind(SyntaxKind.BinaryExpression)) {
+        if (bin.getOperatorToken().getKind() !== SyntaxKind.EqualsToken)
+            continue;
+        const left = bin.getLeft();
+        if (left.getKind() !== SyntaxKind.PropertyAccessExpression)
+            continue;
+        const member = left;
+        if (member.getName() !== "href")
+            continue;
+        if (!member.getExpression().getText().endsWith("location"))
+            continue;
+        const urlResult = extractUrlFromArg(bin.getRight(), sourceFile, project);
+        if (!urlResult)
+            continue;
+        results.push({ startLine: bin.getStartLineNumber(), callerType: "location.href",
+            rawUrl: urlResult.rawUrl, resolvedUrl: urlResult.resolvedUrl, method: "location" });
+    }
+    // ── <Link to> / <NavLink to> (RR/wouter) and <Link href> (next/link) ──
+    for (const el of [
+        ...sourceFile.getDescendantsOfKind(SyntaxKind.JsxOpeningElement),
+        ...sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement),
+    ]) {
+        const tag = el.getTagNameNode().getText();
+        if (tag !== "Link" && tag !== "NavLink")
+            continue;
+        const importSrc = importMap.get(tag);
+        if (!importSrc)
+            continue; // gate: must be an imported Link
+        const toAttr = el.getAttribute("to");
+        const hrefAttr = el.getAttribute("href");
+        let attr = null;
+        if (toAttr && RR_LIBS.includes(importSrc))
+            attr = toAttr;
+        else if (hrefAttr && NEXT_LINK_LIBS.includes(importSrc))
+            attr = hrefAttr;
+        if (!attr)
+            continue;
+        const valueNode = getJsxAttrValueNode(attr);
+        if (!valueNode)
+            continue;
+        const urlResult = extractUrlFromArg(valueNode, sourceFile, project);
+        if (!urlResult)
+            continue;
+        results.push({ startLine: el.getStartLineNumber(), callerType: `<${tag}>`,
+            rawUrl: urlResult.rawUrl, resolvedUrl: urlResult.resolvedUrl, method: "link" });
+    }
+    return results;
+}
+function makeGhostRoute(id, target, flags) {
+    return {
+        id,
+        name: target,
+        type: "ROUTE",
+        filePath: "[route]",
+        startLine: 0,
+        endLine: 0,
+        metadata: {
+            urlPath: target,
+            routeKind: "react-router",
+            isDynamic: /[:*]/.test(target),
+            framework: "unknown",
+            ...flags,
+        },
+    };
+}
+export function detectNavigationEdges(nodes, repoPath) {
+    const edges = [];
+    const dedupSet = new Set();
+    const ghostMap = new Map();
+    const index = buildNavRouteIndex(nodes);
+    const existingIds = new Set(nodes.map(n => n.id));
+    const project = new Project({
+        compilerOptions: { allowJs: true, checkJs: false, jsx: 4, strict: false },
+        skipAddingFilesFromTsConfig: true,
+    });
+    const candidateNodes = nodes.filter(n => n.type !== "ROUTE" && n.type !== "THIRD_PARTY" &&
+        typeof n.rawCode === "string" && n.rawCode.length > 0);
+    const nodesByFile = new Map();
+    for (const node of candidateNodes) {
+        const abs = path.resolve(repoPath, node.filePath);
+        if (!nodesByFile.has(abs))
+            nodesByFile.set(abs, []);
+        nodesByFile.get(abs).push(node);
+    }
+    for (const [abs, fileNodes] of nodesByFile) {
+        let sourceFile = project.getSourceFile(abs);
+        if (!sourceFile) {
+            try {
+                sourceFile = project.addSourceFileAtPath(abs);
+            }
+            catch {
+                continue;
+            }
+        }
+        const located = extractNavCallsFromFile(sourceFile, project);
+        if (located.length === 0)
+            continue;
+        for (const loc of located) {
+            // Attribute to the innermost node whose line range contains the call.
+            let owner = null;
+            for (const node of fileNodes) {
+                if (loc.startLine < node.startLine || loc.startLine > node.endLine)
+                    continue;
+                if (owner === null || (node.endLine - node.startLine) < (owner.endLine - owner.startLine)) {
+                    owner = node;
+                }
+            }
+            if (owner === null)
+                continue;
+            const rawTarget = loc.resolvedUrl;
+            let toId;
+            let matchType;
+            if (rawTarget.startsWith("http://") || rawTarget.startsWith("https://")) {
+                toId = `[route]::${rawTarget}`;
+                matchType = "external";
+                if (!existingIds.has(toId) && !ghostMap.has(toId)) {
+                    ghostMap.set(toId, makeGhostRoute(toId, rawTarget, { isExternal: true }));
+                }
+            }
+            else {
+                const normalized = normalizeUrl(rawTarget);
+                if (!normalized)
+                    continue; // relative / unparseable → can't reason, skip
+                const match = matchNavRoute(normalized, index);
+                if (match) {
+                    toId = match.routeNode.id;
+                    matchType = match.isDynamic ? "dynamic" : "exact";
+                }
+                else {
+                    toId = `[route]::${normalized}`;
+                    matchType = "unresolved";
+                    if (!existingIds.has(toId) && !ghostMap.has(toId)) {
+                        ghostMap.set(toId, makeGhostRoute(toId, normalized, { isUnresolved: true }));
+                    }
+                }
+            }
+            const dedupKey = `${owner.id}→${toId}:${loc.method}`;
+            if (dedupSet.has(dedupKey))
+                continue;
+            dedupSet.add(dedupKey);
+            edges.push({
+                from: owner.id,
+                to: toId,
+                type: "NAVIGATES_TO",
+                metadata: {
+                    path: rawTarget,
+                    rawPath: loc.rawUrl,
+                    method: loc.method,
+                    callerType: loc.callerType,
+                    matchType,
+                },
+            });
+        }
+    }
+    return { edges, ghostNodes: [...ghostMap.values()] };
+}

package/dist/graph/edges/routeEdge.js

@@ -45,6 +45,12 @@ export function detectRouteEdges(nodes, lookup) {
                 handlerNode = resolveDefaultExport(filePath, lookup);
             }
         }
+        else if (routeKind === "react-router") {
+            // React Router / TanStack: route renders a named component
+            // (<Route element={<Home/>}> / { component: Home }) — possibly imported
+            // from another file, so resolve by name.
+            handlerNode = resolveReactRouterComponent(routeNode, lookup);
+        }
         if (!handlerNode)
             continue;
         if (handlerNode.id === routeNode.id)
@@ -91,6 +97,25 @@ function resolveBackendHandler(routeNode, lookup) {
     // path segments with the route file
     return closestByPath(byName, filePath);
 }
+function resolveReactRouterComponent(routeNode, lookup) {
+    const componentName = routeNode.metadata.rendersComponent;
+    if (!componentName)
+        return undefined;
+    // Strategy 1 — component defined in the same file as the route definition
+    const nodesInFile = lookup.nodesByFile.get(routeNode.filePath) ?? [];
+    const sameFile = nodesInFile.find(n => n.name === componentName && (n.type === "COMPONENT" || n.type === "FUNCTION"));
+    if (sameFile)
+        return sameFile;
+    // Strategy 2 — component imported from another file, resolve by name.
+    // Prefer COMPONENT/FUNCTION nodes; if several match, pick the closest by path.
+    const byName = (lookup.nodesByName.get(componentName) ?? [])
+        .filter(n => n.type === "COMPONENT" || n.type === "FUNCTION");
+    if (byName.length === 0)
+        return undefined;
+    if (byName.length === 1)
+        return byName[0];
+    return closestByPath(byName, routeNode.filePath);
+}
 function resolveNextjsApiHandler(routeNode, lookup) {
     const httpMethod = routeNode.metadata.httpMethod;
     if (!httpMethod)