@route-intelligence/next 2.1.0

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import { Condition, RouteGraphLike, FrameworkPlugin } from '@route-intelligence/shared';
+import { SourceFile } from 'ts-morph';
+
+interface MiddlewareAnalysis {
+    matchers: string[];
+    redirects: Array<{
+        path: string;
+        conditions: Condition[];
+    }>;
+    rewrites: Array<{
+        path: string;
+        conditions: Condition[];
+    }>;
+    conditions: Condition[];
+}
+declare function analyzeMiddlewareFile(sourceFile: SourceFile, filePath: string): MiddlewareAnalysis;
+declare function applyMiddlewareToGraph(graph: RouteGraphLike, middlewareId: string, analysis: MiddlewareAnalysis): void;
+
+interface NextPluginOptions {
+    appDir?: string;
+    pagesDir?: string;
+    srcDir?: string;
+    basePath?: string;
+    customNavigationWrappers?: string[];
+}
+declare function createNextAppRouterPlugin(options?: NextPluginOptions): FrameworkPlugin;
+declare function createNextPagesRouterPlugin(options?: NextPluginOptions): FrameworkPlugin;
+declare function NextPlugin(options?: NextPluginOptions): FrameworkPlugin;
+
+export { NextPlugin, type NextPluginOptions, type NextPluginOptions as NextPluginOptionsType, analyzeMiddlewareFile, applyMiddlewareToGraph, createNextAppRouterPlugin, createNextPagesRouterPlugin };

package/dist/index.js

@@ -0,0 +1,694 @@
+// src/index.ts
+import { existsSync, readdirSync, statSync } from "fs";
+import { basename, dirname, join, relative, sep } from "path";
+import { createDefaultEdgeAttributes as createDefaultEdgeAttributes2 } from "@route-intelligence/shared";
+import { Project } from "ts-morph";
+
+// src/middleware.ts
+import { createDefaultEdgeAttributes } from "@route-intelligence/shared";
+import picomatch from "picomatch";
+import { Node } from "ts-morph";
+function analyzeMiddlewareFile(sourceFile, filePath) {
+  const matchers = [];
+  const redirects = [];
+  const rewrites = [];
+  const conditions = [];
+  sourceFile.forEachDescendant((node) => {
+    if (Node.isPropertyAssignment(node) && node.getName() === "matcher") {
+      const init = node.getInitializer();
+      if (init && Node.isArrayLiteralExpression(init)) {
+        for (const el of init.getElements()) {
+          if (Node.isStringLiteral(el)) {
+            matchers.push(el.getLiteralText());
+          }
+        }
+      } else if (init && Node.isStringLiteral(init)) {
+        matchers.push(init.getLiteralText());
+      }
+    }
+    if (Node.isCallExpression(node)) {
+      const expr = node.getExpression();
+      if (Node.isPropertyAccessExpression(expr)) {
+        const obj = expr.getExpression().getText();
+        const method = expr.getName();
+        if (obj === "NextResponse" && (method === "redirect" || method === "rewrite")) {
+          const args = node.getArguments();
+          const pathArg = args[0];
+          if (pathArg && Node.isStringLiteral(pathArg)) {
+            const path = pathArg.getLiteralText();
+            const conds = extractSurroundingConditions(node);
+            if (method === "redirect") {
+              redirects.push({ path, conditions: conds });
+            } else {
+              rewrites.push({ path, conditions: conds });
+            }
+          }
+        }
+      }
+    }
+    if (Node.isCallExpression(node)) {
+      const callee = node.getExpression().getText();
+      if (callee.includes("cookies") || callee.includes("headers")) {
+        conditions.push({
+          kind: callee.includes("cookies") ? "cookie" : "header",
+          expression: node.getText(),
+          negated: false,
+          confidence: "inferred"
+        });
+      }
+    }
+  });
+  if (matchers.length === 0) {
+    matchers.push("/:path*");
+  }
+  return { matchers, redirects, rewrites, conditions };
+}
+function extractSurroundingConditions(node) {
+  let current = node;
+  const conditions = [];
+  while (current) {
+    const parent = current.getParent();
+    if (!parent) break;
+    if (Node.isIfStatement(parent)) {
+      conditions.push({
+        kind: inferKind(parent.getExpression().getText()),
+        expression: parent.getExpression().getText(),
+        negated: false,
+        confidence: "inferred"
+      });
+    }
+    current = parent;
+  }
+  return conditions;
+}
+function inferKind(expr) {
+  const lower = expr.toLowerCase();
+  if (lower.includes("jwt") || lower.includes("token")) return "auth";
+  if (lower.includes("role")) return "role";
+  if (lower.includes("permission")) return "permission";
+  return "unknown";
+}
+function applyMiddlewareToGraph(graph, middlewareId, analysis) {
+  for (const matcher of analysis.matchers) {
+    const isMatch = picomatch(matcher);
+    for (const nodeId of graph.getAllNodeIds()) {
+      const path = graph.getNodePath(nodeId);
+      if (!path || nodeId === middlewareId) continue;
+      if (isMatch(path) || matcher === "/:path*") {
+        graph.addEdge(
+          `middleware-match:${middlewareId}->${nodeId}:${matcher}`,
+          middlewareId,
+          nodeId,
+          createDefaultEdgeAttributes({
+            type: "middleware-match",
+            source: "unknown",
+            conditions: analysis.conditions
+          })
+        );
+      }
+    }
+  }
+  for (const redirect of analysis.redirects) {
+    const targetId = graph.findNodeByPath(redirect.path);
+    if (targetId) {
+      graph.addEdge(
+        `middleware-redirect:${middlewareId}->${targetId}`,
+        middlewareId,
+        targetId,
+        createDefaultEdgeAttributes({
+          type: "redirect",
+          source: "NextResponse.redirect",
+          conditions: redirect.conditions
+        })
+      );
+    }
+  }
+  for (const rewrite of analysis.rewrites) {
+    const targetId = graph.findNodeByPath(rewrite.path);
+    if (targetId) {
+      graph.addEdge(
+        `middleware-rewrite:${middlewareId}->${targetId}`,
+        middlewareId,
+        targetId,
+        createDefaultEdgeAttributes({
+          type: "rewrite",
+          source: "NextResponse.rewrite",
+          conditions: rewrite.conditions
+        })
+      );
+    }
+  }
+}
+
+// src/index.ts
+var APP_FILE_CONVENTIONS = {
+  "page.tsx": "route",
+  "page.ts": "route",
+  "page.jsx": "route",
+  "page.js": "route",
+  "layout.tsx": "layout",
+  "layout.ts": "layout",
+  "layout.jsx": "layout",
+  "layout.js": "layout",
+  "template.tsx": "template",
+  "template.ts": "template",
+  "loading.tsx": "loading",
+  "loading.ts": "loading",
+  "error.tsx": "error",
+  "error.ts": "error",
+  "global-error.tsx": "global-error",
+  "global-error.ts": "global-error",
+  "not-found.tsx": "not-found",
+  "not-found.ts": "not-found",
+  "forbidden.tsx": "forbidden",
+  "forbidden.ts": "forbidden",
+  "unauthorized.tsx": "unauthorized",
+  "unauthorized.ts": "unauthorized",
+  "route.ts": "api-route",
+  "route.js": "api-route"
+};
+var INTERCEPT_PATTERNS = [
+  { prefix: "(.)", level: "." },
+  { prefix: "(..)(..)", level: "(..)(..)" },
+  { prefix: "(..)", level: ".." },
+  { prefix: "(...)", level: "..." }
+];
+function resolveAppDir(root, options) {
+  const candidates = [
+    options.appDir ? join(root, options.appDir) : null,
+    join(root, "src", "app"),
+    join(root, "app")
+  ].filter(Boolean);
+  return candidates.find((c) => existsSync(c)) ?? null;
+}
+function resolvePagesDir(root, options) {
+  const candidates = [
+    options.pagesDir ? join(root, options.pagesDir) : null,
+    join(root, "src", "pages"),
+    join(root, "pages")
+  ].filter(Boolean);
+  return candidates.find((c) => existsSync(c)) ?? null;
+}
+function parseSegment(segment) {
+  if (segment.startsWith("(") && segment.endsWith(")")) {
+    return {
+      segment,
+      isDynamic: false,
+      isCatchAll: false,
+      isOptionalCatchAll: false,
+      isRouteGroup: true,
+      groupName: segment.slice(1, -1),
+      isParallelSlot: false,
+      isIntercepted: false
+    };
+  }
+  if (segment.startsWith("@")) {
+    return {
+      segment,
+      isDynamic: false,
+      isCatchAll: false,
+      isOptionalCatchAll: false,
+      isRouteGroup: false,
+      isParallelSlot: true,
+      slotName: segment.slice(1),
+      isIntercepted: false
+    };
+  }
+  for (const { prefix, level } of INTERCEPT_PATTERNS) {
+    if (segment.startsWith(prefix)) {
+      return {
+        segment,
+        isDynamic: false,
+        isCatchAll: false,
+        isOptionalCatchAll: false,
+        isRouteGroup: false,
+        isParallelSlot: false,
+        isIntercepted: true,
+        interceptLevel: level
+      };
+    }
+  }
+  const optionalCatchAll = segment.match(/^\[\[\.\.\.(.+)\]\]$/);
+  if (optionalCatchAll) {
+    return {
+      segment: optionalCatchAll[1] ?? segment,
+      isDynamic: true,
+      isCatchAll: true,
+      isOptionalCatchAll: true,
+      isRouteGroup: false,
+      isParallelSlot: false,
+      isIntercepted: false
+    };
+  }
+  const catchAll = segment.match(/^\[\.\.\.(.+)\]$/);
+  if (catchAll) {
+    return {
+      segment: catchAll[1] ?? segment,
+      isDynamic: true,
+      isCatchAll: true,
+      isOptionalCatchAll: false,
+      isRouteGroup: false,
+      isParallelSlot: false,
+      isIntercepted: false
+    };
+  }
+  const dynamic = segment.match(/^\[(.+)\]$/);
+  if (dynamic) {
+    return {
+      segment: dynamic[1] ?? segment,
+      isDynamic: true,
+      isCatchAll: false,
+      isOptionalCatchAll: false,
+      isRouteGroup: false,
+      isParallelSlot: false,
+      isIntercepted: false
+    };
+  }
+  return {
+    segment,
+    isDynamic: false,
+    isCatchAll: false,
+    isOptionalCatchAll: false,
+    isRouteGroup: false,
+    isParallelSlot: false,
+    isIntercepted: false
+  };
+}
+function segmentsToUrlPath(segments, basePath = "") {
+  const urlSegments = [];
+  for (const seg of segments) {
+    const parsed = parseSegment(seg);
+    if (parsed.isRouteGroup) continue;
+    if (parsed.isParallelSlot) continue;
+    if (parsed.isIntercepted) {
+      const name = seg.replace(/^\(\.\)+|\(\.\.\)\(\.\.\)|\(\.\.\)|\(\.\.\.\)/, "");
+      urlSegments.push(name);
+      continue;
+    }
+    if (parsed.isOptionalCatchAll) {
+      urlSegments.push(`[[...${parsed.segment}]]`);
+    } else if (parsed.isCatchAll) {
+      urlSegments.push(`[...${parsed.segment}]`);
+    } else if (parsed.isDynamic) {
+      urlSegments.push(`[${parsed.segment}]`);
+    } else {
+      urlSegments.push(parsed.segment);
+    }
+  }
+  const path = `/${urlSegments.join("/")}`;
+  return basePath ? `${basePath}${path === "/" ? "" : path}` : path || "/";
+}
+function walkAppDirectory(dir, appRoot, basePath) {
+  const routes = [];
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return routes;
+  }
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    const isDir = statSync(fullPath).isDirectory();
+    if (isDir) {
+      routes.push(...walkAppDirectory(fullPath, appRoot, basePath));
+      continue;
+    }
+    const routeType = APP_FILE_CONVENTIONS[entry];
+    if (!routeType) continue;
+    const relDir = relative(appRoot, dir);
+    const segments = relDir ? relDir.split(sep) : [];
+    const allSegments = [...segments];
+    const urlPath = segmentsToUrlPath(allSegments, basePath);
+    const lastSegment = allSegments[allSegments.length - 1] ?? "";
+    const parsed = lastSegment ? parseSegment(lastSegment) : parseSegment("");
+    const id = `app:${allSegments.join("/")}:${entry}`;
+    routes.push({
+      id,
+      type: routeType,
+      filePath: fullPath,
+      urlPath: routeType === "route" || routeType === "api-route" ? urlPath : `${urlPath}#${routeType}`,
+      segment: parsed.segment,
+      isDynamic: parsed.isDynamic,
+      isCatchAll: parsed.isCatchAll,
+      isOptionalCatchAll: parsed.isOptionalCatchAll,
+      isParallelSlot: parsed.isParallelSlot,
+      slotName: parsed.slotName,
+      isIntercepted: parsed.isIntercepted,
+      interceptLevel: parsed.interceptLevel,
+      isRouteGroup: parsed.isRouteGroup,
+      groupName: parsed.groupName,
+      tags: ["next", "app-router"]
+    });
+  }
+  return routes;
+}
+function resolveParentLayout(segments, routes) {
+  for (let i = segments.length; i >= 0; i--) {
+    const parentSegments = segments.slice(0, i);
+    const layoutId = `app:${parentSegments.join("/")}:/layout.tsx`;
+    if (routes.some((r) => r.id.startsWith(`app:${parentSegments.join("/")}:`) && r.type === "layout")) {
+      const layout = routes.find(
+        (r) => r.type === "layout" && r.id === `app:${parentSegments.join("/")}:/layout.tsx` || r.id.includes("layout") && r.filePath.includes(parentSegments.join(sep))
+      );
+      if (layout) return layout.id;
+    }
+  }
+  return void 0;
+}
+function createNextAppRouterPlugin(options = {}) {
+  const opts = { appDir: "app", basePath: "", ...options };
+  return {
+    id: "next-app-router",
+    name: "Next.js App Router",
+    version: "0.1.0",
+    capabilities: {
+      supportsAppRouter: true,
+      supportsPagesRouter: false,
+      supportsMiddleware: true,
+      supportsApiRoutes: true,
+      supportsI18n: true,
+      supportsIncrementalAnalysis: true
+    },
+    async detect(ctx) {
+      return resolveAppDir(ctx.root, opts) !== null;
+    },
+    async configure(ctx) {
+      const appDir = resolveAppDir(ctx.root, opts);
+      return {
+        appDir,
+        basePath: opts.basePath,
+        customNavigationWrappers: opts.customNavigationWrappers ?? []
+      };
+    },
+    async *discoverRoutes(ctx) {
+      const appDir = resolveAppDir(ctx.root, opts);
+      if (!appDir) return;
+      const routes = walkAppDirectory(appDir, appDir, opts.basePath ?? "");
+      const middlewarePath = [
+        join(ctx.root, "middleware.ts"),
+        join(ctx.root, "middleware.js"),
+        join(ctx.root, "src", "middleware.ts")
+      ].find((p) => existsSync(p));
+      if (middlewarePath) {
+        routes.push({
+          id: "middleware:main",
+          type: "middleware",
+          filePath: middlewarePath,
+          urlPath: "/*",
+          segment: "*",
+          isDynamic: false,
+          isCatchAll: true,
+          isOptionalCatchAll: false,
+          isParallelSlot: false,
+          isIntercepted: false,
+          isRouteGroup: false,
+          tags: ["next", "middleware"]
+        });
+      }
+      for (const route of routes) {
+        const relDir = relative(appDir, dirname(route.filePath));
+        const segments = relDir === "." ? [] : relDir.split(sep);
+        route.parentLayoutId = resolveParentLayout(segments, routes);
+        yield route;
+      }
+    },
+    async analyzeFile(file, ctx) {
+      const edges = [];
+      const sourceId = findRouteIdForFile(file.path, ctx);
+      for (const link of file.jsxLinks) {
+        const targetPath = destinationToPath(link.destination);
+        edges.push({
+          sourceId: sourceId ?? "",
+          targetPath,
+          type: link.prefetch === false ? "navigation" : "prefetch",
+          source: "Link",
+          isExternal: link.destination.kind === "external",
+          conditions: link.conditions,
+          loc: link.loc
+        });
+      }
+      for (const call of file.navigationCalls) {
+        const targetPath = destinationToPath(call.destination);
+        let edgeType = "navigation";
+        let source = "unknown";
+        if (call.callee === "redirect") {
+          edgeType = "redirect";
+          source = "redirect";
+        } else if (call.callee === "permanentRedirect") {
+          edgeType = "permanent-redirect";
+          source = "permanentRedirect";
+        } else if (call.callee.includes("NextResponse.redirect")) {
+          edgeType = "redirect";
+          source = "NextResponse.redirect";
+        } else if (call.callee.includes("NextResponse.rewrite")) {
+          edgeType = "rewrite";
+          source = "NextResponse.rewrite";
+        } else if (call.callee.startsWith("router.")) {
+          source = call.callee;
+          edgeType = call.callee.includes("prefetch") ? "prefetch" : "navigation";
+        } else if (call.callee === "window.location") {
+          source = "window.location";
+        } else if (call.callee === "window.open") {
+          source = "window.open";
+        } else if (call.callee.startsWith("history.")) {
+          source = call.callee;
+        }
+        edges.push({
+          sourceId: sourceId ?? "",
+          targetPath,
+          type: edgeType,
+          source,
+          method: call.method,
+          isExternal: call.destination.kind === "external",
+          conditions: call.conditions,
+          loc: call.loc
+        });
+      }
+      return {
+        filePath: file.path,
+        edges,
+        conditions: file.conditionalBlocks.flatMap((b) => b.conditions),
+        tags: [],
+        diagnostics: []
+      };
+    },
+    async enrichGraph(graph, ctx) {
+      await enrichMiddlewareGraph(graph, ctx);
+      await enrichLayoutHierarchy(graph, ctx);
+    },
+    async runDiagnostics(graph) {
+      const diags = [];
+      for (const nodeId of graph.getAllNodeIds()) {
+        const path = graph.getNodePath(nodeId);
+        if (!path) continue;
+        const dynamicRoutes = graph.getAllNodeIds().filter((id) => {
+          const p = graph.getNodePath(id);
+          return p?.includes("[") && graph.getNodePath(id) === path;
+        });
+        if (dynamicRoutes.length > 1) {
+          diags.push({
+            ruleId: "shadowed-route",
+            severity: "warning",
+            message: `Route "${path}" may shadow another route`,
+            nodeId
+          });
+        }
+      }
+      return diags;
+    }
+  };
+}
+function destinationToPath(dest) {
+  switch (dest.kind) {
+    case "static":
+      return dest.path;
+    case "template-literal":
+      return dest.template.replace(/\$\{[^}]+\}/g, "[param]");
+    case "external":
+      return dest.url;
+    case "dynamic":
+      return void 0;
+    default: {
+      const _exhaustive = dest;
+      return _exhaustive;
+    }
+  }
+}
+function findRouteIdForFile(filePath, ctx) {
+  for (const [id, route] of ctx.routes) {
+    if (route.filePath === filePath) return id;
+  }
+  return void 0;
+}
+async function enrichMiddlewareGraph(graph, ctx) {
+  const middlewareId = graph.getAllNodeIds().find((id) => id.startsWith("middleware:"));
+  if (!middlewareId) return;
+  const middlewarePaths = [
+    join(ctx.root, "middleware.ts"),
+    join(ctx.root, "middleware.js"),
+    join(ctx.root, "src", "middleware.ts")
+  ];
+  const middlewarePath = middlewarePaths.find((p) => existsSync(p));
+  if (!middlewarePath) return;
+  try {
+    const project = new Project({ skipAddingFilesFromTsConfig: true });
+    const sourceFile = project.addSourceFileAtPath(middlewarePath);
+    const analysis = analyzeMiddlewareFile(sourceFile, middlewarePath);
+    applyMiddlewareToGraph(graph, middlewareId, analysis);
+  } catch {
+    for (const nodeId of graph.getAllNodeIds()) {
+      const path = graph.getNodePath(nodeId);
+      if (!path || nodeId === middlewareId) continue;
+      graph.addEdge(
+        `middleware-match:${middlewareId}->${nodeId}`,
+        middlewareId,
+        nodeId,
+        createDefaultEdgeAttributes2({
+          type: "middleware-match",
+          source: "unknown"
+        })
+      );
+    }
+  }
+}
+async function enrichLayoutHierarchy(graph, _ctx) {
+}
+function createNextPagesRouterPlugin(options = {}) {
+  const opts = { pagesDir: "pages", basePath: "", ...options };
+  return {
+    id: "next-pages-router",
+    name: "Next.js Pages Router",
+    version: "0.1.0",
+    capabilities: {
+      supportsAppRouter: false,
+      supportsPagesRouter: true,
+      supportsMiddleware: true,
+      supportsApiRoutes: true,
+      supportsI18n: false,
+      supportsIncrementalAnalysis: true
+    },
+    async detect(ctx) {
+      return resolvePagesDir(ctx.root, opts) !== null;
+    },
+    async configure(ctx) {
+      return {
+        pagesDir: resolvePagesDir(ctx.root, opts),
+        basePath: opts.basePath
+      };
+    },
+    async *discoverRoutes(ctx) {
+      const pagesDir = resolvePagesDir(ctx.root, opts);
+      if (!pagesDir) return;
+      const { readdirSync: readdirSync2, statSync: statSync2 } = await import("fs");
+      function walk(dir, segments = []) {
+        const routes = [];
+        for (const entry of readdirSync2(dir)) {
+          const fullPath = join(dir, entry);
+          if (statSync2(fullPath).isDirectory()) {
+            routes.push(...walk(fullPath, [...segments, entry]));
+            continue;
+          }
+          const ext = entry.replace(/^(index)?\.(tsx|ts|jsx|js)$/, "");
+          if (!/\.(tsx|ts|jsx|js)$/.test(entry)) continue;
+          if (entry.startsWith("_")) continue;
+          const isApi = segments[0] === "api";
+          const fileName = basename(entry, entry.slice(entry.lastIndexOf(".")));
+          const urlSegments = [...segments];
+          if (fileName !== "index") urlSegments.push(fileName);
+          const urlPath = pagesPathToUrl(urlSegments, opts.basePath ?? "", isApi);
+          routes.push({
+            id: `pages:${urlSegments.join("/")}:${entry}`,
+            type: isApi ? "api-route" : "route",
+            filePath: fullPath,
+            urlPath,
+            segment: urlSegments[urlSegments.length - 1] ?? "",
+            isDynamic: urlSegments.some((s) => s.startsWith("[")),
+            isCatchAll: urlSegments.some((s) => s.startsWith("[...")),
+            isOptionalCatchAll: false,
+            isParallelSlot: false,
+            isIntercepted: false,
+            isRouteGroup: false,
+            tags: ["next", "pages-router"]
+          });
+        }
+        return routes;
+      }
+      for (const route of walk(pagesDir)) {
+        yield route;
+      }
+    },
+    async analyzeFile(file, ctx) {
+      const appPlugin = createNextAppRouterPlugin(opts);
+      return appPlugin.analyzeFile(file, ctx);
+    },
+    async enrichGraph(graph, ctx) {
+      await enrichMiddlewareGraph(graph, ctx);
+    },
+    async runDiagnostics() {
+      return [];
+    }
+  };
+}
+function pagesPathToUrl(segments, basePath, isApi) {
+  const mapped = segments.map((s) => {
+    if (s.startsWith("[...") && s.endsWith("]")) return `[...${s.slice(4, -1)}]`;
+    if (s.startsWith("[") && s.endsWith("]")) return s;
+    return s;
+  });
+  const prefix = isApi ? "" : "";
+  const path = `/${mapped.join("/")}`;
+  const full = `${prefix}${path}`.replace(/\/index$/, "") || "/";
+  return basePath ? `${basePath}${full === "/" ? "" : full}` : full;
+}
+function NextPlugin(options = {}) {
+  const appPlugin = createNextAppRouterPlugin(options);
+  const pagesPlugin = createNextPagesRouterPlugin(options);
+  return {
+    id: "next",
+    name: "Next.js",
+    version: "0.1.0",
+    capabilities: {
+      supportsAppRouter: true,
+      supportsPagesRouter: true,
+      supportsMiddleware: true,
+      supportsApiRoutes: true,
+      supportsI18n: true,
+      supportsIncrementalAnalysis: true
+    },
+    async detect(ctx) {
+      return await appPlugin.detect(ctx) || await pagesPlugin.detect(ctx);
+    },
+    async configure(ctx) {
+      const appConfig = await appPlugin.configure(ctx);
+      const pagesConfig = await pagesPlugin.configure(ctx);
+      return { ...appConfig, ...pagesConfig, ...options };
+    },
+    async *discoverRoutes(ctx) {
+      if (await appPlugin.detect(ctx)) {
+        yield* appPlugin.discoverRoutes(ctx);
+      }
+      if (await pagesPlugin.detect(ctx)) {
+        yield* pagesPlugin.discoverRoutes(ctx);
+      }
+    },
+    async analyzeFile(file, ctx) {
+      return appPlugin.analyzeFile(file, ctx);
+    },
+    async enrichGraph(graph, ctx) {
+      await appPlugin.enrichGraph(graph, ctx);
+      await pagesPlugin.enrichGraph(graph, ctx);
+    },
+    async runDiagnostics(graph) {
+      const appDiags = await appPlugin.runDiagnostics(graph);
+      const pagesDiags = await pagesPlugin.runDiagnostics(graph);
+      return [...appDiags, ...pagesDiags];
+    }
+  };
+}
+export {
+  NextPlugin,
+  analyzeMiddlewareFile,
+  applyMiddlewareToGraph,
+  createNextAppRouterPlugin,
+  createNextPagesRouterPlugin
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@route-intelligence/next",
+  "version": "2.1.0",
+  "description": "Next.js plugin for Route Intelligence",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "development": "./src/index.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests"
+  },
+  "dependencies": {
+    "@route-intelligence/core": "*",
+    "@route-intelligence/shared": "*",
+    "fast-glob": "^3.3.3",
+    "picomatch": "^4.0.2",
+    "ts-morph": "^25.0.1"
+  },
+  "devDependencies": {
+    "@route-intelligence/tsconfig": "*",
+    "@types/node": "^22.15.32",
+    "@types/picomatch": "^4.0.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}