create-backlist 6.0.5 → 6.0.7

package/bin/backlist.js

@@ -1,130 +1,132 @@
 #!/usr/bin/env node
+/* eslint-disable @typescript-eslint/no-var-requires */
 
-const inquirer = require('inquirer');
-const chalk = require('chalk');
-const fs = require('fs-extra');
-const path = require('path');
-const { Command } = require('commander');
-const chokidar = require('chokidar');
+const inquirer = require("inquirer");
+const chalk = require("chalk");
+const fs = require("fs-extra");
+const path = require("path");
+const { Command } = require("commander");
+const chokidar = require("chokidar");
 
-const { isCommandAvailable } = require('../src/utils');
+// FIX: repo has utils.js at root
+const { isCommandAvailable } = require("../utils");
 
-const { generateNodeProject } = require('../src/generators/node');
-const { generateDotnetProject } = require('../src/generators/dotnet');
-const { generateJavaProject } = require('../src/generators/java');
-const { generatePythonProject } = require('../src/generators/python');
+const { generateNodeProject } = require("../src/generators/node");
+const { generateDotnetProject } = require("../src/generators/dotnet");
+const { generateJavaProject } = require("../src/generators/java");
+const { generatePythonProject } = require("../src/generators/python");
 
-const { scanFrontend, writeContracts } = require('../src/scanner');
+const { scanFrontend, writeContracts } = require("../src/scanner");
 
 function resolveOptionsFromFlags(flags) {
   return {
-    projectName: flags.projectName || 'backend',
-    srcPath: flags.srcPath || 'src',
-    stack: flags.stack || 'node-ts-express',
+    projectName: flags.projectName || "backend",
+    srcPath: flags.srcPath || "src",
+    stack: flags.stack || "node-ts-express",
     dbType: flags.dbType,
     addAuth: flags.addAuth,
     addSeeder: flags.addSeeder,
     extraFeatures: flags.extraFeatures || [],
-    projectDir: path.resolve(process.cwd(), flags.projectName || 'backend'),
-    frontendSrcDir: path.resolve(process.cwd(), flags.srcPath || 'src'),
+    projectDir: path.resolve(process.cwd(), flags.projectName || "backend"),
+    frontendSrcDir: path.resolve(process.cwd(), flags.srcPath || "src"),
   };
 }
 
 async function runGeneration(options, contracts) {
   switch (options.stack) {
-    case 'node-ts-express':
+    case "node-ts-express":
       await generateNodeProject({ ...options, contracts });
       break;
 
-    case 'dotnet-webapi':
-      if (!await isCommandAvailable('dotnet')) {
-        throw new Error('.NET SDK is not installed. Please install it from https://dotnet.microsoft.com/download');
+    case "dotnet-webapi":
+      if (!(await isCommandAvailable("dotnet"))) {
+        throw new Error(".NET SDK is not installed. Install: https://dotnet.microsoft.com/download");
       }
       await generateDotnetProject({ ...options, contracts });
       break;
 
-    case 'java-spring':
-      if (!await isCommandAvailable('java')) {
-        throw new Error('Java (JDK 17 or newer) is not installed. Please install a JDK to continue.');
+    case "java-spring":
+      if (!(await isCommandAvailable("java"))) {
+        throw new Error("Java (JDK 17+) is not installed. Install a JDK to continue.");
       }
       await generateJavaProject({ ...options, contracts });
       break;
 
-    case 'python-fastapi':
-      if (!await isCommandAvailable('python')) {
-        throw new Error('Python is not installed. Please install Python (3.8+) and pip to continue.');
+    case "python-fastapi":
+      if (!(await isCommandAvailable("python"))) {
+        throw new Error("Python is not installed. Please install Python (3.8+) and pip.");
       }
       await generatePythonProject({ ...options, contracts });
       break;
 
     default:
-      throw new Error(`The selected stack '${options.stack}' is not supported yet.`);
+      throw new Error(`Unsupported stack '${options.stack}'.`);
   }
 }
 
 async function interactiveMain() {
-  console.log(chalk.cyan.bold('Welcome to Backlist! The Polyglot Backend Generator.'));
+  console.log(chalk.cyan.bold("Welcome to Backlist! The Polyglot Backend Generator."));
 
   const answers = await inquirer.prompt([
     {
-      type: 'input',
-      name: 'projectName',
-      message: 'Enter a name for your backend directory:',
-      default: 'backend',
-      validate: input => input ? true : 'Project name cannot be empty.'
+      type: "input",
+      name: "projectName",
+      message: "Enter a name for your backend directory:",
+      default: "backend",
+      validate: (input) => (input ? true : "Project name cannot be empty."),
     },
     {
-      type: 'list',
-      name: 'stack',
-      message: 'Select the backend stack:',
+      type: "list",
+      name: "stack",
+      message: "Select the backend stack:",
       choices: [
-        { name: 'Node.js (TypeScript, Express)', value: 'node-ts-express' },
-        { name: 'C# (ASP.NET Core Web API)', value: 'dotnet-webapi' },
-        { name: 'Java (Spring Boot)', value: 'java-spring' },
-        { name: 'Python (FastAPI)', value: 'python-fastapi' },
+        { name: "Node.js (TypeScript, Express)", value: "node-ts-express" },
+        { name: "C# (ASP.NET Core Web API)", value: "dotnet-webapi" },
+        { name: "Java (Spring Boot)", value: "java-spring" },
+        { name: "Python (FastAPI)", value: "python-fastapi" },
       ],
     },
     {
-      type: 'input',
-      name: 'srcPath',
-      message: 'Enter the path to your frontend `src` directory:',
-      default: 'src',
+      type: "input",
+      name: "srcPath",
+      message: "Enter the path to your frontend `src` directory:",
+      default: "src",
     },
     {
-      type: 'list',
-      name: 'dbType',
-      message: 'Select your database type for Node.js:',
+      type: "list",
+      name: "dbType",
+      message: "Select your database type for Node.js:",
       choices: [
-        { name: 'NoSQL (MongoDB with Mongoose)', value: 'mongoose' },
-        { name: 'SQL (PostgreSQL/MySQL with Prisma)', value: 'prisma' },
+        { name: "NoSQL (MongoDB with Mongoose)", value: "mongoose" },
+        { name: "SQL (PostgreSQL/MySQL with Prisma)", value: "prisma" },
       ],
-      when: (answers) => answers.stack === 'node-ts-express'
+      when: (a) => a.stack === "node-ts-express",
     },
     {
-      type: 'confirm',
-      name: 'addAuth',
-      message: 'Add JWT authentication boilerplate?',
+      type: "confirm",
+      name: "addAuth",
+      message: "Add JWT authentication boilerplate?",
       default: true,
-      when: (answers) => answers.stack === 'node-ts-express'
+      when: (a) => a.stack === "node-ts-express",
     },
     {
-      type: 'confirm',
-      name: 'addSeeder',
-      message: 'Add a database seeder with sample data?',
+      type: "confirm",
+      name: "addSeeder",
+      message: "Add a database seeder with sample data?",
       default: true,
-      when: (answers) => answers.stack === 'node-ts-express' && answers.addAuth
+      when: (a) => a.stack === "node-ts-express" && a.addAuth,
     },
     {
-      type: 'checkbox',
-      name: 'extraFeatures',
-      message: 'Select additional features for Node.js:',
+      type: "checkbox",
+      name: "extraFeatures",
+      message: "Select additional features for Node.js:",
       choices: [
-        { name: 'Docker Support (Dockerfile & docker-compose.yml)', value: 'docker', checked: true },
-        { name: 'API Testing Boilerplate (Jest & Supertest)', value: 'testing', checked: true },
-        { name: 'API Documentation (Swagger UI)', value: 'swagger', checked: true },
+        { name: "Docker Support", value: "docker", checked: true },
+        { name: "API Testing Boilerplate (Jest & Supertest)", value: "testing", checked: true },
+        { name: "API Documentation (Swagger UI)", value: "swagger", checked: true },
       ],
-      when: (answers) => answers.stack === 'node-ts-express'
-    }
+      when: (a) => a.stack === "node-ts-express",
+    },
   ]);
 
   const options = {
@@ -139,16 +141,15 @@ async function interactiveMain() {
     console.log(chalk.blue(`\nStarting backend generation for: ${chalk.bold(options.stack)}`));
     await runGeneration(options, contracts);
 
-    console.log(chalk.green.bold('\nBackend generation complete!'));
-    console.log('\nNext Steps:');
+    console.log(chalk.green.bold("\nBackend generation complete!"));
+    console.log("\nNext Steps:");
     console.log(chalk.cyan(`  cd ${options.projectName}`));
-    console.log(chalk.cyan('  (Check the generated README.md for instructions)'));
   } catch (error) {
-    console.error(chalk.red.bold('\nAn error occurred during generation:'));
+    console.error(chalk.red.bold("\nAn error occurred during generation:"));
     console.error(error);
 
     if (fs.existsSync(options.projectDir)) {
-      console.log(chalk.yellow('  -> Cleaning up failed installation...'));
+      console.log(chalk.yellow("  -> Cleaning up failed installation..."));
       fs.removeSync(options.projectDir);
     }
     process.exit(1);
@@ -158,15 +159,13 @@ async function interactiveMain() {
 async function main() {
   const program = new Command();
 
+  program.name("backlist").description("Backlist CLI").version("5.1.0");
+
   program
-    .name('backlist')
-    .description('Backlist CLI - generate backend from frontend via AST scan')
-    .version('1.0.0');
-
-  program.command('scan')
-    .description('Scan frontend and write contracts JSON')
-    .option('-s, --srcPath <path>', 'frontend src path', 'src')
-    .option('-o, --out <file>', 'output contracts file', '.backlist/contracts.json')
+    .command("scan")
+    .description("Scan frontend and write contracts JSON")
+    .option("-s, --srcPath <path>", "frontend src path", "src")
+    .option("-o, --out <file>", "output contracts file", ".backlist/contracts.json")
     .action(async (flags) => {
       const frontendSrcDir = path.resolve(process.cwd(), flags.srcPath);
       const outFile = path.resolve(process.cwd(), flags.out);
@@ -175,28 +174,31 @@ async function main() {
       console.log(chalk.green(`Wrote contracts to ${outFile}`));
     });
 
-  program.command('generate')
-    .description('Generate backend using contracts')
-    .requiredOption('-k, --stack <stack>', 'stack: node-ts-express | dotnet-webapi | java-spring | python-fastapi')
-    .option('-p, --projectName <name>', 'backend directory', 'backend')
-    .option('-s, --srcPath <path>', 'frontend src path', 'src')
-    .option('-c, --contracts <file>', 'contracts file', '.backlist/contracts.json')
+  program
+    .command("generate")
+    .description("Generate backend using contracts")
+    .requiredOption("-k, --stack <stack>", "stack: node-ts-express | dotnet-webapi | java-spring | python-fastapi")
+    .option("-p, --projectName <name>", "backend directory", "backend")
+    .option("-s, --srcPath <path>", "frontend src path", "src")
+    .option("-c, --contracts <file>", "contracts file", ".backlist/contracts.json")
     .action(async (flags) => {
       const options = resolveOptionsFromFlags(flags);
+
       const contractsPath = path.resolve(process.cwd(), flags.contracts);
       const contracts = fs.existsSync(contractsPath)
         ? await fs.readJson(contractsPath)
         : await scanFrontend({ frontendSrcDir: options.frontendSrcDir });
 
       await runGeneration(options, contracts);
-      console.log(chalk.green('Generation complete.'));
+      console.log(chalk.green("Generation complete."));
     });
 
-  program.command('watch')
-    .description('Watch frontend and regenerate backend on changes')
-    .requiredOption('-k, --stack <stack>', 'stack')
-    .option('-p, --projectName <name>', 'backend directory', 'backend')
-    .option('-s, --srcPath <path>', 'frontend src path', 'src')
+  program
+    .command("watch")
+    .description("Watch frontend and regenerate backend on changes")
+    .requiredOption("-k, --stack <stack>", "stack")
+    .option("-p, --projectName <name>", "backend directory", "backend")
+    .option("-s, --srcPath <path>", "frontend src path", "src")
     .action(async (flags) => {
       const options = resolveOptionsFromFlags(flags);
       const watcher = chokidar.watch(options.frontendSrcDir, { ignoreInitial: true });
@@ -208,11 +210,10 @@ async function main() {
       };
 
       await run();
-      watcher.on('add', run).on('change', run).on('unlink', run);
+      watcher.on("add", run).on("change", run).on("unlink", run);
       console.log(chalk.cyan(`[watch] watching ${options.frontendSrcDir}`));
     });
 
-  // If no args => old interactive mode
   if (process.argv.length <= 2) {
     await interactiveMain();
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-backlist",
-  "version": "6.0.5",
+  "version": "6.0.7",
   "description": "An advanced, multi-language backend generator based on frontend analysis.",
   "type": "commonjs",
   "bin": {

package/src/analyzer.js

@@ -8,9 +8,6 @@ const traverse = require("@babel/traverse").default;
 
 const HTTP_METHODS = new Set(["get", "post", "put", "patch", "delete"]);
 
-// -------------------------
-// Small utils
-// -------------------------
 function normalizeSlashes(p) {
   return String(p || "").replace(/\\/g, "/");
 }
@@ -23,11 +20,7 @@ function readJSONSafe(p) {
   }
 }
 
-// -------------------------
-// AUTH detection (for addAuth)
-// -------------------------
 function findAuthUsageInRepo(rootDir) {
-  // 1) package.json quick check
   const pkgPath = path.join(rootDir, "package.json");
   const pkg = readJSONSafe(pkgPath) || {};
   const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
@@ -44,7 +37,6 @@ function findAuthUsageInRepo(rootDir) {
 
   if (authDeps.some((d) => deps[d])) return true;
 
-  // 2) Source scan for common auth identifiers
   const scanDirs = ["src", "app", "pages", "components", "lib", "utils"]
     .map((d) => path.join(rootDir, d))
     .filter((d) => fs.existsSync(d));
@@ -59,35 +51,26 @@ function findAuthUsageInRepo(rootDir) {
     "auth()",
     "currentUser",
     "createServerClient",
+    "jwt",
+    "bearer",
   ];
 
   for (const dir of scanDirs) {
     const files = glob.sync(`${normalizeSlashes(dir)}/**/*.{js,ts,jsx,tsx}`, {
-      ignore: [
-        "**/node_modules/**",
-        "**/dist/**",
-        "**/build/**",
-        "**/.next/**",
-        "**/coverage/**",
-      ],
+      ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.next/**", "**/coverage/**"],
     });
 
     for (const f of files) {
       try {
         const content = fs.readFileSync(f, "utf8");
         if (patterns.some((p) => content.includes(p))) return true;
-      } catch {
-        // ignore read errors
-      }
+      } catch {}
     }
   }
 
   return false;
 }
 
-// -------------------------
-// Frontend API call analyzer (your code)
-// -------------------------
 function toTitleCase(str) {
   if (!str) return "Default";
   return String(str)
@@ -100,6 +83,75 @@ function normalizeRouteForBackend(urlValue) {
   return urlValue.replace(/\{(\w+)\}/g, ":$1");
 }
 
+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 parts = String(urlValue || "").split("/").filter(Boolean);
+  const apiIndex = parts.indexOf("api");
+  let seg = null;
+  if (apiIndex >= 0) {
+    seg = parts[apiIndex + 1] || null;
+    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)}`;
+}
+
+function detectAxiosLikeMethod(node) {
+  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();
+}
+
+function getUrlValue(urlNode) {
+  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 out += `{param${i + 1}}`;
+      }
+    }
+    return out;
+  }
+  return null;
+}
+
 function inferTypeFromNode(node) {
   if (!node) return "String";
   switch (node.type) {
@@ -117,132 +169,38 @@ function inferTypeFromNode(node) {
 }
 
 function extractObjectSchema(objExpr) {
-  const schemaFields = {};
+  const schema = {};
   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);
+    schema[key] = inferTypeFromNode(prop.value);
   }
-  return schemaFields;
+  return schema;
 }
 
 function resolveIdentifierToInit(pathObj, identifierName) {
   try {
     const binding = pathObj.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;
+    const decl = binding.path.node;
+    if (!decl) return null;
+    if (decl.type === "VariableDeclarator") return decl.init || null;
     return null;
   } catch {
     return null;
   }
 }
 
-function getUrlValue(urlNode) {
-  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 out += `{param${i + 1}}`;
-      }
-    }
-    return out;
-  }
-
-  return null;
-}
-
-function extractApiPath(urlValue) {
-  if (!urlValue) return null;
-  const idx = urlValue.indexOf("/api/");
-  if (idx === -1) return null;
-  return urlValue.slice(idx);
-}
-
-function deriveControllerNameFromUrl(urlValue) {
-  const apiPath = extractApiPath(urlValue) || urlValue;
-  const parts = String(apiPath).split("/").filter(Boolean);
-  const apiIndex = parts.indexOf("api");
-
-  let seg = null;
-
-  if (apiIndex >= 0) {
-    seg = parts[apiIndex + 1] || null;
-    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)}`;
-}
-
-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 detectAxiosLikeMethod(node) {
-  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();
-}
-
 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.`);
-  }
+  if (!fs.existsSync(srcPath)) throw new Error(`Source dir '${srcPath}' does not exist`);
 
   const files = await glob(`${normalizeSlashes(srcPath)}/**/*.{js,ts,jsx,tsx}`, {
     ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.next/**", "**/coverage/**"],
@@ -271,7 +229,6 @@ async function analyzeFrontend(srcPath) {
 
         const isFetch = node.callee.type === "Identifier" && node.callee.name === "fetch";
         const axiosMethod = detectAxiosLikeMethod(node);
-
         if (!isFetch && !axiosMethod) return;
 
         let urlValue = null;
@@ -282,41 +239,30 @@ async function analyzeFrontend(srcPath) {
           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 (optionsNode?.type === "ObjectExpression") {
+            const mProp = 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 (mProp?.value?.type === "StringLiteral") method = mProp.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"
+              const bProp = optionsNode.properties.find(
+                (p) => p.type === "ObjectProperty" && p.key?.type === "Identifier" && p.key.name === "body"
               );
 
-              if (bodyProp) {
-                const v = bodyProp.value;
-
+              if (bProp) {
+                const v = bProp.value;
                 if (
                   v.type === "CallExpression" &&
                   v.callee.type === "MemberExpression" &&
-                  v.callee.object.type === "Identifier" &&
+                  v.callee.object?.type === "Identifier" &&
                   v.callee.object.name === "JSON" &&
-                  v.callee.property.type === "Identifier" &&
+                  v.callee.property?.type === "Identifier" &&
                   v.callee.property.name === "stringify"
                 ) {
                   const arg0 = v.arguments[0];
-
-                  if (arg0?.type === "ObjectExpression") {
-                    schemaFields = extractObjectSchema(arg0);
-                  } else if (arg0?.type === "Identifier") {
+                  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);
                   }
@@ -332,23 +278,22 @@ async function analyzeFrontend(srcPath) {
 
           if (["POST", "PUT", "PATCH"].includes(method)) {
             const dataArg = node.arguments[1];
-            if (dataArg?.type === "ObjectExpression") {
-              schemaFields = extractObjectSchema(dataArg);
-            } else if (dataArg?.type === "Identifier") {
+            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);
+        const apiPath = urlValue?.includes("/api/") ? urlValue.slice(urlValue.indexOf("/api/")) : null;
         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,
@@ -370,21 +315,22 @@ async function analyzeFrontend(srcPath) {
   return Array.from(endpoints.values());
 }
 
-// -------------------------
-// Main analyze() exported for CLI
-// -------------------------
-function analyze(projectRoot = process.cwd()) {
+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 hasAuth = findAuthUsageInRepo(rootDir);
+
   return {
     rootDir: normalizeSlashes(rootDir),
-    hasAuth: findAuthUsageInRepo(rootDir),
-    // If CLI expects addAuth directly, keep both:
-    addAuth: findAuthUsageInRepo(rootDir),
+    hasAuth,
+    addAuth: hasAuth,
+    endpoints,
   };
 }
 
-module.exports = {
-  analyze,
-  analyzeFrontend,
-};
+module.exports = { analyze, analyzeFrontend };

package/src/scanner/analyzeFrontend.js

@@ -6,7 +6,7 @@ const path = require("path");
  * Normalize paths (Windows → Unix style)
  */
 function normalizeSlashes(p) {
-  return p.replace(/\\/g, "/");
+  return String(p || "").replace(/\\/g, "/");
 }
 
 /**
@@ -40,6 +40,27 @@ function findAuthUsageInRepo(rootDir) {
   return found;
 }
 
+/**
+ * Derive a controller name from URL
+ */
+function deriveControllerName(urlPath) {
+  if (!urlPath) return "Default";
+  const parts = urlPath.split("/").filter(Boolean);
+  const apiIndex = parts.indexOf("api");
+  if (apiIndex >= 0) return parts[apiIndex + 1] || "Default";
+  return parts[0] || "Default";
+}
+
+/**
+ * Derive an action name from method + URL
+ */
+function deriveActionName(method, urlPath) {
+  if (!urlPath) return `${method.toLowerCase()}Action`;
+  const cleaned = urlPath.replace(/^\/api\//, "/").replace(/[/:{}-]/g, " ");
+  const lastSegment = cleaned.trim().split(/\s+/).filter(Boolean).pop() || "Action";
+  return `${method.toLowerCase()}${lastSegment.charAt(0).toUpperCase()}${lastSegment.slice(1)}`;
+}
+
 /**
  * Analyze frontend source to extract API endpoints
  * (axios / fetch based – simple & safe)
@@ -63,23 +84,31 @@ function analyzeFrontend(frontendDir) {
       ) {
         const content = fs.readFileSync(fullPath, "utf8");
 
-        // axios.get('/api/xxx')
+        // --- axios ---
         const axiosRegex = /axios\.(get|post|put|delete|patch)\(\s*['"`](.*?)['"`]/g;
         let match;
         while ((match = axiosRegex.exec(content)) !== null) {
+          const url = match[2].startsWith("/") ? match[2] : "/" + match[2];
+          const method = match[1].toUpperCase();
           endpoints.push({
-            method: match[1].toUpperCase(),
-            path: match[2],
+            method,
+            path: url,
+            controllerName: deriveControllerName(url),
+            actionName: deriveActionName(method, url),
             source: normalizeSlashes(fullPath)
           });
         }
 
-        // fetch('/api/xxx')
+        // --- fetch ---
         const fetchRegex = /fetch\(\s*['"`](.*?)['"`]/g;
         while ((match = fetchRegex.exec(content)) !== null) {
+          const url = match[1].startsWith("/") ? match[1] : "/" + match[1];
+          const method = "GET";
           endpoints.push({
-            method: "GET",
-            path: match[1],
+            method,
+            path: url,
+            controllerName: deriveControllerName(url),
+            actionName: deriveActionName(method, url),
             source: normalizeSlashes(fullPath)
           });
         }

package/src/utils.js

@@ -1,27 +1,24 @@
-const { execa } = require('execa');
+/* eslint-disable @typescript-eslint/no-var-requires */
+const { execa } = require("execa");
 
 const VERSION_ARGS = {
-  java: ['-version'],
-  python: ['--version'],
-  python3: ['--version'],
-  node: ['--version'],
-  npm: ['--version'],
-  dotnet: ['--version'],
-  mvn: ['-v'],
-  git: ['--version'],
+  java: ["-version"],
+  python: ["--version"],
+  python3: ["--version"],
+  node: ["--version"],
+  npm: ["--version"],
+  dotnet: ["--version"],
+  mvn: ["-v"],
+  git: ["--version"],
 };
 
 async function isCommandAvailable(command) {
-  const args = VERSION_ARGS[command] || ['--version'];
-
+  const args = VERSION_ARGS[command] || ["--version"];
   try {
-    // Reject false only if spawn fails (ENOENT). Non-zero exit still counts as "available".
     await execa(command, args, { reject: false });
     return true;
   } catch (err) {
-    // If command not found, execa throws with code 'ENOENT'
-    if (err && err.code === 'ENOENT') return false;
-    // Other unexpected errors: treat as not available
+    if (err && err.code === "ENOENT") return false;
     return false;
   }
 }