create-backlist 7.0.1 → 7.3.1

package/src/analyzer.js

@@ -1,496 +1,751 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
-import fs from "fs-extra";
-import path from "node:path";
-import { glob } from "glob";
-
-import parser from "@babel/parser";
-import _traverse from "@babel/traverse";
-const traverse = _traverse.default || _traverse;
-
-const HTTP_METHODS = new Set(["get", "post", "put", "patch", "delete"]);
-
-// -------------------------
-// Utils
-// -------------------------
-function normalizeSlashes(p) {
-  return String(p || "").replace(/\\/g, "/");
-}
-
-function toTitleCase(str) {
-  if (!str) return "Default";
-  return String(str)
-    .replace(/[-_]+(\w)/g, (_, c) => c.toUpperCase())
-    .replace(/^\w/, (c) => c.toUpperCase())
-    .replace(/[^a-zA-Z0-9]/g, "");
-}
-
-// Convert `/api/users/{id}` -> `/api/users/:id`
-function normalizeRouteForBackend(urlValue) {
-  return String(urlValue || "").replace(/\{(\w+)\}/g, ":$1");
-}
-
-function extractApiPath(urlValue) {
-  // supports:
-  // - /api/...
-  // - http://localhost:5000/api/...
-  if (!urlValue) return null;
-  const idx = urlValue.indexOf("/api/");
-  if (idx === -1) return null;
-  return urlValue.slice(idx); // => /api/...
-}
-
-function extractPathParams(route) {
-  const params = [];
-  const re = /[:{]([a-zA-Z0-9_]+)[}]/g;
-  let m;
-  while ((m = re.exec(route))) params.push(m[1]);
-  return Array.from(new Set(params));
-}
-
-function extractQueryParamsFromUrl(urlValue) {
-  try {
-    const qIndex = urlValue.indexOf("?");
-    if (qIndex === -1) return [];
-    const qs = urlValue.slice(qIndex + 1);
-    return qs
-      .split("&")
-      .map((p) => p.split("=")[0])
-      .filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-
-function deriveControllerNameFromUrl(urlValue) {
-  const apiPath = extractApiPath(urlValue) || urlValue;
-  const parts = String(apiPath).split("/").filter(Boolean); // ["api","v1","products"]
-  const apiIndex = parts.indexOf("api");
-
-  let seg = null;
-  if (apiIndex >= 0) {
-    seg = parts[apiIndex + 1] || null;
-
-    // skip version segment (v1, v2, v10...)
-    if (seg && /^v\d+$/i.test(seg)) {
-      seg = parts[apiIndex + 2] || seg;
-    }
-  } else {
-    seg = parts[0] || null;
-  }
-
-  return toTitleCase(seg);
-}
-
-function deriveActionName(method, route) {
-  const cleaned = String(route).replace(/^\/api\//, "/").replace(/[/:{}-]/g, " ");
-  const last = cleaned.trim().split(/\s+/).filter(Boolean).pop() || "Action";
-  return `${String(method).toLowerCase()}${toTitleCase(last)}`;
-}
-
-// -------------------------
-// URL extraction
-// -------------------------
-function getUrlValue(urlNode) {
-  if (!urlNode) return null;
-
-  if (urlNode.type === "StringLiteral") return urlNode.value;
-
-  if (urlNode.type === "TemplateLiteral") {
-    // `/api/users/${id}` -> `/api/users/{id}` or `{param1}`
-    const quasis = urlNode.quasis || [];
-    const exprs = urlNode.expressions || [];
-    let out = "";
-    for (let i = 0; i < quasis.length; i++) {
-      out += quasis[i].value.raw;
-      if (exprs[i]) {
-        if (exprs[i].type === "Identifier") out += `{${exprs[i].name}}`;
-        else out += `{param${i + 1}}`;
-      }
-    }
-    return out;
-  }
-
-  return null;
-}
-
-// -------------------------
-// axios-like detection
-// -------------------------
-function detectAxiosLikeMethod(node) {
-  // axios.get(...) / api.get(...) / httpClient.post(...) etc
-  if (!node.callee || node.callee.type !== "MemberExpression") return null;
-
-  const prop = node.callee.property;
-  if (!prop || prop.type !== "Identifier") return null;
-
-  const name = prop.name.toLowerCase();
-  if (!HTTP_METHODS.has(name)) return null;
-
-  return name.toUpperCase();
-}
-
-// -------------------------
-// Request body schema (simple + identifier tracing)
-// -------------------------
-function inferTypeFromNode(node) {
-  if (!node) return "String";
-  switch (node.type) {
-    case "StringLiteral":
-      return "String";
-    case "NumericLiteral":
-      return "Number";
-    case "BooleanLiteral":
-      return "Boolean";
-    case "NullLiteral":
-      return "String";
-    default:
-      return "String";
-  }
-}
-
-function extractObjectSchema(objExpr) {
-  const schemaFields = {};
-  if (!objExpr || objExpr.type !== "ObjectExpression") return null;
-
-  for (const prop of objExpr.properties) {
-    if (prop.type !== "ObjectProperty") continue;
-
-    const key =
-      prop.key.type === "Identifier"
-        ? prop.key.name
-        : prop.key.type === "StringLiteral"
-          ? prop.key.value
-          : null;
-
-    if (!key) continue;
-    schemaFields[key] = inferTypeFromNode(prop.value);
-  }
-  return schemaFields;
-}
-
-function resolveIdentifierToInit(callPath, identifierName) {
-  try {
-    const binding = callPath.scope.getBinding(identifierName);
-    if (!binding) return null;
-    const declPath = binding.path;
-    if (!declPath || !declPath.node) return null;
-
-    if (declPath.node.type === "VariableDeclarator") return declPath.node.init || null;
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-function isJSONStringifyCall(node) {
-  // JSON.stringify(x)
-  return (
-    node &&
-    node.type === "CallExpression" &&
-    node.callee &&
-    node.callee.type === "MemberExpression" &&
-    node.callee.object &&
-    node.callee.object.type === "Identifier" &&
-    node.callee.object.name === "JSON" &&
-    node.callee.property &&
-    node.callee.property.type === "Identifier" &&
-    node.callee.property.name === "stringify"
-  );
-}
-
-// -------------------------
-// DB insights: guess db + infer models + seeds
-// -------------------------
-function guessDbTypeFromRepo(rootDir, endpoints = []) {
-  try {
-    const pkgPath = path.join(rootDir, "package.json");
-    if (!fs.existsSync(pkgPath)) return heuristicallyGuessDB(endpoints);
-
-    const pkg = fs.readJsonSync(pkgPath);
-    const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
-
-    if (deps.mongoose || deps.mongodb) return "mongodb-mongoose";
-    if (deps.prisma || deps["@prisma/client"]) return "sql-prisma";
-    if (deps.sequelize) return "sql-sequelize";
-    if (deps.typeorm) return "sql-typeorm";
-
-    return heuristicallyGuessDB(endpoints);
-  } catch {
-    return heuristicallyGuessDB(endpoints);
-  }
-}
-
-function heuristicallyGuessDB(endpoints) {
-  // Free Tier / Default Intelligence:
-  // Analyze data complexity. If highly nested schemas are prominent, default NoSQL.
-  // If many flat, relational-looking fields exist, default SQL.
-  let maxNesting = 0;
-  for (const ep of endpoints) {
-    if (ep.schemaFields && Object.keys(ep.schemaFields).length > 6) {
-       maxNesting++;
-    }
-  }
-  return maxNesting > 3 ? "mongodb-mongoose" : "sql-prisma";
-}
-
-function inferModelsFromEndpoints(endpoints) {
-  const models = new Map();
-
-  for (const ep of endpoints) {
-    const modelName = ep.controllerName || "Default";
-
-    if (!models.has(modelName)) {
-      models.set(modelName, {
-        name: modelName,
-        fields: {},          // merged fields from bodies
-        sources: new Set(),
-        endpoints: [],
-      });
-    }
-
-    const m = models.get(modelName);
-    m.endpoints.push({ method: ep.method, route: ep.route });
-    if (ep.sourceFile) m.sources.add(ep.sourceFile);
-
-    const fields = ep.schemaFields || (ep.requestBody && ep.requestBody.fields) || null;
-    if (fields) {
-      for (const [k, t] of Object.entries(fields)) {
-        if (!m.fields[k]) m.fields[k] = t || "String";
-      }
-    }
-  }
-
-  return Array.from(models.values()).map((m) => ({
-    name: m.name,
-    fields: m.fields,
-    sources: Array.from(m.sources),
-    endpoints: m.endpoints,
-  }));
-}
-
-function seedValueForType(t) {
-  if (t === "Number") return 1;
-  if (t === "Boolean") return true;
-  return "test"; // String default
-}
-
-function generateSeedsFromModels(models, perModel = 3) {
-  return models.map((m) => {
-    const rows = [];
-    for (let i = 0; i < perModel; i++) {
-      const obj = {};
-      for (const [k, t] of Object.entries(m.fields || {})) {
-        obj[k] = seedValueForType(t);
-      }
-      rows.push(obj);
-    }
-    return { model: m.name, rows };
-  });
-}
-
-// -------------------------
-// MAIN frontend analyzer
-// -------------------------
-export async function analyzeFrontend(srcPath) {
-  if (!srcPath) throw new Error("analyzeFrontend: srcPath is required");
-  if (!fs.existsSync(srcPath)) {
-    throw new Error(`The source directory '${srcPath}' does not exist.`);
-  }
-
-  const files = await glob(`${normalizeSlashes(srcPath)}/**/*.{js,ts,jsx,tsx}`, {
-    ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.next/**", "**/coverage/**"],
-  });
-
-  const endpoints = new Map();
-
-  for (const file of files) {
-    let code;
-    try {
-      code = await fs.readFile(file, "utf-8");
-    } catch {
-      continue;
-    }
-
-    let ast;
-    try {
-      ast = parser.parse(code, { sourceType: "module", plugins: ["jsx", "typescript"] });
-    } catch {
-      continue;
-    }
-
-    traverse(ast, {
-      CallExpression(callPath) {
-        const node = callPath.node;
-
-        const isFetch = node.callee.type === "Identifier" && node.callee.name === "fetch";
-        const axiosMethod = detectAxiosLikeMethod(node);
-
-        if (!isFetch && !axiosMethod) return;
-
-        let urlValue = null;
-        let method = "GET";
-        let schemaFields = null;
-
-        // ---- fetch(url, options) ----
-        if (isFetch) {
-          urlValue = getUrlValue(node.arguments[0]);
-          const optionsNode = node.arguments[1];
-
-          if (optionsNode && optionsNode.type === "ObjectExpression") {
-            const methodProp = optionsNode.properties.find(
-              (p) =>
-                p.type === "ObjectProperty" &&
-                p.key.type === "Identifier" &&
-                p.key.name === "method"
-            );
-            if (methodProp && methodProp.value.type === "StringLiteral") {
-              method = methodProp.value.value.toUpperCase();
-            }
-
-            if (["POST", "PUT", "PATCH"].includes(method)) {
-              const bodyProp = optionsNode.properties.find(
-                (p) =>
-                  p.type === "ObjectProperty" &&
-                  p.key.type === "Identifier" &&
-                  p.key.name === "body"
-              );
-
-              if (bodyProp) {
-                const v = bodyProp.value;
-
-                if (isJSONStringifyCall(v)) {
-                  const arg0 = v.arguments[0];
-
-                  if (arg0?.type === "ObjectExpression") {
-                    schemaFields = extractObjectSchema(arg0);
-                  } else if (arg0?.type === "Identifier") {
-                    const init = resolveIdentifierToInit(callPath, arg0.name);
-                    if (init?.type === "ObjectExpression") schemaFields = extractObjectSchema(init);
-                  }
-                }
-              }
-            }
-          }
-        }
-
-        // ---- axios-like client ----
-        if (axiosMethod) {
-          method = axiosMethod;
-          urlValue = getUrlValue(node.arguments[0]);
-
-          if (["POST", "PUT", "PATCH"].includes(method)) {
-            const dataArg = node.arguments[1];
-            if (dataArg?.type === "ObjectExpression") {
-              schemaFields = extractObjectSchema(dataArg);
-            } else if (dataArg?.type === "Identifier") {
-              const init = resolveIdentifierToInit(callPath, dataArg.name);
-              if (init?.type === "ObjectExpression") schemaFields = extractObjectSchema(init);
-            }
-          }
-        }
-
-        // accept only URLs that contain /api/ anywhere
-        const apiPath = extractApiPath(urlValue);
-        if (!apiPath) return;
-
-        const route = normalizeRouteForBackend(apiPath.split("?")[0]);
-        const controllerName = deriveControllerNameFromUrl(apiPath);
-        const actionName = deriveActionName(method, route);
-
-        const key = `${method}:${route}`;
-        if (!endpoints.has(key)) {
-          endpoints.set(key, {
-            path: apiPath,
-            route,
-            method,
-            controllerName,
-            actionName,
-            pathParams: extractPathParams(route),
-            queryParams: extractQueryParamsFromUrl(apiPath),
-            schemaFields,
-            requestBody: schemaFields ? { fields: schemaFields } : null,
-            sourceFile: normalizeSlashes(file),
-          });
-        }
-      },
-    });
-  }
-
-  return Array.from(endpoints.values());
-}
-
-// -------------------------
-// Optional: full project analyze (endpoints + db insights)
-// -------------------------
-export async function analyze(projectRoot = process.cwd()) {
-  const rootDir = path.resolve(projectRoot);
-
-  const frontendSrc = ["src", "app", "pages"]
-    .map((d) => path.join(rootDir, d))
-    .find((d) => fs.existsSync(d));
-
-  const endpoints = frontendSrc ? await analyzeFrontend(frontendSrc) : [];
-
-  const models = inferModelsFromEndpoints(endpoints);
-  const seeds = generateSeedsFromModels(models, 3);
-  const guessedDb = guessDbTypeFromRepo(rootDir, endpoints);
-
-  return {
-    rootDir: normalizeSlashes(rootDir),
-    endpoints,
-    dbInsights: {
-      guessedDb, // mongodb-mongoose | sql-prisma 
-      models,    // inferred entities + fields
-      seeds,     // dummy seed rows
-    },
-  };
-}
-
-// -------------------------
-// NEW v7.0: Low-Cost Path Scanner (Standard Tier)
-// -------------------------
-export async function performLowCostPathScan(frontendSrcDir, endpoints) {
-  // Ensures routes match frontend expectations
-  const inconsistencies = [];
-  endpoints.forEach(ep => {
-    if (!ep.sourceFile || !ep.route) return;
-    const fileBase = path.basename(ep.sourceFile).split('.')[0].toLowerCase();
-    const routeBase = ep.controllerName ? ep.controllerName.toLowerCase() : '';
-    
-    // If the file containing the fetch is named 'AdminPanel' but route points to 'Products', note it.
-    if (fileBase !== 'index' && fileBase !== 'api' && routeBase && !fileBase.includes(routeBase) && !routeBase.includes(fileBase)) {
-      inconsistencies.push({
-        file: ep.sourceFile,
-        routeCalled: ep.route,
-        warning: `Path Scanner: File '${fileBase}' calls unrelated route '${routeBase}'. Potential naming drift.`
-      });
-    }
-  });
-  return inconsistencies;
-}
-
-// -------------------------
-// NEW v7.0: Component Component Tree Extractor (DOM Sync Level 2)
-// -------------------------
-export async function extractComponentTreeTypes(frontendSrcDir) {
-  // A heuristic simulation of live DOM cross-checking:
-  // Parses JSX tags (<input type="date">) to build forced validations.
-  if (!fs.existsSync(frontendSrcDir)) return [];
-  
-  const files = await glob(`${normalizeSlashes(frontendSrcDir)}/**/*.{jsx,tsx}`, {
-    ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"]
-  });
-
-  const extractedTypes = [];
-  
-  for (const file of files) {
-    try {
-      const code = await fs.readFile(file, "utf-8");
-      if (code.includes('type="date"')) extractedTypes.push({ file, fieldType: 'Date', rawHTMLType: 'date' });
-      if (code.includes('type="number"')) extractedTypes.push({ file, fieldType: 'Number', rawHTMLType: 'number' });
-      if (code.includes('type="email"')) extractedTypes.push({ file, fieldType: 'Email', rawHTMLType: 'email' });
-    } catch {}
-  }
-
-  return extractedTypes;
+import fs from "fs-extra";
+import path from "node:path";
+import { glob } from "glob";
+
+import parser from "@babel/parser";
+import _traverse from "@babel/traverse";
+const traverse = _traverse.default || _traverse;
+
+const HTTP_METHODS = new Set(["get", "post", "put", "patch", "delete"]);
+
+const STATIC_ASSET_EXTENSIONS = new Set([
+  ".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp", ".ico",
+  ".css", ".scss", ".less", ".woff", ".woff2", ".ttf", ".eot",
+  ".mp3", ".mp4", ".webm", ".pdf",
+]);
+
+// -------------------------
+// Utils
+// -------------------------
+function normalizeSlashes(p) {
+  return String(p || "").replace(/\\/g, "/");
+}
+
+function toTitleCase(str) {
+  if (!str) return "Default";
+  return String(str)
+    .replace(/[-_]+(\w)/g, (_, c) => c.toUpperCase())
+    .replace(/^\w/, (c) => c.toUpperCase())
+    .replace(/[^a-zA-Z0-9]/g, "");
+}
+
+// Convert `/api/users/{id}` -> `/api/users/:id`
+function normalizeRouteForBackend(urlValue) {
+  return String(urlValue || "").replace(/\{(\w+)\}/g, ":$1");
+}
+
+function extractApiPath(urlValue, envMap = new Map()) {
+  if (!urlValue) return null;
+
+  // 1. Original behavior: if URL contains /api/, extract from there
+  const idx = urlValue.indexOf("/api/");
+  if (idx !== -1) return urlValue.slice(idx);
+
+  // 2. Resolve env variable placeholders left by getUrlValue
+  let resolved = urlValue;
+  const envPattern = /\{(NEXT_PUBLIC_|REACT_APP_|VITE_)[^}]+\}/g;
+  resolved = resolved.replace(envPattern, (match) => {
+    const varName = match.slice(1, -1);
+    return envMap.get(varName) || "";
+  });
+
+  // Re-check after resolution
+  const idx2 = resolved.indexOf("/api/");
+  if (idx2 !== -1) return resolved.slice(idx2);
+
+  // 3. If resolved URL starts with http(s), extract the path portion
+  if (/^https?:\/\//.test(resolved)) {
+    try {
+      const url = new URL(resolved);
+      const pathname = url.pathname;
+      if (pathname && pathname !== "/") return pathname;
+    } catch {}
+  }
+
+  // 4. If it's a relative path starting with /, accept it
+  if (resolved.startsWith("/") && resolved.length > 1) {
+    // Filter out static assets
+    const ext = path.extname(resolved.split("?")[0]).toLowerCase();
+    if (STATIC_ASSET_EXTENSIONS.has(ext)) return null;
+    return resolved;
+  }
+
+  return null;
+}
+
+function extractPathParams(route) {
+  const params = [];
+  const re = /[:{]([a-zA-Z0-9_]+)[}]/g;
+  let m;
+  while ((m = re.exec(route))) params.push(m[1]);
+  return Array.from(new Set(params));
+}
+
+function extractQueryParamsFromUrl(urlValue) {
+  try {
+    const qIndex = urlValue.indexOf("?");
+    if (qIndex === -1) return [];
+    const qs = urlValue.slice(qIndex + 1);
+    return qs
+      .split("&")
+      .map((p) => p.split("=")[0])
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function deriveControllerNameFromUrl(urlValue) {
+  const apiPath = extractApiPath(urlValue) || urlValue;
+  const parts = String(apiPath).split("/").filter(Boolean); // ["api","v1","products"]
+  const apiIndex = parts.indexOf("api");
+
+  let seg = null;
+  if (apiIndex >= 0) {
+    seg = parts[apiIndex + 1] || null;
+
+    // skip version segment (v1, v2, v10...)
+    if (seg && /^v\d+$/i.test(seg)) {
+      seg = parts[apiIndex + 2] || seg;
+    }
+  } else {
+    seg = parts[0] || null;
+  }
+
+  return toTitleCase(seg);
+}
+
+function deriveActionName(method, route) {
+  const cleaned = String(route).replace(/^\/api\//, "/").replace(/[/:{}-]/g, " ");
+  const last = cleaned.trim().split(/\s+/).filter(Boolean).pop() || "Action";
+  return `${String(method).toLowerCase()}${toTitleCase(last)}`;
+}
+
+// -------------------------
+// URL extraction
+// -------------------------
+function extractEnvVarName(node) {
+  // process.env.NEXT_PUBLIC_API_URL
+  if (
+    node.type === "MemberExpression" &&
+    node.object?.type === "MemberExpression" &&
+    node.object.object?.type === "Identifier" &&
+    node.object.object.name === "process" &&
+    node.object.property?.name === "env" &&
+    node.property?.type === "Identifier"
+  ) {
+    return node.property.name;
+  }
+  // import.meta.env.VITE_API_URL
+  if (
+    node.type === "MemberExpression" &&
+    node.object?.type === "MemberExpression" &&
+    node.object.object?.type === "MetaProperty" &&
+    node.object.property?.name === "env" &&
+    node.property?.type === "Identifier"
+  ) {
+    return node.property.name;
+  }
+  return null;
+}
+
+function getUrlValue(urlNode, envMap = new Map()) {
+  if (!urlNode) return null;
+
+  if (urlNode.type === "StringLiteral") return urlNode.value;
+
+  if (urlNode.type === "TemplateLiteral") {
+    const quasis = urlNode.quasis || [];
+    const exprs = urlNode.expressions || [];
+    let out = "";
+    for (let i = 0; i < quasis.length; i++) {
+      out += quasis[i].value.raw;
+      if (exprs[i]) {
+        if (exprs[i].type === "Identifier") {
+          out += `{${exprs[i].name}}`;
+        } else if (exprs[i].type === "MemberExpression") {
+          const envName = extractEnvVarName(exprs[i]);
+          if (envName && envMap.has(envName)) {
+            out += envMap.get(envName);
+          } else if (envName) {
+            out += `{${envName}}`;
+          } else {
+            out += `{param${i + 1}}`;
+          }
+        } else {
+          out += `{param${i + 1}}`;
+        }
+      }
+    }
+    return out;
+  }
+
+  // Handle string concatenation: baseUrl + "/users"
+  if (urlNode.type === "BinaryExpression" && urlNode.operator === "+") {
+    const left = getUrlValue(urlNode.left, envMap);
+    const right = getUrlValue(urlNode.right, envMap);
+    if (left || right) return (left || "") + (right || "");
+  }
+
+  // Handle process.env.X / import.meta.env.X directly as URL
+  if (urlNode.type === "MemberExpression") {
+    const envName = extractEnvVarName(urlNode);
+    if (envName && envMap.has(envName)) {
+      return envMap.get(envName);
+    }
+    if (envName) {
+      return `{${envName}}`;
+    }
+  }
+
+  return null;
+}
+
+// -------------------------
+// axios-like detection
+// -------------------------
+function detectAxiosLikeMethod(node) {
+  // axios.get(...) / api.get(...) / httpClient.post(...) etc
+  if (!node.callee || node.callee.type !== "MemberExpression") return null;
+
+  const prop = node.callee.property;
+  if (!prop || prop.type !== "Identifier") return null;
+
+  const name = prop.name.toLowerCase();
+  if (!HTTP_METHODS.has(name)) return null;
+
+  return name.toUpperCase();
+}
+
+// -------------------------
+// Request body schema (simple + identifier tracing)
+// -------------------------
+function inferTypeFromNode(node) {
+  if (!node) return "String";
+  switch (node.type) {
+    case "StringLiteral":
+      return "String";
+    case "NumericLiteral":
+      return "Number";
+    case "BooleanLiteral":
+      return "Boolean";
+    case "NullLiteral":
+      return "String";
+    default:
+      return "String";
+  }
+}
+
+function extractObjectSchema(objExpr) {
+  const schemaFields = {};
+  if (!objExpr || objExpr.type !== "ObjectExpression") return null;
+
+  for (const prop of objExpr.properties) {
+    if (prop.type !== "ObjectProperty") continue;
+
+    const key =
+      prop.key.type === "Identifier"
+        ? prop.key.name
+        : prop.key.type === "StringLiteral"
+          ? prop.key.value
+          : null;
+
+    if (!key) continue;
+    schemaFields[key] = inferTypeFromNode(prop.value);
+  }
+  return schemaFields;
+}
+
+function resolveIdentifierToInit(callPath, identifierName) {
+  try {
+    const binding = callPath.scope.getBinding(identifierName);
+    if (!binding) return null;
+    const declPath = binding.path;
+    if (!declPath || !declPath.node) return null;
+
+    if (declPath.node.type === "VariableDeclarator") return declPath.node.init || null;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function isJSONStringifyCall(node) {
+  // JSON.stringify(x)
+  return (
+    node &&
+    node.type === "CallExpression" &&
+    node.callee &&
+    node.callee.type === "MemberExpression" &&
+    node.callee.object &&
+    node.callee.object.type === "Identifier" &&
+    node.callee.object.name === "JSON" &&
+    node.callee.property &&
+    node.callee.property.type === "Identifier" &&
+    node.callee.property.name === "stringify"
+  );
+}
+
+// -------------------------
+// DB insights: guess db + infer models + seeds
+// -------------------------
+function guessDbTypeFromRepo(rootDir, endpoints = []) {
+  try {
+    const pkgPath = path.join(rootDir, "package.json");
+    if (!fs.existsSync(pkgPath)) return heuristicallyGuessDB(endpoints);
+
+    const pkg = fs.readJsonSync(pkgPath);
+    const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+
+    if (deps.mongoose || deps.mongodb) return "mongodb-mongoose";
+    if (deps.prisma || deps["@prisma/client"]) return "sql-prisma";
+    if (deps.sequelize) return "sql-sequelize";
+    if (deps.typeorm) return "sql-typeorm";
+
+    return heuristicallyGuessDB(endpoints);
+  } catch {
+    return heuristicallyGuessDB(endpoints);
+  }
+}
+
+function heuristicallyGuessDB(endpoints) {
+  // Free Tier / Default Intelligence:
+  // Analyze data complexity. If highly nested schemas are prominent, default NoSQL.
+  // If many flat, relational-looking fields exist, default SQL.
+  let maxNesting = 0;
+  for (const ep of endpoints) {
+    if (ep.schemaFields && Object.keys(ep.schemaFields).length > 6) {
+       maxNesting++;
+    }
+  }
+  return maxNesting > 3 ? "mongodb-mongoose" : "sql-prisma";
+}
+
+function inferModelsFromEndpoints(endpoints) {
+  const models = new Map();
+
+  for (const ep of endpoints) {
+    const modelName = ep.controllerName || "Default";
+
+    if (!models.has(modelName)) {
+      models.set(modelName, {
+        name: modelName,
+        fields: {},          // merged fields from bodies
+        sources: new Set(),
+        endpoints: [],
+      });
+    }
+
+    const m = models.get(modelName);
+    m.endpoints.push({ method: ep.method, route: ep.route });
+    if (ep.sourceFile) m.sources.add(ep.sourceFile);
+
+    const fields = ep.schemaFields || (ep.requestBody && ep.requestBody.fields) || null;
+    if (fields) {
+      for (const [k, t] of Object.entries(fields)) {
+        if (!m.fields[k]) m.fields[k] = t || "String";
+      }
+    }
+  }
+
+  return Array.from(models.values()).map((m) => ({
+    name: m.name,
+    fields: m.fields,
+    sources: Array.from(m.sources),
+    endpoints: m.endpoints,
+  }));
+}
+
+// -------------------------
+// Relationship detection from nested routes
+// -------------------------
+function singularize(word) {
+  if (!word) return word;
+  if (word.endsWith("ies")) return word.slice(0, -3) + "y";
+  if (word.endsWith("ses") || word.endsWith("xes") || word.endsWith("zes")) return word.slice(0, -2);
+  if (word.endsWith("s") && !word.endsWith("ss")) return word.slice(0, -1);
+  return word;
+}
+
+export function detectRelationships(endpoints) {
+  const seen = new Set();
+  const relationships = [];
+
+  for (const ep of endpoints) {
+    const route = ep.route || ep.path || "";
+    const segments = route.split("/").filter(Boolean);
+
+    for (let i = 0; i < segments.length - 2; i++) {
+      const parentSegment = segments[i];
+      const paramSegment = segments[i + 1];
+      const childSegment = segments[i + 2];
+
+      if (
+        parentSegment === "api" ||
+        /^v\d+$/i.test(parentSegment) ||
+        !paramSegment.startsWith(":")
+      ) continue;
+
+      const parentName = toTitleCase(singularize(parentSegment));
+      const childName = toTitleCase(singularize(childSegment));
+
+      if (!parentName || !childName || parentName === childName) continue;
+
+      const key = `${parentName}:${childName}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+
+      const foreignKey = parentName.charAt(0).toLowerCase() + parentName.slice(1) + "Id";
+
+      relationships.push({
+        parent: parentName,
+        child: childName,
+        type: "oneToMany",
+        foreignKey,
+      });
+    }
+  }
+
+  return relationships;
+}
+
+function seedValueForType(t) {
+  if (t === "Number") return 1;
+  if (t === "Boolean") return true;
+  return "test"; // String default
+}
+
+function generateSeedsFromModels(models, perModel = 3) {
+  return models.map((m) => {
+    const rows = [];
+    for (let i = 0; i < perModel; i++) {
+      const obj = {};
+      for (const [k, t] of Object.entries(m.fields || {})) {
+        obj[k] = seedValueForType(t);
+      }
+      rows.push(obj);
+    }
+    return { model: m.name, rows };
+  });
+}
+
+// -------------------------
+// MAIN frontend analyzer
+// -------------------------
+export async function analyzeFrontend(srcPath, options = {}) {
+  if (!srcPath) throw new Error("analyzeFrontend: srcPath is required");
+  if (!fs.existsSync(srcPath)) {
+    throw new Error(`The source directory '${srcPath}' does not exist.`);
+  }
+  return analyzeFrontendMulti([srcPath], options);
+}
+
+export async function analyzeFrontendMulti(scanDirs, options = {}) {
+  const { envMap = new Map() } = options;
+
+  const allFiles = new Set();
+  for (const dir of scanDirs) {
+    if (!fs.existsSync(dir)) continue;
+    const files = await glob(`${normalizeSlashes(dir)}/**/*.{js,ts,jsx,tsx}`, {
+      ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.next/**", "**/coverage/**"],
+    });
+    files.forEach((f) => allFiles.add(path.resolve(f)));
+  }
+
+  const endpoints = new Map();
+
+  for (const file of allFiles) {
+    let code;
+    try {
+      code = await fs.readFile(file, "utf-8");
+    } catch {
+      continue;
+    }
+
+    let ast;
+    try {
+      ast = parser.parse(code, { sourceType: "module", plugins: ["jsx", "typescript"] });
+    } catch {
+      continue;
+    }
+
+    traverse(ast, {
+      CallExpression(callPath) {
+        const node = callPath.node;
+
+        const isFetch = node.callee.type === "Identifier" && node.callee.name === "fetch";
+        const axiosMethod = detectAxiosLikeMethod(node);
+
+        if (!isFetch && !axiosMethod) return;
+
+        let urlValue = null;
+        let method = "GET";
+        let schemaFields = null;
+
+        if (isFetch) {
+          urlValue = getUrlValue(node.arguments[0], envMap);
+          const optionsNode = node.arguments[1];
+
+          if (optionsNode && optionsNode.type === "ObjectExpression") {
+            const methodProp = optionsNode.properties.find(
+              (p) =>
+                p.type === "ObjectProperty" &&
+                p.key.type === "Identifier" &&
+                p.key.name === "method"
+            );
+            if (methodProp && methodProp.value.type === "StringLiteral") {
+              method = methodProp.value.value.toUpperCase();
+            }
+
+            if (["POST", "PUT", "PATCH"].includes(method)) {
+              const bodyProp = optionsNode.properties.find(
+                (p) =>
+                  p.type === "ObjectProperty" &&
+                  p.key.type === "Identifier" &&
+                  p.key.name === "body"
+              );
+
+              if (bodyProp) {
+                const v = bodyProp.value;
+
+                if (isJSONStringifyCall(v)) {
+                  const arg0 = v.arguments[0];
+
+                  if (arg0?.type === "ObjectExpression") {
+                    schemaFields = extractObjectSchema(arg0);
+                  } else if (arg0?.type === "Identifier") {
+                    const init = resolveIdentifierToInit(callPath, arg0.name);
+                    if (init?.type === "ObjectExpression") schemaFields = extractObjectSchema(init);
+                  }
+                }
+              }
+            }
+          }
+        }
+
+        if (axiosMethod) {
+          method = axiosMethod;
+          urlValue = getUrlValue(node.arguments[0], envMap);
+
+          if (["POST", "PUT", "PATCH"].includes(method)) {
+            const dataArg = node.arguments[1];
+            if (dataArg?.type === "ObjectExpression") {
+              schemaFields = extractObjectSchema(dataArg);
+            } else if (dataArg?.type === "Identifier") {
+              const init = resolveIdentifierToInit(callPath, dataArg.name);
+              if (init?.type === "ObjectExpression") schemaFields = extractObjectSchema(init);
+            }
+          }
+        }
+
+        const apiPath = extractApiPath(urlValue, envMap);
+        if (!apiPath) return;
+
+        const route = normalizeRouteForBackend(apiPath.split("?")[0]);
+        const normalizedRoute = route.replace(/\/+/g, "/").replace(/\/$/, "") || "/";
+        const controllerName = deriveControllerNameFromUrl(apiPath);
+        const actionName = deriveActionName(method, normalizedRoute);
+
+        const key = `${method}:${normalizedRoute}`;
+        if (!endpoints.has(key)) {
+          endpoints.set(key, {
+            path: apiPath,
+            route: normalizedRoute,
+            method,
+            controllerName,
+            actionName,
+            pathParams: extractPathParams(normalizedRoute),
+            queryParams: extractQueryParamsFromUrl(apiPath),
+            schemaFields,
+            requestBody: schemaFields ? { fields: schemaFields } : null,
+            sourceFile: normalizeSlashes(file),
+          });
+        }
+      },
+    });
+  }
+
+  return Array.from(endpoints.values());
+}
+
+// -------------------------
+// Optional: full project analyze (endpoints + db insights)
+// -------------------------
+export async function analyze(projectRoot = process.cwd()) {
+  const rootDir = path.resolve(projectRoot);
+
+  const frontendSrc = ["src", "app", "pages"]
+    .map((d) => path.join(rootDir, d))
+    .find((d) => fs.existsSync(d));
+
+  const endpoints = frontendSrc ? await analyzeFrontend(frontendSrc) : [];
+
+  const models = inferModelsFromEndpoints(endpoints);
+  const seeds = generateSeedsFromModels(models, 3);
+  const guessedDb = guessDbTypeFromRepo(rootDir, endpoints);
+  const relationships = detectRelationships(endpoints);
+
+  return {
+    rootDir: normalizeSlashes(rootDir),
+    endpoints,
+    relationships,
+    dbInsights: {
+      guessedDb,
+      models,
+      seeds,
+    },
+  };
+}
+
+// -------------------------
+// Next.js API Route Detection
+// -------------------------
+const NEXTJS_HTTP_EXPORTS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+
+export async function detectNextjsApiRoutes(apiRouteDirs) {
+  const routes = [];
+
+  for (const dir of apiRouteDirs) {
+    if (!fs.existsSync(dir)) continue;
+
+    // App Router: app/**/route.{ts,js}
+    const appRouterFiles = await glob(
+      `${normalizeSlashes(dir)}/**/route.{ts,js,tsx,jsx}`,
+      { ignore: ["**/node_modules/**"] }
+    );
+
+    for (const file of appRouterFiles) {
+      const relativePath = path.relative(dir, path.dirname(file));
+      let routePath = "/" + relativePath
+        .replace(/\\/g, "/")
+        .replace(/\(([^)]+)\)\//g, "")
+        .replace(/\[\.\.\.([^\]]+)\]/g, ":$1")
+        .replace(/\[([^\]]+)\]/g, ":$1");
+
+      if (routePath === "/.") routePath = "/";
+
+      const methods = await extractExportedHttpMethods(file);
+      for (const method of methods) {
+        routes.push({
+          route: routePath,
+          method,
+          controllerName: deriveControllerNameFromUrl(routePath),
+          sourceFile: normalizeSlashes(file),
+          isServerRoute: true,
+        });
+      }
+    }
+
+    // Pages Router: pages/api/**/*.{ts,js}
+    const pagesApiDir = path.join(dir, "api");
+    if (fs.existsSync(pagesApiDir)) {
+      const pagesApiFiles = await glob(
+        `${normalizeSlashes(pagesApiDir)}/**/*.{ts,js,tsx,jsx}`,
+        { ignore: ["**/node_modules/**"] }
+      );
+
+      for (const file of pagesApiFiles) {
+        const relativePath = path.relative(pagesApiDir, file);
+        let routePath = "/api/" + relativePath
+          .replace(/\\/g, "/")
+          .replace(/\.(ts|js|tsx|jsx)$/, "")
+          .replace(/\/index$/, "")
+          .replace(/\[\.\.\.([^\]]+)\]/g, ":$1")
+          .replace(/\[([^\]]+)\]/g, ":$1");
+
+        routes.push({
+          route: routePath,
+          method: "ALL",
+          controllerName: deriveControllerNameFromUrl(routePath),
+          sourceFile: normalizeSlashes(file),
+          isServerRoute: true,
+        });
+      }
+    }
+  }
+
+  return routes;
+}
+
+async function extractExportedHttpMethods(file) {
+  const methods = [];
+  try {
+    const code = await fs.readFile(file, "utf-8");
+    const ast = parser.parse(code, {
+      sourceType: "module",
+      plugins: ["jsx", "typescript"],
+    });
+
+    traverse(ast, {
+      ExportNamedDeclaration(nodePath) {
+        const decl = nodePath.node.declaration;
+        if (!decl) return;
+
+        if (decl.type === "FunctionDeclaration" && decl.id) {
+          const name = decl.id.name;
+          if (NEXTJS_HTTP_EXPORTS.has(name)) methods.push(name);
+        }
+
+        if (decl.type === "VariableDeclaration") {
+          for (const declarator of decl.declarations) {
+            if (declarator.id?.type === "Identifier") {
+              const name = declarator.id.name;
+              if (NEXTJS_HTTP_EXPORTS.has(name)) methods.push(name);
+            }
+          }
+        }
+      },
+    });
+  } catch {}
+
+  return methods.length > 0 ? methods : ["GET"];
+}
+
+// -------------------------
+// NEW v7.0: Low-Cost Path Scanner (Standard Tier)
+// -------------------------
+export async function performLowCostPathScan(frontendSrcDir, endpoints) {
+  // Ensures routes match frontend expectations
+  const inconsistencies = [];
+  endpoints.forEach(ep => {
+    if (!ep.sourceFile || !ep.route) return;
+    const fileBase = path.basename(ep.sourceFile).split('.')[0].toLowerCase();
+    const routeBase = ep.controllerName ? ep.controllerName.toLowerCase() : '';
+    
+    // If the file containing the fetch is named 'AdminPanel' but route points to 'Products', note it.
+    if (fileBase !== 'index' && fileBase !== 'api' && routeBase && !fileBase.includes(routeBase) && !routeBase.includes(fileBase)) {
+      inconsistencies.push({
+        file: ep.sourceFile,
+        routeCalled: ep.route,
+        warning: `Path Scanner: File '${fileBase}' calls unrelated route '${routeBase}'. Potential naming drift.`
+      });
+    }
+  });
+  return inconsistencies;
+}
+
+// -------------------------
+// NEW v7.0: Component Component Tree Extractor (DOM Sync Level 2)
+// -------------------------
+export async function extractComponentTreeTypes(frontendSrcDir) {
+  // A heuristic simulation of live DOM cross-checking:
+  // Parses JSX tags (<input type="date">) to build forced validations.
+  if (!fs.existsSync(frontendSrcDir)) return [];
+  
+  const files = await glob(`${normalizeSlashes(frontendSrcDir)}/**/*.{jsx,tsx}`, {
+    ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"]
+  });
+
+  const extractedTypes = [];
+  
+  for (const file of files) {
+    try {
+      const code = await fs.readFile(file, "utf-8");
+      if (code.includes('type="date"')) extractedTypes.push({ file, fieldType: 'Date', rawHTMLType: 'date' });
+      if (code.includes('type="number"')) extractedTypes.push({ file, fieldType: 'Number', rawHTMLType: 'number' });
+      if (code.includes('type="email"')) extractedTypes.push({ file, fieldType: 'Email', rawHTMLType: 'email' });
+    } catch {}
+  }
+
+  return extractedTypes;
 }