@vibecheckai/cli 3.5.1 → 3.5.2

package/bin/runners/lib/route-detection.js

@@ -1018,108 +1018,177 @@ async function resolvePythonClientRefs(repoRoot) {
 // MAIN: RESOLVE ALL ROUTES
 // ============================================================================
 
-async function resolveAllRoutes(repoRoot) {
+// Smart orchestration: only run expensive scanners when signals say they matter.
+// You can force the old behavior by setting:
+//   VIBECHECK_ROUTE_SCAN_MODE=deep
+// or calling resolveAllRoutes(repoRoot, { mode: "deep" }).
+async function resolveAllRoutes(repoRoot, opts = {}) {
+  const mode = (opts.mode || process.env.VIBECHECK_ROUTE_SCAN_MODE || "smart").toLowerCase();
+  const verbose = !!(opts.verbose || process.env.VIBECHECK_VERBOSE_ROUTES);
+  const skipExpress = !!opts.skipExpress; // When true, skip Express (handled by optimized extractor)
+
   const frameworks = await detectFrameworks(repoRoot);
-  
+
   const allRoutes = [];
   const allClientRefs = [];
   const gaps = [];
-  
-  console.log(`  📦 Detected frameworks: ${frameworks.length > 0 ? frameworks.join(", ") : "none detected, scanning all"}`);
-  
-  // Always scan for routes regardless of detected frameworks
-  // JavaScript/TypeScript frameworks
+
+  const fw = new Set(frameworks.map((x) => String(x).toLowerCase()));
+
+  // Lightweight language presence checks (avoid globbing millions of files)
+  const has = {
+    python: exists(path.join(repoRoot, "requirements.txt")) || exists(path.join(repoRoot, "pyproject.toml")),
+    ruby: exists(path.join(repoRoot, "Gemfile")),
+    go: exists(path.join(repoRoot, "go.mod")),
+  };
+
+  // If we don't have explicit deps, do a quick filesystem sniff.
+  // (We intentionally keep this cheap: just check for any matching file.)
+  if (!has.python) {
+    try {
+      const py = await fg(["**/*.py"], { cwd: repoRoot, absolute: true, ignore: ["**/node_modules/**", "**/.venv/**", "**/venv/**", "**/.git/**", "**/dist/**", "**/build/**"] , deep: 4 });
+      has.python = py.length > 0;
+    } catch {}
+  }
+
+  const shouldDeepScan = mode === "deep";
+
+  if (verbose) {
+    const list = frameworks.length ? frameworks.join(", ") : "none";
+    console.log(`  📦 Detected frameworks: ${list} (mode=${mode})`);
+  }
+
+  // JS/TS frameworks
+  const shouldExpress = shouldDeepScan || fw.has("express");
+  const shouldHono = shouldDeepScan || fw.has("hono");
+  const shouldKoa = shouldDeepScan || fw.has("koa");
+  const shouldNest = shouldDeepScan || fw.has("nestjs");
+
+  // Python frameworks
+  const shouldFlask = shouldDeepScan || fw.has("flask") || (has.python && fw.size === 0);
+  const shouldFastAPI = shouldDeepScan || fw.has("fastapi") || (has.python && fw.size === 0);
+  const shouldDjango = shouldDeepScan || fw.has("django") || (has.python && fw.size === 0);
+
+  // Go frameworks
+  const shouldGo = shouldDeepScan || fw.has("go") || has.go;
+
+  // OpenAPI/GraphQL are cheap and high-signal, so include when present.
+  const shouldOpenAPI = shouldDeepScan || fw.has("openapi");
+  const shouldGraphQL = shouldDeepScan || fw.has("graphql");
+
+  // If nothing detected and not deep mode, keep JS scanning conservative.
+  // (Truthpack already handles Next/Fastify separately; this is a safety net.)
+  const unknownRepo = fw.size === 0 && !has.python && !has.go && !has.ruby;
+  const safeJsScan = shouldDeepScan || !unknownRepo;
+
   try {
-    const expressRoutes = await resolveExpressRoutes(repoRoot);
-    if (expressRoutes.length > 0) {
-      console.log(`     ✓ Express: ${expressRoutes.length} routes`);
-      allRoutes.push(...expressRoutes);
+    if (safeJsScan && shouldExpress && !skipExpress) {
+      const expressRoutes = await resolveExpressRoutes(repoRoot);
+      if (expressRoutes.length > 0) {
+        if (verbose) console.log(`     ✓ Express: ${expressRoutes.length} routes`);
+        allRoutes.push(...expressRoutes);
+      }
+    } else if (skipExpress && verbose) {
+      console.log(`     ⏭️  Express: skipped (using optimized extractor)`);
     }
   } catch (e) { gaps.push({ kind: "express_scan_error", error: e.message }); }
-  
+
   try {
-    const honoRoutes = await resolveHonoRoutes(repoRoot);
-    if (honoRoutes.length > 0) {
-      console.log(`     ✓ Hono: ${honoRoutes.length} routes`);
-      allRoutes.push(...honoRoutes);
+    if (safeJsScan && shouldHono) {
+      const honoRoutes = await resolveHonoRoutes(repoRoot);
+      if (honoRoutes.length > 0) {
+        if (verbose) console.log(`     ✓ Hono: ${honoRoutes.length} routes`);
+        allRoutes.push(...honoRoutes);
+      }
     }
   } catch (e) { gaps.push({ kind: "hono_scan_error", error: e.message }); }
-  
+
   try {
-    const koaRoutes = await resolveKoaRoutes(repoRoot);
-    if (koaRoutes.length > 0) {
-      console.log(`     ✓ Koa: ${koaRoutes.length} routes`);
-      allRoutes.push(...koaRoutes);
+    if (safeJsScan && shouldKoa) {
+      const koaRoutes = await resolveKoaRoutes(repoRoot);
+      if (koaRoutes.length > 0) {
+        if (verbose) console.log(`     ✓ Koa: ${koaRoutes.length} routes`);
+        allRoutes.push(...koaRoutes);
+      }
     }
   } catch (e) { gaps.push({ kind: "koa_scan_error", error: e.message }); }
-  
-  // Python frameworks
+
+  // NestJS route extraction is expensive and flaky; only run it when clearly present.
+  if (shouldNest) {
+    // (No dedicated resolver today; keep placeholder for future.)
+  }
+
   try {
-    const flaskRoutes = await resolveFlaskRoutes(repoRoot);
-    if (flaskRoutes.length > 0) {
-      console.log(`     ✓ Flask: ${flaskRoutes.length} routes`);
-      allRoutes.push(...flaskRoutes);
+    if (shouldFlask) {
+      const flaskRoutes = await resolveFlaskRoutes(repoRoot);
+      if (flaskRoutes.length > 0) {
+        if (verbose) console.log(`     ✓ Flask: ${flaskRoutes.length} routes`);
+        allRoutes.push(...flaskRoutes);
+      }
     }
   } catch (e) { gaps.push({ kind: "flask_scan_error", error: e.message }); }
-  
+
   try {
-    const fastapiRoutes = await resolveFastAPIRoutes(repoRoot);
-    if (fastapiRoutes.length > 0) {
-      console.log(`     ✓ FastAPI: ${fastapiRoutes.length} routes`);
-      allRoutes.push(...fastapiRoutes);
+    if (shouldFastAPI) {
+      const fastapiRoutes = await resolveFastAPIRoutes(repoRoot);
+      if (fastapiRoutes.length > 0) {
+        if (verbose) console.log(`     ✓ FastAPI: ${fastapiRoutes.length} routes`);
+        allRoutes.push(...fastapiRoutes);
+      }
     }
   } catch (e) { gaps.push({ kind: "fastapi_scan_error", error: e.message }); }
-  
+
   try {
-    const djangoRoutes = await resolveDjangoRoutes(repoRoot);
-    if (djangoRoutes.length > 0) {
-      console.log(`     ✓ Django: ${djangoRoutes.length} routes`);
-      allRoutes.push(...djangoRoutes);
+    if (shouldDjango) {
+      const djangoRoutes = await resolveDjangoRoutes(repoRoot);
+      if (djangoRoutes.length > 0) {
+        if (verbose) console.log(`     ✓ Django: ${djangoRoutes.length} routes`);
+        allRoutes.push(...djangoRoutes);
+      }
     }
   } catch (e) { gaps.push({ kind: "django_scan_error", error: e.message }); }
-  
-  // Python client refs
+
   try {
-    const pythonRefs = await resolvePythonClientRefs(repoRoot);
-    if (pythonRefs.length > 0) {
-      console.log(`     ✓ Python client refs: ${pythonRefs.length}`);
-      allClientRefs.push(...pythonRefs);
+    if (has.python && (shouldDeepScan || shouldFlask || shouldFastAPI || shouldDjango)) {
+      const pythonRefs = await resolvePythonClientRefs(repoRoot);
+      if (pythonRefs.length > 0) {
+        if (verbose) console.log(`     ✓ Python client refs: ${pythonRefs.length}`);
+        allClientRefs.push(...pythonRefs);
+      }
     }
   } catch (e) { gaps.push({ kind: "python_client_scan_error", error: e.message }); }
-  
-  // OpenAPI/Swagger specs (high accuracy)
+
   try {
-    const openapiRoutes = await resolveOpenAPIRoutes(repoRoot);
-    if (openapiRoutes.length > 0) {
-      console.log(`     ✓ OpenAPI spec: ${openapiRoutes.length} routes`);
-      allRoutes.push(...openapiRoutes);
+    if (shouldOpenAPI) {
+      const openapiRoutes = await resolveOpenAPIRoutes(repoRoot);
+      if (openapiRoutes.length > 0) {
+        if (verbose) console.log(`     ✓ OpenAPI spec: ${openapiRoutes.length} routes`);
+        allRoutes.push(...openapiRoutes);
+      }
     }
   } catch (e) { gaps.push({ kind: "openapi_scan_error", error: e.message }); }
-  
-  // GraphQL endpoints
+
   try {
-    const graphqlRoutes = await resolveGraphQLRoutes(repoRoot);
-    if (graphqlRoutes.length > 0) {
-      console.log(`     ✓ GraphQL: ${graphqlRoutes.length} endpoints`);
-      allRoutes.push(...graphqlRoutes);
+    if (shouldGraphQL) {
+      const graphqlRoutes = await resolveGraphQLRoutes(repoRoot);
+      if (graphqlRoutes.length > 0) {
+        if (verbose) console.log(`     ✓ GraphQL: ${graphqlRoutes.length} endpoints`);
+        allRoutes.push(...graphqlRoutes);
+      }
     }
   } catch (e) { gaps.push({ kind: "graphql_scan_error", error: e.message }); }
-  
-  // Go frameworks (Gin, Echo, Fiber, Chi, Gorilla, stdlib)
+
   try {
-    const goRoutes = await resolveGoRoutes(repoRoot);
-    if (goRoutes.length > 0) {
-      console.log(`     ✓ Go: ${goRoutes.length} routes`);
-      allRoutes.push(...goRoutes);
+    if (shouldGo) {
+      const goRoutes = await resolveGoRoutes(repoRoot);
+      if (goRoutes.length > 0) {
+        if (verbose) console.log(`     ✓ Go: ${goRoutes.length} routes`);
+        allRoutes.push(...goRoutes);
+      }
     }
   } catch (e) { gaps.push({ kind: "go_scan_error", error: e.message }); }
-  
-  return {
-    routes: allRoutes,
-    clientRefs: allClientRefs,
-    gaps,
-    frameworks
-  };
+
+  return { routes: allRoutes, clientRefs: allClientRefs, gaps, frameworks };
 }
 
 module.exports = {