@vibecheckai/cli 3.2.2 → 3.2.4

package/bin/runners/lib/extractors/fastify-routes.js

@@ -1,426 +1,426 @@
-/**
- * Fastify Route Extractor v2
- * 
- * Spec-compliant extraction with prefix stacking and autoload support.
- * Two-tier approach: static AST extraction + optional runtime introspection.
- * 
- * Patterns supported:
- * - fastify.route({ method, url, handler })
- * - fastify.get/post/put/patch/delete(path, handler)
- * - fastify.register(plugin, { prefix })
- * - AutoLoad with dir resolution
- */
-
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const fg = require("fast-glob");
-const crypto = require("crypto");
-
-const FASTIFY_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD", "ALL"];
-
-/**
- * Detect Fastify service and entrypoint
- */
-function detectFastify(projectRoot) {
-  const result = {
-    present: false,
-    entryFile: null,
-    prefixes: [],
-  };
-
-  // Check package.json for fastify dependency
-  const pkgPath = path.join(projectRoot, "package.json");
-  if (fs.existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-      if (pkg.dependencies?.fastify || pkg.devDependencies?.fastify) {
-        result.present = true;
-      }
-
-      // Try to find entry from scripts
-      const scripts = pkg.scripts || {};
-      for (const [name, cmd] of Object.entries(scripts)) {
-        if (name === "start" || name === "dev" || name === "server") {
-          const entryMatch = cmd.match(/(?:node|tsx|ts-node|npx\s+tsx?)\s+([^\s]+)/);
-          if (entryMatch) {
-            const entryPath = path.join(projectRoot, entryMatch[1]);
-            if (fs.existsSync(entryPath)) {
-              result.entryFile = entryMatch[1];
-            }
-          }
-        }
-      }
-    } catch {}
-  }
-
-  // Fallback: search common entry files
-  if (!result.entryFile) {
-    const commonEntries = [
-      "server.ts", "server.js",
-      "src/server.ts", "src/server.js",
-      "app.ts", "app.js",
-      "src/app.ts", "src/app.js",
-      "index.ts", "index.js",
-      "src/index.ts", "src/index.js",
-    ];
-
-    for (const entry of commonEntries) {
-      const entryPath = path.join(projectRoot, entry);
-      if (fs.existsSync(entryPath)) {
-        const content = fs.readFileSync(entryPath, "utf8");
-        if (/from\s+['"]fastify['"]|require\s*\(\s*['"]fastify['"]\s*\)/.test(content)) {
-          result.entryFile = entry;
-          result.present = true;
-          break;
-        }
-      }
-    }
-  }
-
-  return result;
-}
-
-/**
- * Extract routes from Fastify project using static AST analysis
- */
-function extractFastifyRoutes(projectRoot, entryFile = null) {
-  const detection = detectFastify(projectRoot);
-  
-  if (!detection.present) {
-    return {
-      present: false,
-      entryFile: null,
-      routes: [],
-      prefixes: [],
-      autoloadDirs: [],
-      gaps: [],
-    };
-  }
-
-  const entry = entryFile || detection.entryFile;
-  const routes = [];
-  const prefixes = new Set();
-  const autoloadDirs = [];
-  const gaps = [];
-  const visited = new Set();
-
-  // Start extraction from entry file
-  if (entry) {
-    const entryPath = path.join(projectRoot, entry);
-    if (fs.existsSync(entryPath)) {
-      extractFromFile(entryPath, projectRoot, "", routes, prefixes, autoloadDirs, gaps, visited);
-    }
-  }
-
-  // Also scan common route directories
-  const routeDirs = ["routes", "src/routes", "api", "src/api"];
-  for (const dir of routeDirs) {
-    const dirPath = path.join(projectRoot, dir);
-    if (fs.existsSync(dirPath)) {
-      scanRouteDirectory(dirPath, projectRoot, "", routes, prefixes, gaps, visited);
-    }
-  }
-
-  return {
-    present: true,
-    entryFile: entry,
-    routes,
-    prefixes: [...prefixes],
-    autoloadDirs,
-    gaps,
-  };
-}
-
-/**
- * Extract routes from a single file
- */
-function extractFromFile(filePath, projectRoot, currentPrefix, routes, prefixes, autoloadDirs, gaps, visited) {
-  if (visited.has(filePath)) return;
-  visited.add(filePath);
-
-  if (!fs.existsSync(filePath)) return;
-
-  const content = fs.readFileSync(filePath, "utf8");
-  const relPath = path.relative(projectRoot, filePath).replace(/\\/g, "/");
-
-  // Pattern A: fastify.route({ method, url, ... })
-  extractRouteMethod(content, relPath, currentPrefix, routes, projectRoot);
-
-  // Pattern B: fastify.get/post/put/... shorthand
-  extractShorthandMethods(content, relPath, currentPrefix, routes, projectRoot);
-
-  // Pattern C: fastify.register with prefix
-  extractRegisterCalls(content, filePath, projectRoot, currentPrefix, routes, prefixes, autoloadDirs, gaps, visited);
-
-  // Pattern D: AutoLoad
-  extractAutoLoad(content, filePath, projectRoot, currentPrefix, routes, prefixes, autoloadDirs, gaps, visited);
-}
-
-/**
- * Extract fastify.route({ method, url, ... }) patterns
- */
-function extractRouteMethod(content, relPath, prefix, routes, projectRoot) {
-  // Match fastify.route({ method: "POST", url: "/path", ... })
-  const routePattern = /(?:fastify|app|server)\s*\.\s*route\s*\(\s*\{([^}]+)\}/g;
-  
-  let match;
-  while ((match = routePattern.exec(content)) !== null) {
-    const routeBody = match[1];
-    
-    // Extract method
-    const methodMatch = routeBody.match(/method\s*:\s*(?:['"`](\w+)['"`]|\[([^\]]+)\])/);
-    let methods = ["UNKNOWN"];
-    if (methodMatch) {
-      if (methodMatch[1]) {
-        methods = [methodMatch[1].toUpperCase()];
-      } else if (methodMatch[2]) {
-        methods = methodMatch[2].match(/['"`](\w+)['"`]/g)?.map(m => m.replace(/['"`]/g, "").toUpperCase()) || [];
-      }
-    }
-
-    // Extract url/path
-    const urlMatch = routeBody.match(/(?:url|path)\s*:\s*['"`]([^'"`]+)['"`]/);
-    if (urlMatch) {
-      const rawPath = urlMatch[1];
-      const fullPath = combinePrefixes(prefix, rawPath);
-      const canonicalPath = convertFastifyPathToCanonical(fullPath);
-
-      const lineNum = content.substring(0, match.index).split("\n").length;
-
-      routes.push({
-        id: `R_FASTIFY_${hashPath(canonicalPath)}`,
-        kind: "fastify",
-        methods,
-        rawPath: fullPath,
-        path: canonicalPath,
-        canonicalPath,
-        authRequired: "unknown",
-        confidence: "medium",
-        handler: {
-          file: relPath,
-          export: "route",
-        },
-        evidence: [{
-          id: `E_${crypto.randomBytes(4).toString("hex").toUpperCase()}`,
-          kind: "file",
-          reason: "fastify.route() call",
-          file: relPath,
-          lines: `${lineNum}-${lineNum + 5}`,
-          snippetHash: hashSnippet(match[0]),
-        }],
-      });
-    }
-  }
-}
-
-/**
- * Extract fastify.get/post/put shorthand methods
- */
-function extractShorthandMethods(content, relPath, prefix, routes, projectRoot) {
-  for (const method of FASTIFY_METHODS) {
-    const lowerMethod = method.toLowerCase();
-    // Match fastify.get("/path", ...) or fastify.get('/path', ...)
-    const pattern = new RegExp(`(?:fastify|app|server)\\s*\\.\\s*${lowerMethod}\\s*\\(\\s*['"\`]([^'"\`]+)['"\`]`, "g");
-    
-    let match;
-    while ((match = pattern.exec(content)) !== null) {
-      const rawPath = match[1];
-      const fullPath = combinePrefixes(prefix, rawPath);
-      const canonicalPath = convertFastifyPathToCanonical(fullPath);
-
-      const lineNum = content.substring(0, match.index).split("\n").length;
-
-      routes.push({
-        id: `R_FASTIFY_${hashPath(canonicalPath)}_${method}`,
-        kind: "fastify",
-        methods: method === "ALL" ? ["GET", "POST", "PUT", "PATCH", "DELETE"] : [method],
-        rawPath: fullPath,
-        path: canonicalPath,
-        canonicalPath,
-        authRequired: "unknown",
-        confidence: "medium",
-        handler: {
-          file: relPath,
-          export: lowerMethod,
-        },
-        evidence: [{
-          id: `E_${crypto.randomBytes(4).toString("hex").toUpperCase()}`,
-          kind: "file",
-          reason: `fastify.${lowerMethod}() call`,
-          file: relPath,
-          lines: `${lineNum}-${lineNum + 3}`,
-          snippetHash: hashSnippet(match[0]),
-        }],
-      });
-    }
-  }
-}
-
-/**
- * Extract fastify.register() calls with prefix stacking
- */
-function extractRegisterCalls(content, filePath, projectRoot, currentPrefix, routes, prefixes, autoloadDirs, gaps, visited) {
-  // Match register(plugin, { prefix: "/api" }) or register(import(...), { prefix })
-  const registerPattern = /(?:fastify|app|server)\s*\.\s*register\s*\(\s*(?:import\s*\(\s*['"`]([^'"`]+)['"`]\s*\)|require\s*\(\s*['"`]([^'"`]+)['"`]\s*\)|(\w+))\s*(?:,\s*\{[^}]*prefix\s*:\s*['"`]([^'"`]+)['"`][^}]*\})?/g;
-
-  let match;
-  while ((match = registerPattern.exec(content)) !== null) {
-    const importPath = match[1] || match[2];
-    const varName = match[3];
-    const newPrefix = match[4] || "";
-
-    const combinedPrefix = combinePrefixes(currentPrefix, newPrefix);
-    if (newPrefix) {
-      prefixes.add(combinedPrefix);
-    }
-
-    // Try to resolve and scan the registered plugin
-    if (importPath) {
-      const resolvedPath = resolveImportPath(filePath, importPath, projectRoot);
-      if (resolvedPath) {
-        extractFromFile(resolvedPath, projectRoot, combinedPrefix, routes, prefixes, autoloadDirs, gaps, visited);
-      }
-    }
-  }
-}
-
-/**
- * Extract AutoLoad patterns
- */
-function extractAutoLoad(content, filePath, projectRoot, currentPrefix, routes, prefixes, autoloadDirs, gaps, visited) {
-  // Match AutoLoad registration
-  const autoloadPattern = /register\s*\(\s*(?:AutoLoad|autoLoad|fastifyAutoload)\s*,\s*\{[^}]*dir\s*:\s*(?:path\.join\s*\(\s*__dirname\s*,\s*['"`]([^'"`]+)['"`]\s*\)|['"`]([^'"`]+)['"`])/g;
-
-  let match;
-  while ((match = autoloadPattern.exec(content)) !== null) {
-    const dirRelative = match[1] || match[2];
-    
-    if (dirRelative) {
-      const fileDir = path.dirname(filePath);
-      const autoloadDir = path.resolve(fileDir, dirRelative);
-      
-      if (fs.existsSync(autoloadDir)) {
-        autoloadDirs.push(path.relative(projectRoot, autoloadDir));
-        scanRouteDirectory(autoloadDir, projectRoot, currentPrefix, routes, prefixes, gaps, visited);
-      } else {
-        gaps.push({
-          type: "autoload_dir_not_found",
-          dir: dirRelative,
-          file: path.relative(projectRoot, filePath),
-        });
-      }
-    } else {
-      // Non-literal dir path
-      gaps.push({
-        type: "autoload_dir_not_resolvable",
-        file: path.relative(projectRoot, filePath),
-        message: "AutoLoad directory is not statically resolvable",
-      });
-    }
-  }
-}
-
-/**
- * Scan a routes directory for plugin files
- */
-function scanRouteDirectory(dir, projectRoot, prefix, routes, prefixes, gaps, visited) {
-  const pattern = path.join(dir, "**", "*.{js,ts}").replace(/\\/g, "/");
-  const files = fg.sync(pattern, { onlyFiles: true, absolute: true, ignore: ["**/*.test.*", "**/*.spec.*"] });
-
-  for (const file of files) {
-    // Infer prefix from directory structure
-    const relDir = path.relative(dir, path.dirname(file)).replace(/\\/g, "/");
-    const inferredPrefix = relDir ? `/${relDir}` : "";
-    const combinedPrefix = combinePrefixes(prefix, inferredPrefix);
-
-    extractFromFile(file, projectRoot, combinedPrefix, routes, prefixes, [], gaps, visited);
-  }
-}
-
-/**
- * Convert Fastify path params to canonical format
- * :id → {id}
- * :path* → {*path}
- * /* → {*path}
- */
-function convertFastifyPathToCanonical(urlPath) {
-  return urlPath
-    // Wildcard catch-all
-    .replace(/\/\*$/, "/{*path}")
-    .replace(/\/:(\w+)\*/, "/{*$1}")
-    // Named params
-    .replace(/:(\w+)/g, "{$1}")
-    // Clean up
-    .replace(/\/+/g, "/")
-    .replace(/(.)\/$/, "$1");
-}
-
-/**
- * Combine prefix segments
- */
-function combinePrefixes(base, addition) {
-  if (!addition) return base;
-  if (!base) return addition;
-  
-  const baseTrimmed = base.replace(/\/$/, "");
-  const addTrimmed = addition.startsWith("/") ? addition : "/" + addition;
-  
-  return baseTrimmed + addTrimmed;
-}
-
-/**
- * Resolve import path to absolute file path
- */
-function resolveImportPath(fromFile, importPath, projectRoot) {
-  const fromDir = path.dirname(fromFile);
-  
-  // Relative import
-  if (importPath.startsWith(".")) {
-    const extensions = [".ts", ".js", ".tsx", ".jsx", ""];
-    for (const ext of extensions) {
-      const resolved = path.resolve(fromDir, importPath + ext);
-      if (fs.existsSync(resolved)) return resolved;
-      
-      // Try index file
-      const indexResolved = path.resolve(fromDir, importPath, "index" + ext);
-      if (fs.existsSync(indexResolved)) return indexResolved;
-    }
-  }
-  
-  return null;
-}
-
-/**
- * Runtime introspection for Fastify routes (optional, high-confidence)
- */
-async function introspectFastifyRoutes(projectRoot, entryFile) {
-  // This would spawn a node process to load and dump routes
-  // For now, return null to indicate runtime introspection not performed
-  return null;
-}
-
-// Helpers
-function hashSnippet(text) {
-  return `sha256:${crypto.createHash("sha256").update(text).digest("hex")}`;
-}
-
-function hashPath(urlPath) {
-  return crypto.createHash("sha256").update(urlPath).digest("hex").slice(0, 12).toUpperCase();
-}
-
-module.exports = {
-  detectFastify,
-  extractFastifyRoutes,
-  extractFromFile,
-  extractRouteMethod,
-  extractShorthandMethods,
-  extractRegisterCalls,
-  extractAutoLoad,
-  convertFastifyPathToCanonical,
-  combinePrefixes,
-  resolveImportPath,
-  introspectFastifyRoutes,
-  FASTIFY_METHODS,
-};
+/**
+ * Fastify Route Extractor v2
+ * 
+ * Spec-compliant extraction with prefix stacking and autoload support.
+ * Two-tier approach: static AST extraction + optional runtime introspection.
+ * 
+ * Patterns supported:
+ * - fastify.route({ method, url, handler })
+ * - fastify.get/post/put/patch/delete(path, handler)
+ * - fastify.register(plugin, { prefix })
+ * - AutoLoad with dir resolution
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const fg = require("fast-glob");
+const crypto = require("crypto");
+
+const FASTIFY_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD", "ALL"];
+
+/**
+ * Detect Fastify service and entrypoint
+ */
+function detectFastify(projectRoot) {
+  const result = {
+    present: false,
+    entryFile: null,
+    prefixes: [],
+  };
+
+  // Check package.json for fastify dependency
+  const pkgPath = path.join(projectRoot, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+      if (pkg.dependencies?.fastify || pkg.devDependencies?.fastify) {
+        result.present = true;
+      }
+
+      // Try to find entry from scripts
+      const scripts = pkg.scripts || {};
+      for (const [name, cmd] of Object.entries(scripts)) {
+        if (name === "start" || name === "dev" || name === "server") {
+          const entryMatch = cmd.match(/(?:node|tsx|ts-node|npx\s+tsx?)\s+([^\s]+)/);
+          if (entryMatch) {
+            const entryPath = path.join(projectRoot, entryMatch[1]);
+            if (fs.existsSync(entryPath)) {
+              result.entryFile = entryMatch[1];
+            }
+          }
+        }
+      }
+    } catch {}
+  }
+
+  // Fallback: search common entry files
+  if (!result.entryFile) {
+    const commonEntries = [
+      "server.ts", "server.js",
+      "src/server.ts", "src/server.js",
+      "app.ts", "app.js",
+      "src/app.ts", "src/app.js",
+      "index.ts", "index.js",
+      "src/index.ts", "src/index.js",
+    ];
+
+    for (const entry of commonEntries) {
+      const entryPath = path.join(projectRoot, entry);
+      if (fs.existsSync(entryPath)) {
+        const content = fs.readFileSync(entryPath, "utf8");
+        if (/from\s+['"]fastify['"]|require\s*\(\s*['"]fastify['"]\s*\)/.test(content)) {
+          result.entryFile = entry;
+          result.present = true;
+          break;
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Extract routes from Fastify project using static AST analysis
+ */
+function extractFastifyRoutes(projectRoot, entryFile = null) {
+  const detection = detectFastify(projectRoot);
+  
+  if (!detection.present) {
+    return {
+      present: false,
+      entryFile: null,
+      routes: [],
+      prefixes: [],
+      autoloadDirs: [],
+      gaps: [],
+    };
+  }
+
+  const entry = entryFile || detection.entryFile;
+  const routes = [];
+  const prefixes = new Set();
+  const autoloadDirs = [];
+  const gaps = [];
+  const visited = new Set();
+
+  // Start extraction from entry file
+  if (entry) {
+    const entryPath = path.join(projectRoot, entry);
+    if (fs.existsSync(entryPath)) {
+      extractFromFile(entryPath, projectRoot, "", routes, prefixes, autoloadDirs, gaps, visited);
+    }
+  }
+
+  // Also scan common route directories
+  const routeDirs = ["routes", "src/routes", "api", "src/api"];
+  for (const dir of routeDirs) {
+    const dirPath = path.join(projectRoot, dir);
+    if (fs.existsSync(dirPath)) {
+      scanRouteDirectory(dirPath, projectRoot, "", routes, prefixes, gaps, visited);
+    }
+  }
+
+  return {
+    present: true,
+    entryFile: entry,
+    routes,
+    prefixes: [...prefixes],
+    autoloadDirs,
+    gaps,
+  };
+}
+
+/**
+ * Extract routes from a single file
+ */
+function extractFromFile(filePath, projectRoot, currentPrefix, routes, prefixes, autoloadDirs, gaps, visited) {
+  if (visited.has(filePath)) return;
+  visited.add(filePath);
+
+  if (!fs.existsSync(filePath)) return;
+
+  const content = fs.readFileSync(filePath, "utf8");
+  const relPath = path.relative(projectRoot, filePath).replace(/\\/g, "/");
+
+  // Pattern A: fastify.route({ method, url, ... })
+  extractRouteMethod(content, relPath, currentPrefix, routes, projectRoot);
+
+  // Pattern B: fastify.get/post/put/... shorthand
+  extractShorthandMethods(content, relPath, currentPrefix, routes, projectRoot);
+
+  // Pattern C: fastify.register with prefix
+  extractRegisterCalls(content, filePath, projectRoot, currentPrefix, routes, prefixes, autoloadDirs, gaps, visited);
+
+  // Pattern D: AutoLoad
+  extractAutoLoad(content, filePath, projectRoot, currentPrefix, routes, prefixes, autoloadDirs, gaps, visited);
+}
+
+/**
+ * Extract fastify.route({ method, url, ... }) patterns
+ */
+function extractRouteMethod(content, relPath, prefix, routes, projectRoot) {
+  // Match fastify.route({ method: "POST", url: "/path", ... })
+  const routePattern = /(?:fastify|app|server)\s*\.\s*route\s*\(\s*\{([^}]+)\}/g;
+  
+  let match;
+  while ((match = routePattern.exec(content)) !== null) {
+    const routeBody = match[1];
+    
+    // Extract method
+    const methodMatch = routeBody.match(/method\s*:\s*(?:['"`](\w+)['"`]|\[([^\]]+)\])/);
+    let methods = ["UNKNOWN"];
+    if (methodMatch) {
+      if (methodMatch[1]) {
+        methods = [methodMatch[1].toUpperCase()];
+      } else if (methodMatch[2]) {
+        methods = methodMatch[2].match(/['"`](\w+)['"`]/g)?.map(m => m.replace(/['"`]/g, "").toUpperCase()) || [];
+      }
+    }
+
+    // Extract url/path
+    const urlMatch = routeBody.match(/(?:url|path)\s*:\s*['"`]([^'"`]+)['"`]/);
+    if (urlMatch) {
+      const rawPath = urlMatch[1];
+      const fullPath = combinePrefixes(prefix, rawPath);
+      const canonicalPath = convertFastifyPathToCanonical(fullPath);
+
+      const lineNum = content.substring(0, match.index).split("\n").length;
+
+      routes.push({
+        id: `R_FASTIFY_${hashPath(canonicalPath)}`,
+        kind: "fastify",
+        methods,
+        rawPath: fullPath,
+        path: canonicalPath,
+        canonicalPath,
+        authRequired: "unknown",
+        confidence: "medium",
+        handler: {
+          file: relPath,
+          export: "route",
+        },
+        evidence: [{
+          id: `E_${crypto.randomBytes(4).toString("hex").toUpperCase()}`,
+          kind: "file",
+          reason: "fastify.route() call",
+          file: relPath,
+          lines: `${lineNum}-${lineNum + 5}`,
+          snippetHash: hashSnippet(match[0]),
+        }],
+      });
+    }
+  }
+}
+
+/**
+ * Extract fastify.get/post/put shorthand methods
+ */
+function extractShorthandMethods(content, relPath, prefix, routes, projectRoot) {
+  for (const method of FASTIFY_METHODS) {
+    const lowerMethod = method.toLowerCase();
+    // Match fastify.get("/path", ...) or fastify.get('/path', ...)
+    const pattern = new RegExp(`(?:fastify|app|server)\\s*\\.\\s*${lowerMethod}\\s*\\(\\s*['"\`]([^'"\`]+)['"\`]`, "g");
+    
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      const rawPath = match[1];
+      const fullPath = combinePrefixes(prefix, rawPath);
+      const canonicalPath = convertFastifyPathToCanonical(fullPath);
+
+      const lineNum = content.substring(0, match.index).split("\n").length;
+
+      routes.push({
+        id: `R_FASTIFY_${hashPath(canonicalPath)}_${method}`,
+        kind: "fastify",
+        methods: method === "ALL" ? ["GET", "POST", "PUT", "PATCH", "DELETE"] : [method],
+        rawPath: fullPath,
+        path: canonicalPath,
+        canonicalPath,
+        authRequired: "unknown",
+        confidence: "medium",
+        handler: {
+          file: relPath,
+          export: lowerMethod,
+        },
+        evidence: [{
+          id: `E_${crypto.randomBytes(4).toString("hex").toUpperCase()}`,
+          kind: "file",
+          reason: `fastify.${lowerMethod}() call`,
+          file: relPath,
+          lines: `${lineNum}-${lineNum + 3}`,
+          snippetHash: hashSnippet(match[0]),
+        }],
+      });
+    }
+  }
+}
+
+/**
+ * Extract fastify.register() calls with prefix stacking
+ */
+function extractRegisterCalls(content, filePath, projectRoot, currentPrefix, routes, prefixes, autoloadDirs, gaps, visited) {
+  // Match register(plugin, { prefix: "/api" }) or register(import(...), { prefix })
+  const registerPattern = /(?:fastify|app|server)\s*\.\s*register\s*\(\s*(?:import\s*\(\s*['"`]([^'"`]+)['"`]\s*\)|require\s*\(\s*['"`]([^'"`]+)['"`]\s*\)|(\w+))\s*(?:,\s*\{[^}]*prefix\s*:\s*['"`]([^'"`]+)['"`][^}]*\})?/g;
+
+  let match;
+  while ((match = registerPattern.exec(content)) !== null) {
+    const importPath = match[1] || match[2];
+    const varName = match[3];
+    const newPrefix = match[4] || "";
+
+    const combinedPrefix = combinePrefixes(currentPrefix, newPrefix);
+    if (newPrefix) {
+      prefixes.add(combinedPrefix);
+    }
+
+    // Try to resolve and scan the registered plugin
+    if (importPath) {
+      const resolvedPath = resolveImportPath(filePath, importPath, projectRoot);
+      if (resolvedPath) {
+        extractFromFile(resolvedPath, projectRoot, combinedPrefix, routes, prefixes, autoloadDirs, gaps, visited);
+      }
+    }
+  }
+}
+
+/**
+ * Extract AutoLoad patterns
+ */
+function extractAutoLoad(content, filePath, projectRoot, currentPrefix, routes, prefixes, autoloadDirs, gaps, visited) {
+  // Match AutoLoad registration
+  const autoloadPattern = /register\s*\(\s*(?:AutoLoad|autoLoad|fastifyAutoload)\s*,\s*\{[^}]*dir\s*:\s*(?:path\.join\s*\(\s*__dirname\s*,\s*['"`]([^'"`]+)['"`]\s*\)|['"`]([^'"`]+)['"`])/g;
+
+  let match;
+  while ((match = autoloadPattern.exec(content)) !== null) {
+    const dirRelative = match[1] || match[2];
+    
+    if (dirRelative) {
+      const fileDir = path.dirname(filePath);
+      const autoloadDir = path.resolve(fileDir, dirRelative);
+      
+      if (fs.existsSync(autoloadDir)) {
+        autoloadDirs.push(path.relative(projectRoot, autoloadDir));
+        scanRouteDirectory(autoloadDir, projectRoot, currentPrefix, routes, prefixes, gaps, visited);
+      } else {
+        gaps.push({
+          type: "autoload_dir_not_found",
+          dir: dirRelative,
+          file: path.relative(projectRoot, filePath),
+        });
+      }
+    } else {
+      // Non-literal dir path
+      gaps.push({
+        type: "autoload_dir_not_resolvable",
+        file: path.relative(projectRoot, filePath),
+        message: "AutoLoad directory is not statically resolvable",
+      });
+    }
+  }
+}
+
+/**
+ * Scan a routes directory for plugin files
+ */
+function scanRouteDirectory(dir, projectRoot, prefix, routes, prefixes, gaps, visited) {
+  const pattern = path.join(dir, "**", "*.{js,ts}").replace(/\\/g, "/");
+  const files = fg.sync(pattern, { onlyFiles: true, absolute: true, ignore: ["**/*.test.*", "**/*.spec.*"] });
+
+  for (const file of files) {
+    // Infer prefix from directory structure
+    const relDir = path.relative(dir, path.dirname(file)).replace(/\\/g, "/");
+    const inferredPrefix = relDir ? `/${relDir}` : "";
+    const combinedPrefix = combinePrefixes(prefix, inferredPrefix);
+
+    extractFromFile(file, projectRoot, combinedPrefix, routes, prefixes, [], gaps, visited);
+  }
+}
+
+/**
+ * Convert Fastify path params to canonical format
+ * :id → {id}
+ * :path* → {*path}
+ * /* → {*path}
+ */
+function convertFastifyPathToCanonical(urlPath) {
+  return urlPath
+    // Wildcard catch-all
+    .replace(/\/\*$/, "/{*path}")
+    .replace(/\/:(\w+)\*/, "/{*$1}")
+    // Named params
+    .replace(/:(\w+)/g, "{$1}")
+    // Clean up
+    .replace(/\/+/g, "/")
+    .replace(/(.)\/$/, "$1");
+}
+
+/**
+ * Combine prefix segments
+ */
+function combinePrefixes(base, addition) {
+  if (!addition) return base;
+  if (!base) return addition;
+  
+  const baseTrimmed = base.replace(/\/$/, "");
+  const addTrimmed = addition.startsWith("/") ? addition : "/" + addition;
+  
+  return baseTrimmed + addTrimmed;
+}
+
+/**
+ * Resolve import path to absolute file path
+ */
+function resolveImportPath(fromFile, importPath, projectRoot) {
+  const fromDir = path.dirname(fromFile);
+  
+  // Relative import
+  if (importPath.startsWith(".")) {
+    const extensions = [".ts", ".js", ".tsx", ".jsx", ""];
+    for (const ext of extensions) {
+      const resolved = path.resolve(fromDir, importPath + ext);
+      if (fs.existsSync(resolved)) return resolved;
+      
+      // Try index file
+      const indexResolved = path.resolve(fromDir, importPath, "index" + ext);
+      if (fs.existsSync(indexResolved)) return indexResolved;
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Runtime introspection for Fastify routes (optional, high-confidence)
+ */
+async function introspectFastifyRoutes(projectRoot, entryFile) {
+  // This would spawn a node process to load and dump routes
+  // For now, return null to indicate runtime introspection not performed
+  return null;
+}
+
+// Helpers
+function hashSnippet(text) {
+  return `sha256:${crypto.createHash("sha256").update(text).digest("hex")}`;
+}
+
+function hashPath(urlPath) {
+  return crypto.createHash("sha256").update(urlPath).digest("hex").slice(0, 12).toUpperCase();
+}
+
+module.exports = {
+  detectFastify,
+  extractFastifyRoutes,
+  extractFromFile,
+  extractRouteMethod,
+  extractShorthandMethods,
+  extractRegisterCalls,
+  extractAutoLoad,
+  convertFastifyPathToCanonical,
+  combinePrefixes,
+  resolveImportPath,
+  introspectFastifyRoutes,
+  FASTIFY_METHODS,
+};