@vibecheckai/cli 3.5.1 → 3.5.2

package/bin/runners/lib/engine/extractors.js

@@ -0,0 +1,849 @@
+// bin/runners/lib/engine/extractors.js
+// Optimized route extractors that use RepoIndex and globalASTCache
+
+const path = require("path");
+const crypto = require("crypto");
+const traverse = require("@babel/traverse").default;
+const t = require("@babel/types");
+const { globalASTCache } = require("./ast-cache");
+
+// ---------- helpers ----------
+
+function sha256(text) {
+  return "sha256:" + crypto.createHash("sha256").update(text).digest("hex");
+}
+
+function canonicalizeMethod(m) {
+  const u = String(m || "").toUpperCase();
+  if (u === "ALL" || u === "ANY" || u === "*") return "*";
+  return u;
+}
+
+function stripQueryHash(s) {
+  const v = String(s || "");
+  const q = v.indexOf("?");
+  const h = v.indexOf("#");
+  const cut = q === -1 ? h : h === -1 ? q : Math.min(q, h);
+  return cut === -1 ? v : v.slice(0, cut);
+}
+
+function canonicalizePath(p) {
+  let s = stripQueryHash(String(p || "").trim());
+  const protoIdx = s.indexOf("://");
+  if (protoIdx !== -1) {
+    const slashAfterHost = s.indexOf("/", protoIdx + 3);
+    s = slashAfterHost === -1 ? "/" : s.slice(slashAfterHost);
+  }
+  if (!s.startsWith("/")) s = "/" + s;
+  s = s.replace(/\/+/g, "/");
+  s = s.replace(/\[\[\.{3}([^\]]+)\]\]/g, "*$1?");
+  s = s.replace(/\[\.{3}([^\]]+)\]/g, "*$1");
+  s = s.replace(/\[([^\]]+)\]/g, ":$1");
+  if (s.length > 1) s = s.replace(/\/$/, "");
+  return s;
+}
+
+function joinPaths(prefix, p) {
+  const a = canonicalizePath(prefix || "/");
+  const b = canonicalizePath(p || "/");
+  if (a === "/") return b;
+  if (b === "/") return a;
+  return canonicalizePath(a + "/" + b);
+}
+
+function evidenceFromContent(content, fileRel, loc, reason) {
+  if (!loc || !content) return null;
+  const lines = content.split(/\r?\n/);
+  const start = Math.max(1, loc.start?.line || 1);
+  const end = Math.max(start, loc.end?.line || start);
+  const snippet = lines.slice(start - 1, end).join("\n");
+  return {
+    id: `ev_${crypto.randomBytes(4).toString("hex")}`,
+    file: fileRel,
+    lines: `${start}-${end}`,
+    snippetHash: sha256(snippet),
+    reason,
+  };
+}
+
+function isRouteGroupSegment(seg) {
+  return seg.startsWith("(") && seg.endsWith(")");
+}
+
+function isParallelSegment(seg) {
+  return seg.startsWith("@");
+}
+
+// ---------- Next.js App Router ----------
+
+const HTTP_EXPORTS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"]);
+
+function nextAppApiPathFromRel(fileRel) {
+  const idx = fileRel.indexOf("app/api/");
+  if (idx === -1) return null;
+  let sub = fileRel.slice(idx + "app/api/".length);
+  sub = sub.replace(/\/route\.(ts|tsx|js|jsx)$/, "");
+  const parts = sub.split("/").filter(Boolean).filter((seg) => !isRouteGroupSegment(seg) && !isParallelSegment(seg));
+  sub = parts.join("/");
+  return canonicalizePath("/api/" + sub);
+}
+
+/**
+ * Extract Next.js App Router API routes using RepoIndex
+ * @param {import('./repo-index').RepoIndex} index
+ * @param {Object} stats
+ * @returns {Array}
+ */
+function extractNextAppRoutes(index, stats) {
+  // Get route files from index (already filtered)
+  const routeFiles = index.files.filter(f =>
+    f.rel.includes("/app/") &&
+    f.rel.includes("/api/") &&
+    /route\.(ts|tsx|js|jsx)$/.test(f.rel)
+  );
+
+  const out = [];
+
+  for (const file of routeFiles) {
+    const routePath = nextAppApiPathFromRel(file.rel);
+    if (!routePath) continue;
+
+    const content = index.getContent(file.abs);
+    if (!content) continue;
+
+    // Use shared AST cache
+    const { ast, error } = globalASTCache.parse(content, file.abs);
+    if (error || !ast) {
+      stats.parseErrors++;
+      continue;
+    }
+
+    const methods = [];
+
+    try {
+      traverse(ast, {
+        ExportNamedDeclaration(p) {
+          const decl = p.node.declaration;
+
+          if (t.isFunctionDeclaration(decl) && decl.id?.name) {
+            const n = decl.id.name.toUpperCase();
+            if (HTTP_EXPORTS.has(n)) methods.push({ method: n, loc: decl.loc, why: "export function" });
+          }
+
+          if (t.isVariableDeclaration(decl)) {
+            for (const d of decl.declarations) {
+              if (!t.isVariableDeclarator(d)) continue;
+              if (!t.isIdentifier(d.id)) continue;
+              const n = d.id.name.toUpperCase();
+              if (HTTP_EXPORTS.has(n)) methods.push({ method: n, loc: d.loc || decl.loc, why: "export const" });
+            }
+          }
+
+          for (const s of p.node.specifiers || []) {
+            if (!t.isExportSpecifier(s)) continue;
+            if (!t.isIdentifier(s.exported)) continue;
+            const n = s.exported.name.toUpperCase();
+            if (HTTP_EXPORTS.has(n)) methods.push({ method: n, loc: s.loc || p.node.loc, why: "export re-export" });
+          }
+        },
+      });
+    } catch {
+      stats.parseErrors++;
+      continue;
+    }
+
+    if (methods.length === 0) {
+      out.push({
+        method: "*",
+        path: routePath,
+        handler: file.rel,
+        confidence: "low",
+        framework: "next",
+        evidence: [],
+      });
+      continue;
+    }
+
+    for (const m of methods) {
+      const ev = evidenceFromContent(content, file.rel, m.loc, `Next app router ${m.method} (${m.why})`);
+      out.push({
+        method: m.method,
+        path: routePath,
+        handler: file.rel,
+        confidence: m.why === "export re-export" ? "med" : "high",
+        framework: "next",
+        evidence: ev ? [ev] : [],
+      });
+    }
+  }
+
+  return out;
+}
+
+// ---------- Next.js Pages Router ----------
+
+function nextPagesApiPathFromRel(fileRel) {
+  const idx = fileRel.indexOf("pages/api/");
+  if (idx === -1) return null;
+  let sub = fileRel.slice(idx + "pages/api/".length);
+  sub = sub.replace(/\.(ts|tsx|js|jsx)$/, "");
+  if (sub === "index") sub = "";
+  sub = sub.replace(/\/index$/, "");
+  return canonicalizePath("/api/" + sub);
+}
+
+/**
+ * Extract Next.js Pages Router API routes using RepoIndex
+ * @param {import('./repo-index').RepoIndex} index
+ * @param {Object} stats
+ * @returns {Array}
+ */
+function extractNextPagesRoutes(index, stats) {
+  const pagesFiles = index.files.filter(f =>
+    f.rel.includes("/pages/api/") &&
+    /\.(ts|tsx|js|jsx)$/.test(f.rel) &&
+    !f.rel.includes("/_")
+  );
+
+  const out = [];
+
+  for (const file of pagesFiles) {
+    const routePath = nextPagesApiPathFromRel(file.rel);
+    if (!routePath) continue;
+
+    const content = index.getContent(file.abs);
+    if (!content) continue;
+
+    const { ast, error } = globalASTCache.parse(content, file.abs);
+    if (error || !ast) {
+      stats.parseErrors++;
+      continue;
+    }
+
+    // Check for export default
+    let hasDefaultExport = false;
+    try {
+      traverse(ast, {
+        ExportDefaultDeclaration(p) {
+          hasDefaultExport = true;
+          p.stop();
+        },
+      });
+    } catch {
+      stats.parseErrors++;
+      continue;
+    }
+
+    if (!hasDefaultExport) continue;
+
+    out.push({
+      method: "*",
+      path: routePath,
+      handler: file.rel,
+      confidence: "med",
+      framework: "next",
+      evidence: [],
+    });
+  }
+
+  return out;
+}
+
+// ---------- Client Refs (fetch/axios/useSWR/useQuery) ----------
+
+function isAxiosMember(node) {
+  return (
+    t.isMemberExpression(node) &&
+    t.isIdentifier(node.object) &&
+    t.isIdentifier(node.property) &&
+    ["get", "post", "put", "patch", "delete"].includes(node.property.name)
+  );
+}
+
+function extractUrlLike(node) {
+  if (t.isStringLiteral(node)) return { url: node.value, confidence: "high", note: "string" };
+  if (t.isTemplateLiteral(node) && node.expressions.length === 0) {
+    return { url: node.quasis.map((q) => q.value.cooked || "").join(""), confidence: "high", note: "template_static" };
+  }
+  if (t.isTemplateLiteral(node) && node.quasis.length >= 1) {
+    const start = node.quasis[0]?.value?.cooked || "";
+    if (!start.startsWith("/")) return null;
+    let built = "";
+    for (let i = 0; i < node.quasis.length; i++) {
+      built += node.quasis[i].value.cooked || "";
+      if (i < node.expressions.length) {
+        const expr = node.expressions[i];
+        if (t.isIdentifier(expr)) built += `:${expr.name}`;
+        else built += "*";
+      }
+    }
+    return { url: built, confidence: "med", note: "template_dynamic" };
+  }
+  if (t.isBinaryExpression(node, { operator: "+" })) {
+    if (t.isStringLiteral(node.left) && node.left.value.startsWith("/")) {
+      const left = node.left.value;
+      let right = "";
+      if (t.isStringLiteral(node.right)) right = node.right.value;
+      else if (t.isIdentifier(node.right)) right = `:${node.right.name}`;
+      else right = "*";
+      return { url: left + right, confidence: "low", note: "concat" };
+    }
+  }
+  return null;
+}
+
+function extractFetchMethodFromOptions(node) {
+  if (!t.isObjectExpression(node)) return "*";
+  for (const prop of node.properties) {
+    if (!t.isObjectProperty(prop)) continue;
+    const key = t.isIdentifier(prop.key) ? prop.key.name : t.isStringLiteral(prop.key) ? prop.key.value : null;
+    if (key === "method" && t.isStringLiteral(prop.value)) return canonicalizeMethod(prop.value.value);
+  }
+  return "*";
+}
+
+function extractAxiosConfig(node) {
+  if (!t.isObjectExpression(node)) return null;
+  let urlNode = null;
+  let methodNode = null;
+  for (const prop of node.properties) {
+    if (!t.isObjectProperty(prop)) continue;
+    const key = t.isIdentifier(prop.key) ? prop.key.name : t.isStringLiteral(prop.key) ? prop.key.value : null;
+    if (key === "url") urlNode = prop.value;
+    if (key === "method") methodNode = prop.value;
+  }
+  const urlInfo = urlNode ? extractUrlLike(urlNode) : null;
+  if (!urlInfo) return null;
+  const method = methodNode && t.isStringLiteral(methodNode) ? canonicalizeMethod(methodNode.value) : "*";
+  return { method, urlInfo };
+}
+
+/**
+ * Extract client route refs using RepoIndex (prefiltered)
+ * @param {import('./repo-index').RepoIndex} index
+ * @param {Object} stats
+ * @returns {Array}
+ */
+function extractClientRefs(index, stats) {
+  // Use token prefilter - only scan files that contain fetch/axios/useSWR/useQuery
+  const candidateAbs = index.getByAnyToken(["fetch(", "axios", "useSWR", "useQuery"]);
+  
+  // Filter to JS/TS files only
+  const jsExtensions = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+  const candidates = candidateAbs.filter(abs => {
+    const ext = path.extname(abs).toLowerCase();
+    return jsExtensions.has(ext);
+  });
+
+  // Filter out test files
+  const files = candidates.filter(abs => {
+    const rel = index.relPath(abs);
+    return !rel.includes("/test/") &&
+           !rel.includes("/tests/") &&
+           !rel.includes("/__tests__/") &&
+           !rel.includes(".test.") &&
+           !rel.includes(".spec.") &&
+           !rel.includes("/mocks/") &&
+           !rel.includes("/fixtures/");
+  });
+
+  const out = [];
+
+  for (const fileAbs of files) {
+    const fileRel = index.relPath(fileAbs);
+    const content = index.getContent(fileAbs);
+    if (!content) continue;
+
+    const { ast, error } = globalASTCache.parse(content, fileAbs);
+    if (error || !ast) {
+      stats.parseErrors++;
+      continue;
+    }
+
+    try {
+      traverse(ast, {
+        CallExpression(p) {
+          const callee = p.node.callee;
+
+          // fetch(url, opts)
+          if (t.isIdentifier(callee, { name: "fetch" })) {
+            const a0 = p.node.arguments[0];
+            const a1 = p.node.arguments[1];
+            const urlInfo = extractUrlLike(a0);
+            if (!urlInfo) return;
+            const url = urlInfo.url;
+            if (!url.startsWith("/")) return;
+            const method = extractFetchMethodFromOptions(a1);
+            const ev = evidenceFromContent(content, fileRel, p.node.loc, `Client fetch(${urlInfo.note}) "${stripQueryHash(url)}"`);
+            out.push({
+              method,
+              path: canonicalizePath(url),
+              source: fileRel,
+              confidence: urlInfo.confidence,
+              kind: "fetch",
+              evidence: ev ? [ev] : [],
+            });
+            return;
+          }
+
+          // axios.get("/api/x") etc
+          if (isAxiosMember(callee)) {
+            const verb = callee.property.name.toUpperCase();
+            const a0 = p.node.arguments[0];
+            const urlInfo = extractUrlLike(a0);
+            if (!urlInfo) return;
+            const url = urlInfo.url;
+            if (!url.startsWith("/")) return;
+            const ev = evidenceFromContent(content, fileRel, p.node.loc, `Client axios.${verb.toLowerCase()}(${urlInfo.note}) "${stripQueryHash(url)}"`);
+            out.push({
+              method: canonicalizeMethod(verb),
+              path: canonicalizePath(url),
+              source: fileRel,
+              confidence: urlInfo.confidence,
+              kind: "axios_member",
+              evidence: ev ? [ev] : [],
+            });
+            return;
+          }
+
+          // axios({ url, method })
+          if (t.isIdentifier(callee, { name: "axios" })) {
+            const a0 = p.node.arguments[0];
+            const cfg = extractAxiosConfig(a0);
+            if (!cfg) return;
+            const url = cfg.urlInfo.url;
+            if (!url.startsWith("/")) return;
+            const ev = evidenceFromContent(content, fileRel, p.node.loc, `Client axios(config:${cfg.urlInfo.note}) "${stripQueryHash(url)}"`);
+            out.push({
+              method: cfg.method,
+              path: canonicalizePath(url),
+              source: fileRel,
+              confidence: cfg.urlInfo.confidence === "high" ? "high" : "med",
+              kind: "axios_config",
+              evidence: ev ? [ev] : [],
+            });
+            return;
+          }
+
+          // useSWR("/api/user", fetcher)
+          if (t.isIdentifier(callee, { name: "useSWR" })) {
+            const a0 = p.node.arguments[0];
+            const urlInfo = extractUrlLike(a0);
+            if (!urlInfo) return;
+            const url = urlInfo.url;
+            if (!url.startsWith("/")) return;
+            const ev = evidenceFromContent(content, fileRel, p.node.loc, `Client useSWR(${urlInfo.note}) "${stripQueryHash(url)}"`);
+            out.push({
+              method: "GET",
+              path: canonicalizePath(url),
+              source: fileRel,
+              confidence: urlInfo.confidence,
+              kind: "useSWR",
+              evidence: ev ? [ev] : [],
+            });
+            return;
+          }
+
+          // useQuery
+          if (t.isIdentifier(callee, { name: "useQuery" })) {
+            const a0 = p.node.arguments[0];
+            if (t.isObjectExpression(a0)) {
+              for (const prop of a0.properties) {
+                if (!t.isObjectProperty(prop)) continue;
+                if (!t.isIdentifier(prop.key, { name: "queryFn" })) continue;
+                const fn = prop.value;
+                if (t.isArrowFunctionExpression(fn) || t.isFunctionExpression(fn)) {
+                  const fnCode = content.slice(fn.start, fn.end);
+                  const urlMatch = fnCode.match(/["'`](\/api\/[^"'`]+)["'`]/);
+                  if (urlMatch) {
+                    const url = urlMatch[1].split("?")[0].split("#")[0];
+                    const ev = evidenceFromContent(content, fileRel, p.node.loc, `Client useQuery(queryFn) "${url}"`);
+                    out.push({
+                      method: "GET",
+                      path: canonicalizePath(url),
+                      source: fileRel,
+                      confidence: "low",
+                      kind: "useQuery",
+                      evidence: ev ? [ev] : [],
+                    });
+                  }
+                }
+              }
+            }
+          }
+        },
+      });
+    } catch {
+      stats.parseErrors++;
+    }
+  }
+
+  return out;
+}
+
+// ---------- Fastify Routes ----------
+
+const FASTIFY_METHODS = new Set(["get", "post", "put", "patch", "delete", "options", "head", "all"]);
+
+function isFastifyMethod(name) {
+  return FASTIFY_METHODS.has(name);
+}
+
+/**
+ * Extract Fastify routes using RepoIndex
+ * @param {import('./repo-index').RepoIndex} index
+ * @param {string} entryAbs - Entry file absolute path
+ * @param {Object} stats
+ * @returns {{ routes: Array, gaps: Array }}
+ */
+function extractFastifyRoutes(index, entryAbs, stats) {
+  const seen = new Set();
+  const routes = [];
+  const gaps = [];
+
+  function scanFile(fileAbs, prefix) {
+    if (!fileAbs || seen.has(fileAbs)) return;
+    seen.add(fileAbs);
+
+    const fileRel = index.relPath(fileAbs);
+    const content = index.getContent(fileAbs);
+    if (!content) return;
+
+    const { ast, error } = globalASTCache.parse(content, fileAbs);
+    if (error || !ast) {
+      stats.parseErrors++;
+      return;
+    }
+
+    const fastifyNames = new Set(["fastify"]);
+    const _rawConstInits = new Map();
+    const _constStrings = new Map();
+    const _localPlugins = new Map();
+
+    function evalStaticString(node, depth = 0) {
+      if (!node || depth > 6) return null;
+      if (t.isStringLiteral(node)) return node.value;
+      if (t.isTemplateLiteral(node) && node.expressions.length === 0) {
+        return node.quasis.map((q) => q.value.cooked || "").join("");
+      }
+      if (t.isIdentifier(node)) {
+        const name = node.name;
+        if (_constStrings.has(name)) return _constStrings.get(name);
+        const init = _rawConstInits.get(name);
+        if (!init) return null;
+        const v = evalStaticString(init, depth + 1);
+        if (typeof v === "string" && v.length <= 4096) {
+          _constStrings.set(name, v);
+          return v;
+        }
+        return null;
+      }
+      if (t.isBinaryExpression(node, { operator: "+" })) {
+        const l = evalStaticString(node.left, depth + 1);
+        const r = evalStaticString(node.right, depth + 1);
+        if (typeof l !== "string" || typeof r !== "string") return null;
+        return (l + r).length <= 4096 ? l + r : null;
+      }
+      return null;
+    }
+
+    function extractPrefixFromOpts(node) {
+      if (!t.isObjectExpression(node)) return null;
+      for (const p of node.properties) {
+        if (!t.isObjectProperty(p)) continue;
+        const key = t.isIdentifier(p.key) ? p.key.name : t.isStringLiteral(p.key) ? p.key.value : null;
+        if (key !== "prefix") continue;
+        return evalStaticString(p.value);
+      }
+      return null;
+    }
+
+    function extractRouteObject(objExpr) {
+      let url = null;
+      let methods = [];
+      let hasHandler = false;
+      const hooks = [];
+      for (const p of objExpr.properties) {
+        if (!t.isObjectProperty(p)) continue;
+        const key = t.isIdentifier(p.key) ? p.key.name : t.isStringLiteral(p.key) ? p.key.value : null;
+        if (!key) continue;
+        if (key === "url") {
+          const u = evalStaticString(p.value);
+          if (typeof u === "string") url = u;
+        }
+        if (key === "method") {
+          if (t.isStringLiteral(p.value)) methods = [p.value.value];
+          if (t.isArrayExpression(p.value)) {
+            methods = p.value.elements.filter((e) => t.isStringLiteral(e)).map((e) => e.value);
+          }
+        }
+        if (key === "handler") hasHandler = true;
+        if (["preHandler", "onRequest", "preValidation", "preSerialization"].includes(key)) hooks.push(key);
+      }
+      return { url, methods, hasHandler, hooks };
+    }
+
+    function unwrapPluginArg(node) {
+      if (!node || !t.isCallExpression(node)) return node;
+      const calleeName = t.isIdentifier(node.callee)
+        ? node.callee.name
+        : t.isMemberExpression(node.callee) && t.isIdentifier(node.callee.property)
+        ? node.callee.property.name
+        : null;
+      if (!calleeName || !/^(fp|fastifyPlugin|plugin|fastifyPluginify)$/i.test(calleeName)) return node;
+      return node.arguments?.[0] || node;
+    }
+
+    function resolveRelativeModule(fromFileAbs, spec) {
+      if (!spec || (!spec.startsWith("./") && !spec.startsWith("../"))) return null;
+      const base = path.resolve(path.dirname(fromFileAbs), spec);
+      const candidates = [base, base + ".ts", base + ".tsx", base + ".js", base + ".jsx",
+        path.join(base, "index.ts"), path.join(base, "index.tsx"), path.join(base, "index.js"), path.join(base, "index.jsx")];
+      for (const c of candidates) {
+        if (index.files.some(f => f.abs === c)) return c;
+        // Fall back to fs check for files not in index
+        try { require("fs").statSync(c).isFile() && candidates.push(c); } catch {}
+      }
+      for (const c of candidates) {
+        try { if (require("fs").statSync(c).isFile()) return c; } catch {}
+      }
+      return null;
+    }
+
+    function extractRequireOrImportSpec(node) {
+      if (t.isCallExpression(node) && t.isIdentifier(node.callee, { name: "require" })) {
+        const a0 = node.arguments?.[0];
+        if (t.isStringLiteral(a0)) return a0.value;
+      }
+      if (t.isCallExpression(node) && node.callee?.type === "Import") {
+        const a0 = node.arguments?.[0];
+        if (t.isStringLiteral(a0)) return a0.value;
+      }
+      if (t.isAwaitExpression(node)) return extractRequireOrImportSpec(node.argument);
+      return null;
+    }
+
+    try {
+      traverse(ast, {
+        FunctionDeclaration(p) {
+          if (t.isIdentifier(p.node.id)) _localPlugins.set(p.node.id.name, p.node);
+        },
+        VariableDeclarator(p) {
+          if (!t.isIdentifier(p.node.id)) return;
+          const id = p.node.id.name;
+          const init = p.node.init;
+          if (!init) return;
+          _rawConstInits.set(id, init);
+          if (t.isFunctionExpression(init) || t.isArrowFunctionExpression(init)) _localPlugins.set(id, init);
+          if (t.isCallExpression(init) && t.isIdentifier(init.callee)) {
+            if (init.callee.name === "Fastify" || init.callee.name === "fastify") fastifyNames.add(id);
+          }
+          if (t.isCallExpression(init) && t.isCallExpression(init.callee)) {
+            const inner = init.callee;
+            if (t.isIdentifier(inner.callee, { name: "require" }) && t.isStringLiteral(inner.arguments?.[0], { value: "fastify" })) {
+              fastifyNames.add(id);
+            }
+          }
+        },
+      });
+    } catch {}
+
+    function resolveImportSpecForLocal(localName) {
+      let spec = null;
+      try {
+        traverse(ast, {
+          ImportDeclaration(ip) {
+            for (const s of ip.node.specifiers) {
+              if ((t.isImportDefaultSpecifier(s) || t.isImportSpecifier(s)) && s.local.name === localName) {
+                spec = ip.node.source.value;
+              }
+            }
+          },
+          VariableDeclarator(vp) {
+            if (!t.isIdentifier(vp.node.id) || vp.node.id.name !== localName) return;
+            const init = vp.node.init;
+            if (!t.isCallExpression(init) || !t.isIdentifier(init.callee, { name: "require" })) return;
+            const a0 = init.arguments[0];
+            if (t.isStringLiteral(a0)) spec = a0.value;
+          },
+        });
+      } catch {}
+      return spec;
+    }
+
+    try {
+      traverse(ast, {
+        CallExpression(p) {
+          const callee = p.node.callee;
+          if (!t.isMemberExpression(callee)) return;
+          if (!t.isIdentifier(callee.object) || !t.isIdentifier(callee.property)) return;
+          const obj = callee.object.name;
+          const prop = callee.property.name;
+          if (!fastifyNames.has(obj)) return;
+
+          if (isFastifyMethod(prop)) {
+            const routeStr = evalStaticString(p.node.arguments[0]);
+            if (!routeStr) return;
+            const fullPath = joinPaths(prefix, routeStr);
+            const ev = evidenceFromContent(content, fileRel, p.node.loc, `Fastify ${prop.toUpperCase()}("${routeStr}")`);
+            routes.push({
+              method: canonicalizeMethod(prop),
+              path: fullPath,
+              handler: fileRel,
+              confidence: "med",
+              framework: "fastify",
+              evidence: ev ? [ev] : [],
+            });
+            return;
+          }
+
+          if (prop === "route") {
+            const arg0 = p.node.arguments[0];
+            if (!t.isObjectExpression(arg0)) return;
+            const r = extractRouteObject(arg0);
+            if (!r.url) return;
+            const fullPath = joinPaths(prefix, r.url);
+            const ms = (r.methods.length ? r.methods : ["*"]).map(canonicalizeMethod);
+            const ev = evidenceFromContent(content, fileRel, p.node.loc, `Fastify.route({ url: "${r.url}" })`);
+            for (const m of ms) {
+              routes.push({
+                method: m,
+                path: fullPath,
+                handler: fileRel,
+                hooks: r.hooks,
+                confidence: r.hasHandler ? "med" : "low",
+                framework: "fastify",
+                evidence: ev ? [ev] : [],
+              });
+            }
+            return;
+          }
+
+          if (prop === "register") {
+            const pluginArgRaw = unwrapPluginArg(p.node.arguments[0]);
+            const optsArg = p.node.arguments[1];
+            const childPrefixRaw = extractPrefixFromOpts(optsArg);
+            const childPrefix = childPrefixRaw ? joinPaths(prefix, childPrefixRaw) : prefix;
+
+            let pluginFn = null;
+            const localIdentName = t.isIdentifier(pluginArgRaw) ? pluginArgRaw.name : null;
+            if (t.isFunctionExpression(pluginArgRaw) || t.isArrowFunctionExpression(pluginArgRaw)) pluginFn = pluginArgRaw;
+            if (!pluginFn && localIdentName) pluginFn = _localPlugins.get(localIdentName) || null;
+
+            if (pluginFn) {
+              const param0 = pluginFn.params?.[0];
+              const innerName = t.isIdentifier(param0) ? param0.name : "fastify";
+              const bodyNode = pluginFn.body;
+              if (t.isBlockStatement(bodyNode)) {
+                try {
+                  traverse(bodyNode, {
+                    CallExpression(pp) {
+                      const c = pp.node.callee;
+                      if (!t.isMemberExpression(c) || !t.isIdentifier(c.object) || !t.isIdentifier(c.property)) return;
+                      if (c.object.name !== innerName) return;
+                      const pr = c.property.name;
+                      if (isFastifyMethod(pr)) {
+                        const rs = evalStaticString(pp.node.arguments[0]);
+                        if (!rs) return;
+                        const fp = joinPaths(childPrefix, rs);
+                        const ev = evidenceFromContent(content, fileRel, pp.node.loc, `Fastify plugin ${pr.toUpperCase()}("${rs}")`);
+                        routes.push({ method: canonicalizeMethod(pr), path: fp, handler: fileRel, confidence: "med", framework: "fastify", evidence: ev ? [ev] : [] });
+                      }
+                      if (pr === "route") {
+                        const a0 = pp.node.arguments[0];
+                        if (!t.isObjectExpression(a0)) return;
+                        const r = extractRouteObject(a0);
+                        if (!r.url) return;
+                        const fp = joinPaths(childPrefix, r.url);
+                        const ms = (r.methods.length ? r.methods : ["*"]).map(canonicalizeMethod);
+                        const ev = evidenceFromContent(content, fileRel, pp.node.loc, `Fastify plugin route("${r.url}")`);
+                        for (const m of ms) {
+                          routes.push({ method: m, path: fp, handler: fileRel, confidence: "med", framework: "fastify", evidence: ev ? [ev] : [] });
+                        }
+                      }
+                    },
+                  }, p.scope, p);
+                } catch {}
+              }
+              if (localIdentName) return;
+              return;
+            }
+
+            const dynSpec = extractRequireOrImportSpec(pluginArgRaw);
+            if (dynSpec) {
+              const resolved = resolveRelativeModule(fileAbs, dynSpec);
+              if (!resolved) {
+                gaps.push({ kind: "fastify_plugin_unresolved", file: fileRel, spec: dynSpec });
+                return;
+              }
+              scanFile(resolved, childPrefix);
+              return;
+            }
+
+            if (t.isIdentifier(pluginArgRaw)) {
+              const localName = pluginArgRaw.name;
+              const spec = resolveImportSpecForLocal(localName);
+              if (!spec) {
+                gaps.push({ kind: "fastify_plugin_unresolved", file: fileRel, name: localName });
+                return;
+              }
+              const resolved = resolveRelativeModule(fileAbs, spec);
+              if (!resolved) {
+                gaps.push({ kind: "fastify_plugin_unresolved", file: fileRel, spec });
+                return;
+              }
+              scanFile(resolved, childPrefix);
+              return;
+            }
+
+            gaps.push({ kind: "fastify_plugin_unresolved", file: fileRel, note: "register() plugin not statically resolvable" });
+          }
+        },
+      });
+    } catch {
+      stats.parseErrors++;
+    }
+  }
+
+  scanFile(entryAbs, "/");
+  return { routes, gaps };
+}
+
+/**
+ * Detect Fastify entry files using RepoIndex
+ * @param {import('./repo-index').RepoIndex} index
+ * @returns {string[]} - Array of absolute paths
+ */
+function detectFastifyEntries(index) {
+  if (!index.hasFramework("fastify")) return [];
+
+  // Use token prefilter
+  const fastifyFiles = index.getByAnyToken(["fastify", "Fastify"]);
+  
+  const fastifySignal = /\b(Fastify\s*\(|fastify\s*\(|require\(['"]fastify['"]\)|from\s+['"]fastify['"])\b/;
+  const listenSignal = /\.\s*(listen|ready)\s*\(/;
+
+  const entries = [];
+
+  for (const fileAbs of fastifyFiles) {
+    const content = index.getContent(fileAbs);
+    if (!content) continue;
+    if (fastifySignal.test(content) && listenSignal.test(content)) {
+      entries.push(fileAbs);
+    }
+  }
+
+  return Array.from(new Set(entries));
+}
+
+module.exports = {
+  extractNextAppRoutes,
+  extractNextPagesRoutes,
+  extractClientRefs,
+  extractFastifyRoutes,
+  detectFastifyEntries,
+  // Helpers exported for testing
+  canonicalizeMethod,
+  canonicalizePath,
+  joinPaths,
+};