@gurulu/cli 0.4.0 → 0.4.2

package/scripts/gurulu-scan.lib.cjs

@@ -8,6 +8,7 @@
 'use strict';
 
 const fs = require('node:fs').promises;
+const fsSync = require('node:fs');
 const path = require('node:path');
 
 const SCAN_VERSION = '2';
@@ -22,24 +23,79 @@ const SKIP_DIRS = new Set([
   '.turbo',
   '.vercel',
   'coverage',
+  // Mobile
+  'Pods',              // iOS CocoaPods
+  '.gradle',           // Android Gradle cache
+  '.dart_tool',        // Flutter
+  '.pub-cache',        // Flutter pub cache
 ]);
 
 const CODE_EXTS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']);
 
+// Mobile code extensions for screen/route scanning
+const MOBILE_CODE_EXTS = new Set([
+  '.ts', '.tsx', '.js', '.jsx',       // React Native
+  '.swift',                            // iOS
+  '.kt', '.java',                      // Android
+  '.dart',                             // Flutter
+]);
+
 // ---------------------------------------------------------------------------
 // Framework detection
 // ---------------------------------------------------------------------------
-function detectFramework(deps = {}) {
+function detectFramework(deps = {}, rootPath) {
   const has = (name) => Object.prototype.hasOwnProperty.call(deps, name);
   const ver = (name) =>
     deps[name] ? String(deps[name]).replace(/^[^\d]*/, '') || null : null;
 
+  // --- Mobile framework detection (must come before web frameworks) ---
+
+  // React Native: has react-native in deps — check BEFORE other React-based frameworks
+  if (has('react-native')) {
+    return { name: 'react-native', version: ver('react-native') };
+  }
+
+  if (rootPath) {
+    // Flutter: check for pubspec.yaml
+    if (fsSync.existsSync(path.join(rootPath, 'pubspec.yaml'))) {
+      return { name: 'flutter', version: null };
+    }
+
+    // iOS: check for .xcodeproj, .xcworkspace, or Package.swift
+    try {
+      const entries = fsSync.readdirSync(rootPath);
+      const hasXcode = entries.some(
+        (e) => e.endsWith('.xcodeproj') || e.endsWith('.xcworkspace'),
+      );
+      const hasPackageSwift = fsSync.existsSync(path.join(rootPath, 'Package.swift'));
+      if (hasXcode || hasPackageSwift) {
+        return { name: 'ios-swift', version: null };
+      }
+    } catch {
+      /* skip */
+    }
+
+    // Android: check for build.gradle / build.gradle.kts (only when no package.json deps,
+    // otherwise it could be a monorepo with an android/ subfolder)
+    if (Object.keys(deps).length === 0) {
+      if (
+        fsSync.existsSync(path.join(rootPath, 'build.gradle')) ||
+        fsSync.existsSync(path.join(rootPath, 'build.gradle.kts')) ||
+        fsSync.existsSync(path.join(rootPath, 'app', 'build.gradle'))
+      ) {
+        return { name: 'android-kotlin', version: null };
+      }
+    }
+  }
+
+  // --- Web framework detection ---
   if (has('next')) return { name: 'nextjs', version: ver('next') };
   if (has('@nestjs/core')) return { name: 'nestjs', version: ver('@nestjs/core') };
   if (has('@remix-run/dev')) return { name: 'remix', version: ver('@remix-run/dev') };
   if (has('@sveltejs/kit')) return { name: 'sveltekit', version: ver('@sveltejs/kit') };
   if (has('astro')) return { name: 'astro', version: ver('astro') };
   if (has('fastify')) return { name: 'fastify', version: ver('fastify') };
+  if (has('hono')) return { name: 'hono', version: ver('hono') };
   if (has('express')) return { name: 'express', version: ver('express') };
   if (has('vite') && has('react')) return { name: 'vite-react', version: ver('vite') };
   if (has('vue')) return { name: 'vue', version: ver('vue') };
@@ -52,6 +108,13 @@ function detectFramework(deps = {}) {
 function detectORM(deps = {}, schemaHints = {}) {
   const has = (name) => Object.prototype.hasOwnProperty.call(deps, name);
 
+  // Mobile ORM / persistence (package.json-based, e.g. React Native)
+  if (has('realm') || has('@realm/react')) return { name: 'realm', schemaPath: null };
+  if (has('react-native-sqlite-storage') || has('react-native-sqlite-2') || has('expo-sqlite')) {
+    return { name: 'sqlite', schemaPath: null };
+  }
+
+  // Web ORMs
   if (has('@prisma/client') || has('prisma')) {
     return { name: 'prisma', schemaPath: schemaHints.prisma || null };
   }
@@ -65,6 +128,63 @@ function detectORM(deps = {}, schemaHints = {}) {
   return { name: 'unknown', schemaPath: null };
 }
 
+/**
+ * detectMobileORM — filesystem-based ORM detection for mobile projects
+ * that don't use package.json (iOS/Android/Flutter).
+ */
+function detectMobileORM(rootPath, framework) {
+  if (!framework || !rootPath) return { name: 'unknown', schemaPath: null };
+
+  if (framework.name === 'ios-swift') {
+    // Core Data: look for .xcdatamodeld directories
+    try {
+      const entries = fsSync.readdirSync(rootPath);
+      if (entries.some((e) => e.endsWith('.xcdatamodeld'))) {
+        return { name: 'coredata', schemaPath: null };
+      }
+    } catch {
+      /* skip */
+    }
+    // Realm for iOS (check via SPM Package.swift or Podfile)
+    for (const f of ['Package.swift', 'Podfile']) {
+      try {
+        const content = fsSync.readFileSync(path.join(rootPath, f), 'utf8');
+        if (/realm/i.test(content)) return { name: 'realm', schemaPath: null };
+      } catch {
+        /* skip */
+      }
+    }
+  }
+
+  if (framework.name === 'android-kotlin') {
+    // Room: check build.gradle for androidx.room dependency
+    for (const gf of ['build.gradle', 'build.gradle.kts', 'app/build.gradle', 'app/build.gradle.kts']) {
+      try {
+        const content = fsSync.readFileSync(path.join(rootPath, gf), 'utf8');
+        if (/androidx\.room/.test(content)) return { name: 'room', schemaPath: null };
+        if (/realm/i.test(content)) return { name: 'realm', schemaPath: null };
+      } catch {
+        /* skip */
+      }
+    }
+  }
+
+  if (framework.name === 'flutter') {
+    // sqflite / drift / floor — check pubspec.yaml
+    try {
+      const pubspec = fsSync.readFileSync(path.join(rootPath, 'pubspec.yaml'), 'utf8');
+      if (/\bsqflite\b/.test(pubspec)) return { name: 'sqlite', schemaPath: null };
+      if (/\bdrift\b/.test(pubspec)) return { name: 'drift', schemaPath: null };
+      if (/\bfloor\b/.test(pubspec)) return { name: 'floor', schemaPath: null };
+      if (/\brealm\b/.test(pubspec)) return { name: 'realm', schemaPath: null };
+    } catch {
+      /* skip */
+    }
+  }
+
+  return { name: 'unknown', schemaPath: null };
+}
+
 // ---------------------------------------------------------------------------
 // Auth detection
 // ---------------------------------------------------------------------------
@@ -113,6 +233,308 @@ async function walk(dir, collected = []) {
   return collected;
 }
 
+// ---------------------------------------------------------------------------
+// Route detection — Express
+// ---------------------------------------------------------------------------
+const EXPRESS_ROUTE_PATTERN =
+  /(?:app|router)\.(get|post|put|delete|patch|options|head)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
+const EXPRESS_USE_PATTERN =
+  /(?:app|router)\.use\s*\(\s*['"`]([^'"`]+)['"`]/gi;
+
+async function scanExpressRoutes(rootPath) {
+  const ROUTE_LIMIT = 100;
+  const candidateDirs = ['src/routes', 'routes', 'src/controllers', 'src/api', 'app'];
+  const seen = new Set();
+  const routes = [];
+
+  // Collect prefix hints from app.use('/prefix', router)
+  const prefixes = [];
+
+  for (const base of candidateDirs) {
+    const dir = path.join(rootPath, base);
+    let files;
+    try {
+      files = await walk(dir);
+    } catch {
+      continue;
+    }
+    for (const abs of files) {
+      if (!CODE_EXTS.has(path.extname(abs))) continue;
+      let content;
+      try {
+        content = await fs.readFile(abs, 'utf8');
+      } catch {
+        continue;
+      }
+      if (content.length > 1_500_000) continue;
+
+      // Collect use() prefixes
+      const useRe = new RegExp(EXPRESS_USE_PATTERN.source, EXPRESS_USE_PATTERN.flags);
+      let um;
+      while ((um = useRe.exec(content)) !== null) {
+        const prefix = um[1].replace(/\/+$/, '');
+        if (prefix && prefix !== '/') prefixes.push(prefix);
+      }
+
+      // Collect routes
+      const re = new RegExp(EXPRESS_ROUTE_PATTERN.source, EXPRESS_ROUTE_PATTERN.flags);
+      let m;
+      while ((m = re.exec(content)) !== null) {
+        const method = m[1].toUpperCase();
+        const routePath = m[2];
+        const key = `${method}:${routePath}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        routes.push({ method, path: routePath });
+        if (routes.length >= ROUTE_LIMIT) return { routes };
+      }
+    }
+  }
+
+  // Also scan entry files at root and src/ level
+  for (const baseDir of ['', 'src']) {
+    for (const entry of ['index', 'server', 'app', 'main']) {
+      for (const ext of ['.ts', '.js', '.mjs', '.cjs']) {
+        const abs = path.join(rootPath, baseDir, `${entry}${ext}`);
+        let content;
+        try {
+          content = await fs.readFile(abs, 'utf8');
+        } catch {
+          continue;
+        }
+        if (content.length > 1_500_000) continue;
+
+        const useRe = new RegExp(EXPRESS_USE_PATTERN.source, EXPRESS_USE_PATTERN.flags);
+        let um;
+        while ((um = useRe.exec(content)) !== null) {
+          const prefix = um[1].replace(/\/+$/, '');
+          if (prefix && prefix !== '/') prefixes.push(prefix);
+        }
+
+        const re = new RegExp(EXPRESS_ROUTE_PATTERN.source, EXPRESS_ROUTE_PATTERN.flags);
+        let m;
+        while ((m = re.exec(content)) !== null) {
+          const method = m[1].toUpperCase();
+          const routePath = m[2];
+          const key = `${method}:${routePath}`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          routes.push({ method, path: routePath });
+          if (routes.length >= ROUTE_LIMIT) return { routes };
+        }
+      }
+    }
+  }
+
+  return { routes };
+}
+
+// ---------------------------------------------------------------------------
+// Route detection — Fastify
+// ---------------------------------------------------------------------------
+const FASTIFY_PATTERN =
+  /fastify\.(get|post|put|delete|patch|options|head)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
+const FASTIFY_ROUTE_PATTERN =
+  /fastify\.route\s*\(\s*\{[^}]*method\s*:\s*['"`](\w+)['"`][^}]*url\s*:\s*['"`]([^'"`]+)['"`]/gi;
+
+async function scanFastifyRoutes(rootPath) {
+  const ROUTE_LIMIT = 100;
+  const candidateDirs = ['src/routes', 'routes', 'src/controllers', 'src/api', 'app'];
+  const seen = new Set();
+  const routes = [];
+
+  const scanFile = async (abs) => {
+    if (!CODE_EXTS.has(path.extname(abs))) return;
+    let content;
+    try {
+      content = await fs.readFile(abs, 'utf8');
+    } catch {
+      return;
+    }
+    if (content.length > 1_500_000) return;
+
+    // Shorthand: fastify.get('/path', ...)
+    const re1 = new RegExp(FASTIFY_PATTERN.source, FASTIFY_PATTERN.flags);
+    let m;
+    while ((m = re1.exec(content)) !== null) {
+      const method = m[1].toUpperCase();
+      const routePath = m[2];
+      const key = `${method}:${routePath}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      routes.push({ method, path: routePath });
+      if (routes.length >= ROUTE_LIMIT) return;
+    }
+
+    // fastify.route({ method: 'GET', url: '/path' })
+    const re2 = new RegExp(FASTIFY_ROUTE_PATTERN.source, FASTIFY_ROUTE_PATTERN.flags);
+    while ((m = re2.exec(content)) !== null) {
+      const method = m[1].toUpperCase();
+      const routePath = m[2];
+      const key = `${method}:${routePath}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      routes.push({ method, path: routePath });
+      if (routes.length >= ROUTE_LIMIT) return;
+    }
+  };
+
+  for (const base of candidateDirs) {
+    const dir = path.join(rootPath, base);
+    let files;
+    try {
+      files = await walk(dir);
+    } catch {
+      continue;
+    }
+    for (const abs of files) {
+      await scanFile(abs);
+      if (routes.length >= ROUTE_LIMIT) return { routes };
+    }
+  }
+
+  // Scan entry files at root and src/ level
+  for (const baseDir of ['', 'src']) {
+    for (const entry of ['index', 'server', 'app', 'main']) {
+      for (const ext of ['.ts', '.js', '.mjs', '.cjs']) {
+        await scanFile(path.join(rootPath, baseDir, `${entry}${ext}`));
+        if (routes.length >= ROUTE_LIMIT) return { routes };
+      }
+    }
+  }
+
+  return { routes };
+}
+
+// ---------------------------------------------------------------------------
+// Route detection — Hono
+// ---------------------------------------------------------------------------
+const HONO_PATTERN =
+  /(?:app|api|router|server)\.(get|post|put|delete|patch|options|head)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
+
+async function scanHonoRoutes(rootPath) {
+  const ROUTE_LIMIT = 100;
+  const candidateDirs = ['src/routes', 'routes', 'src/api', 'app', 'src/app'];
+  const seen = new Set();
+  const routes = [];
+
+  const scanFile = async (abs) => {
+    if (!CODE_EXTS.has(path.extname(abs))) return;
+    let content;
+    try {
+      content = await fs.readFile(abs, 'utf8');
+    } catch {
+      return;
+    }
+    if (content.length > 1_500_000) return;
+    // Must reference Hono somewhere in the file to avoid false positives
+    // from Express/Fastify files using the same `.get(...)` pattern.
+    if (!content.includes('Hono') && !content.includes('hono')) return;
+
+    const re1 = new RegExp(HONO_PATTERN.source, HONO_PATTERN.flags);
+    let m;
+    while ((m = re1.exec(content)) !== null) {
+      const method = m[1].toUpperCase();
+      const routePath = m[2];
+      const key = `${method}:${routePath}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      routes.push({ method, path: routePath });
+      if (routes.length >= ROUTE_LIMIT) return;
+    }
+  };
+
+  for (const base of candidateDirs) {
+    const dir = path.join(rootPath, base);
+    let files;
+    try {
+      files = await walk(dir);
+    } catch {
+      continue;
+    }
+    for (const abs of files) {
+      await scanFile(abs);
+      if (routes.length >= ROUTE_LIMIT) return { routes };
+    }
+  }
+
+  // Scan entry files at root and src/ level
+  for (const baseDir of ['', 'src']) {
+    for (const entry of ['index', 'server', 'app', 'main']) {
+      for (const ext of ['.ts', '.js', '.mjs', '.cjs']) {
+        await scanFile(path.join(rootPath, baseDir, `${entry}${ext}`));
+        if (routes.length >= ROUTE_LIMIT) return { routes };
+      }
+    }
+  }
+
+  return { routes };
+}
+
+// ---------------------------------------------------------------------------
+// Route detection — NestJS
+// ---------------------------------------------------------------------------
+const NEST_DECORATOR =
+  /@(Get|Post|Put|Delete|Patch|Head|Options)\s*\(\s*['"`]?([^'"`\)]*)/gi;
+const NEST_CONTROLLER =
+  /@Controller\s*\(\s*['"`]([^'"`]+)/gi;
+
+async function scanNestRoutes(rootPath) {
+  const ROUTE_LIMIT = 100;
+  const candidateDirs = ['src', 'src/modules', 'src/controllers', 'src/api', 'app'];
+  const seen = new Set();
+  const routes = [];
+
+  const scanFile = async (abs) => {
+    if (!CODE_EXTS.has(path.extname(abs))) return;
+    let content;
+    try {
+      content = await fs.readFile(abs, 'utf8');
+    } catch {
+      return;
+    }
+    if (content.length > 1_500_000) return;
+
+    // Find @Controller prefix
+    const controllerRe = new RegExp(NEST_CONTROLLER.source, NEST_CONTROLLER.flags);
+    const controllerMatch = controllerRe.exec(content);
+    const controllerPrefix = controllerMatch
+      ? '/' + controllerMatch[1].replace(/^\/+|\/+$/g, '')
+      : '';
+
+    // Find route decorators
+    const decoratorRe = new RegExp(NEST_DECORATOR.source, NEST_DECORATOR.flags);
+    let m;
+    while ((m = decoratorRe.exec(content)) !== null) {
+      const method = m[1].toUpperCase();
+      const rawPath = (m[2] || '').trim().replace(/['"`]/g, '');
+      const suffix = rawPath ? '/' + rawPath.replace(/^\/+/, '') : '';
+      const routePath = (controllerPrefix + suffix) || '/';
+      const key = `${method}:${routePath}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      routes.push({ method, path: routePath });
+      if (routes.length >= ROUTE_LIMIT) return;
+    }
+  };
+
+  for (const base of candidateDirs) {
+    const dir = path.join(rootPath, base);
+    let files;
+    try {
+      files = await walk(dir);
+    } catch {
+      continue;
+    }
+    for (const abs of files) {
+      await scanFile(abs);
+      if (routes.length >= ROUTE_LIMIT) return { routes };
+    }
+  }
+
+  return { routes };
+}
+
 // ---------------------------------------------------------------------------
 // Route detection (Next.js App + Pages router)
 // ---------------------------------------------------------------------------
@@ -139,17 +561,95 @@ function routePathFromPagesRouterFile(relFile) {
   return '/' + segs.join('/');
 }
 
-async function detectRoutes(rootPath, framework) {
-  if (!framework || framework.name !== 'nextjs') {
-    if (
-      framework &&
-      ['express', 'fastify', 'nestjs'].includes(framework.name)
-    ) {
-      return {
-        routes: [],
-        note: `detection_not_implemented_for_${framework.name}`,
-      };
+// ---------------------------------------------------------------------------
+// Mobile screen/route detection
+// ---------------------------------------------------------------------------
+
+// React Native: Stack.Screen, Tab.Screen, Drawer.Screen name patterns
+const RN_SCREEN_RE = /(?:Stack|Tab|Drawer)\.Screen\s+name\s*=\s*['"`]([^'"`]+)['"`]/g;
+// iOS: UIViewController subclasses
+const IOS_VC_RE = /class\s+(\w+)\s*:\s*(?:UI)?ViewController/g;
+// Android: Activity / Fragment classes
+const ANDROID_ACTIVITY_RE = /class\s+(\w+)\s*:\s*(?:AppCompat)?Activity\b/g;
+const ANDROID_FRAGMENT_RE = /class\s+(\w+)\s*:\s*(?:Fragment)\b/g;
+// Flutter: StatelessWidget / StatefulWidget
+const FLUTTER_WIDGET_RE = /class\s+(\w+)\s+extends\s+Stateful?Widget\b/g;
+
+async function scanMobileScreens(rootPath, framework) {
+  const SCREEN_LIMIT = 100;
+  const seen = new Set();
+  const routes = [];
+
+  let files;
+  try {
+    files = await walk(rootPath);
+  } catch {
+    return { routes: [] };
+  }
+
+  for (const abs of files) {
+    const ext = path.extname(abs);
+    if (!MOBILE_CODE_EXTS.has(ext)) continue;
+    let content;
+    try {
+      content = await fs.readFile(abs, 'utf8');
+    } catch {
+      continue;
+    }
+    if (content.length > 1_500_000) continue;
+
+    const rel = path.relative(rootPath, abs);
+    let patterns = [];
+
+    if (framework.name === 'react-native') {
+      patterns = [RN_SCREEN_RE];
+    } else if (framework.name === 'ios-swift') {
+      patterns = [IOS_VC_RE];
+    } else if (framework.name === 'android-kotlin') {
+      patterns = [ANDROID_ACTIVITY_RE, ANDROID_FRAGMENT_RE];
+    } else if (framework.name === 'flutter') {
+      patterns = [FLUTTER_WIDGET_RE];
     }
+
+    for (const pattern of patterns) {
+      const re = new RegExp(pattern.source, pattern.flags);
+      let m;
+      while ((m = re.exec(content)) !== null) {
+        const name = m[1];
+        if (seen.has(name)) continue;
+        seen.add(name);
+        routes.push({ method: 'SCREEN', path: name, file: rel });
+        if (routes.length >= SCREEN_LIMIT) return { routes };
+      }
+    }
+  }
+
+  routes.sort((a, b) => a.path.localeCompare(b.path));
+  return { routes };
+}
+
+async function detectRoutes(rootPath, framework) {
+  if (!framework) return { routes: [] };
+
+  // Mobile frameworks — detect screens instead of HTTP routes
+  if (['react-native', 'ios-swift', 'android-kotlin', 'flutter'].includes(framework.name)) {
+    return scanMobileScreens(rootPath, framework);
+  }
+
+  if (framework.name === 'express') {
+    return scanExpressRoutes(rootPath);
+  }
+  if (framework.name === 'fastify') {
+    return scanFastifyRoutes(rootPath);
+  }
+  if (framework.name === 'hono') {
+    return scanHonoRoutes(rootPath);
+  }
+  if (framework.name === 'nestjs') {
+    return scanNestRoutes(rootPath);
+  }
+
+  if (framework.name !== 'nextjs') {
     return { routes: [] };
   }
 
@@ -727,7 +1227,7 @@ async function extractFolderStructureHints(rootPath, framework) {
         /* skip */
       }
     }
-  } else if (framework && ['express', 'fastify', 'nestjs'].includes(framework.name)) {
+  } else if (framework && ['express', 'fastify', 'hono', 'nestjs'].includes(framework.name)) {
     for (const base of ['src/routes', 'routes', 'src/controllers', 'src/modules']) {
       const root = path.join(rootPath, base);
       try {
@@ -867,11 +1367,17 @@ async function scanRepo(rootPath, { log = () => {} } = {}) {
   }
   const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
 
-  const framework = detectFramework(deps);
+  const framework = detectFramework(deps, abs);
   log(`[scan] framework: ${framework.name} ${framework.version || ''}`);
 
+  const isMobile = ['react-native', 'ios-swift', 'android-kotlin', 'flutter'].includes(framework.name);
+
   const schemaHints = await detectSchemaHints(abs);
-  const orm = detectORM(deps, schemaHints);
+  let orm = detectORM(deps, schemaHints);
+  // For non-package.json mobile projects, fall back to filesystem-based ORM detection
+  if (isMobile && orm.name === 'unknown') {
+    orm = detectMobileORM(abs, framework);
+  }
   log(`[scan] orm: ${orm.name}`);
 
   const auth = detectAuth(deps);
@@ -886,7 +1392,13 @@ async function scanRepo(rootPath, { log = () => {} } = {}) {
   }
   log(`[scan] walk root: ${path.relative(abs, scanRoot) || '.'}`);
 
-  const { routes, note: routeNote } = await detectRoutes(scanRoot, framework);
+  // Next.js routes live under src/app or app/ (walk handles both from scanRoot).
+  // Express/Fastify/Hono/NestJS scanners specify their own candidate dirs
+  // relative to project root, so pass `abs` for those frameworks.
+  // Mobile frameworks also scan from project root for screen detection.
+  const routeScanRoot =
+    framework && ['express', 'fastify', 'hono', 'nestjs', 'react-native', 'ios-swift', 'android-kotlin', 'flutter'].includes(framework.name) ? abs : scanRoot;
+  const { routes, note: routeNote } = await detectRoutes(routeScanRoot, framework);
   log(`[scan] routes: ${routes.length}${routeNote ? ` (${routeNote})` : ''}`);
 
   const mutations = await detectMutations(scanRoot);
@@ -923,12 +1435,15 @@ async function scanRepo(rootPath, { log = () => {} } = {}) {
     /* skip */
   }
 
-  const normalizedRoutes = (routes || []).flatMap((r) =>
-    (r.methods && r.methods.length ? r.methods : ['*']).map((method) => ({
+  const normalizedRoutes = (routes || []).flatMap((r) => {
+    // Express/Fastify/NestJS routes have { method, path } directly.
+    if (r.method) return [{ method: r.method, path: r.path }];
+    // Next.js routes have { methods: [...], path, file }.
+    return (r.methods && r.methods.length ? r.methods : ['*']).map((method) => ({
       method,
       path: r.path,
-    })),
-  );
+    }));
+  });
 
   const normalizedMutations = (mutations || []).map((m) => ({
     file: m.file,
@@ -971,8 +1486,13 @@ module.exports = {
   SCAN_VERSION,
   detectFramework,
   detectORM,
+  detectMobileORM,
   detectAuth,
   detectRoutes,
+  scanExpressRoutes,
+  scanFastifyRoutes,
+  scanNestRoutes,
+  scanMobileScreens,
   detectMutations,
   scanRepo,
   // Phase 18.6 A1