vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/lib/engine/express-extractor.js

@@ -0,0 +1,208 @@
+// bin/runners/lib/engine/express-extractor.js
+// Optimized Express route extraction using RepoIndex
+
+const path = require("path");
+const crypto = require("crypto");
+const traverse = require("@babel/traverse").default;
+const t = require("@babel/types");
+const { globalASTCache } = require("./ast-cache");
+
+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 canonicalizePath(p) {
+  let s = String(p || "").trim();
+  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
+  };
+}
+
+const EXPRESS_METHODS = new Set(["get", "post", "put", "patch", "delete", "options", "head", "all", "use"]);
+const EXPRESS_NAMES = new Set(["app", "router", "express", "server"]);
+
+function evalStaticString(node, constMap = new Map(), depth = 0) {
+  if (!node || depth > 5) 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) && constMap.has(node.name)) {
+    return evalStaticString(constMap.get(node.name), constMap, depth + 1);
+  }
+  if (t.isBinaryExpression(node, { operator: "+" })) {
+    const l = evalStaticString(node.left, constMap, depth + 1);
+    const r = evalStaticString(node.right, constMap, depth + 1);
+    if (typeof l === "string" && typeof r === "string") return l + r;
+  }
+  return null;
+}
+
+/**
+ * Extract Express routes using RepoIndex
+ * @param {import('./repo-index').RepoIndex} index
+ * @param {Object} stats
+ * @returns {Array}
+ */
+function extractExpressRoutes(index, stats) {
+  if (!index.hasFramework("express")) return [];
+
+  // Use token prefilter - only scan files that mention express/app/router
+  const candidateAbs = index.getByAnyToken(["express", "app.get", "app.post", "router.get", "router.post"]);
+  
+  // Filter to JS/TS files, exclude tests
+  const jsExtensions = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+  const files = candidateAbs.filter(abs => {
+    const ext = path.extname(abs).toLowerCase();
+    if (!jsExtensions.has(ext)) return false;
+    const rel = index.relPath(abs);
+    if (rel.includes("/test/") || rel.includes("/tests/") || rel.includes("/__tests__/")) return false;
+    if (rel.includes(".test.") || rel.includes(".spec.")) return false;
+    if (rel.endsWith(".d.ts")) return false;
+    return true;
+  });
+
+  const routes = [];
+
+  for (const fileAbs of files) {
+    const fileRel = index.relPath(fileAbs);
+    const content = index.getContent(fileAbs);
+    if (!content) continue;
+
+    // Quick content check
+    if (!content.includes("express") && !content.includes("app.") && !content.includes("router.")) continue;
+
+    const { ast, error } = globalASTCache.parse(content, fileAbs);
+    if (error || !ast) {
+      stats.parseErrors++;
+      continue;
+    }
+
+    const constMap = new Map();
+    const routerPrefixes = new Map();
+
+    try {
+      // First pass: collect constants and router.use prefixes
+      traverse(ast, {
+        VariableDeclarator(p) {
+          if (t.isIdentifier(p.node.id) && p.node.init) {
+            const v = evalStaticString(p.node.init, constMap);
+            if (typeof v === "string") constMap.set(p.node.id.name, p.node.init);
+
+            // Detect express/router assignment
+            if (t.isCallExpression(p.node.init)) {
+              const callee = p.node.init.callee;
+              if (t.isIdentifier(callee, { name: "express" }) ||
+                  (t.isMemberExpression(callee) && t.isIdentifier(callee.property, { name: "Router" }))) {
+                EXPRESS_NAMES.add(p.node.id.name);
+              }
+            }
+          }
+        },
+        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 method = callee.property.name;
+
+          // app.use("/api", router) - track prefix
+          if (method === "use" && EXPRESS_NAMES.has(obj)) {
+            const args = p.node.arguments;
+            if (args.length >= 2) {
+              const prefixArg = args[0];
+              const routerArg = args[1];
+              const prefix = evalStaticString(prefixArg, constMap);
+              if (typeof prefix === "string" && t.isIdentifier(routerArg)) {
+                routerPrefixes.set(routerArg.name, prefix);
+              }
+            }
+          }
+        }
+      });
+
+      // Second pass: extract routes
+      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 method = callee.property.name.toLowerCase();
+
+          if (!EXPRESS_NAMES.has(obj) && !routerPrefixes.has(obj)) return;
+          if (!EXPRESS_METHODS.has(method)) return;
+
+          // Get the path argument
+          const pathArg = p.node.arguments[0];
+          const routePath = evalStaticString(pathArg, constMap);
+          if (!routePath) return;
+
+          // Skip middleware-only patterns
+          if (method === "use" && !routePath.startsWith("/")) return;
+
+          // Get prefix for this router
+          const prefix = routerPrefixes.get(obj) || "/";
+          const fullPath = joinPaths(prefix, routePath);
+
+          const ev = evidenceFromContent(content, fileRel, p.node.loc, `Express ${method.toUpperCase()}("${routePath}")`);
+
+          routes.push({
+            method: method === "use" ? "*" : canonicalizeMethod(method),
+            path: fullPath,
+            handler: fileRel,
+            confidence: "med",
+            framework: "express",
+            evidence: ev ? [ev] : []
+          });
+        }
+      });
+    } catch {
+      stats.parseErrors++;
+    }
+  }
+
+  return routes;
+}
+
+module.exports = {
+  extractExpressRoutes,
+  canonicalizeMethod,
+  canonicalizePath,
+  joinPaths,
+};