create-backlist 6.2.3 → 7.3.0

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "create-backlist",
-  "version": "6.2.3",
-  "description": "An advanced, multi-language backend generator based on frontend analysis.",
-  "type": "commonjs",
+  "version": "7.3.0",
+  "description": "An advanced, multi-language backend generator based on frontend analysis. Smart Freemium SaaS CLI.",
+  "type": "module",
   "bin": {
     "create-backlist": "bin/index.js"
   },
   "files": [
     "bin",
-    "src"
+    "src",
+    "AiModuls"
   ],
   "scripts": {
     "start": "node bin/index.js"
@@ -18,13 +19,16 @@
   "dependencies": {
     "@babel/parser": "^7.22.7",
     "@babel/traverse": "^7.22.8",
+    "@clack/prompts": "^0.7.0",
     "axios": "^1.13.1",
-    "chalk": "^4.1.2",
+    "chalk": "^5.3.0",
     "ejs": "^3.1.9",
-    "execa": "^6.1.0",
+    "execa": "^8.0.1",
     "fs-extra": "^11.1.1",
     "glob": "^10.3.3",
-    "inquirer": "^8.2.4",
+    "inquirer": "^9.2.12",
+    "ora": "^7.0.1",
+    "together-ai": "^0.39.0",
     "unzipper": "^0.12.3"
   }
 }

package/src/ai-agent.js

@@ -0,0 +1,171 @@
+import Together from "together-ai";
+import fs from 'fs-extra';
+import path from 'node:path';
+
+export class BacklistAIAgent {
+  constructor(apiKey, onThought) {
+    this.apiKey = apiKey;
+    this.onThought = onThought || (() => {});
+    this.together = null;
+    this.modelName = "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8";
+  }
+
+  async init() {
+    this.onThought('[THOUGHT] Initializing Together AI runtime...');
+    try {
+      this.together = new Together({ apiKey: this.apiKey });
+      this.onThought('[THOUGHT] Connected to Together AI cloud service successfully.');
+    } catch (err) {
+      throw new Error(`Together AI initialization failed: ${err.message}`);
+    }
+  }
+
+  async promptModel(systemPrompt, userPrompt) {
+    const response = await this.together.chat.completions.create({
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: userPrompt }
+      ],
+      model: this.modelName
+    });
+    return response.choices[0].message.content;
+  }
+
+  // --- PASS 1: Generate Code Blocks ---
+  async generateBackendBlocks(astJsonData, existingSchemaContent = null) {
+    this.onThought(`[THOUGHT] Commencing Pass 1 Analysis on ${astJsonData.length} AST endpoints via Cloud AI...`);
+    
+    let schemaDirective = `Generate a comprehensive Prisma schema (schema.prisma). Deduce many-to-many relationships and apply optimal indexing.`;
+    if (existingSchemaContent) {
+      this.onThought('[THOUGHT] Detected existing schema.prisma. Generating Schema Migration Scripts instead of full overwrite.');
+      schemaDirective = `An existing schema exists. Output an SQL Migration Script instead of a full schema rewrite, along with the updated prisma schema models.`;
+    }
+
+    const systemPrompt = `You are an expert backend architect and Domain-Driven Design (DDD) specialist.
+Follow Hexagonal Architecture (Ports and Adapters) principles.
+Your task is to generate intelligent implementation blocks for EJS placeholders based on the provided AST data.
+
+1. ${schemaDirective}
+2. Generate <%- aiSecurityConfig %>: Define complex JWT filters, rate limiting, and CORS based on the sensitivity of the endpoints.
+3. Generate <%- aiDbRelations %>: Code for Repositories connecting defined Prisma models.
+4. Generate <%- aiValidationLogic %>: Input validation middleware (Zod, Joi) tailored precisely to the data shapes extracted from the frontend.
+
+Output ONLY JSON with the following structure:
+{
+  "prismaSchema": "string",
+  "aiSecurityConfig": "string",
+  "aiDbRelations": "string",
+  "aiValidationLogic": "string"
+}
+Do NOT include explanations. Output raw JSON only.`;
+
+    const userPrompt = `AST Frontend Extracted Data:\n${JSON.stringify(astJsonData, null, 2)}`;
+
+    this.onThought('[THOUGHT] Prompting Together AI (Llama-4-Maverick) with Hexagonal architecture rules...');
+    let result = await this.promptModel(systemPrompt, userPrompt);
+    
+    // Clean JSON response
+    try {
+      if (result.includes('```json')) {
+        result = result.split('```json')[1].split('```')[0].trim();
+      } else if (result.includes('```')) {
+        result = result.split('```')[1].split('```')[0].trim();
+      }
+      return JSON.parse(result);
+    } catch (e) {
+      this.onThought(`[WARNING] Failed to parse Pass 1 JSON. Attempting heuristic extraction...`);
+      return {
+        prismaSchema: "// Fallback schema\n" + result,
+        aiSecurityConfig: "// Security fallback",
+        aiDbRelations: "// Db Relations fallback",
+        aiValidationLogic: "// Validation fallback"
+      };
+    }
+  }
+
+  // --- PASS 2: Verification Loop (Dry-Run & DOM Sync) ---
+  async verifyDryRun(generatedBlocks, astJsonData) {
+    this.onThought('[THOUGHT] Commencing Pass 2 Verification Loop (Virtual Dry Run)...');
+
+    let issueFound = false;
+
+    // DOM Sync Level 2 (Data-type matching check)
+    this.onThought('[THOUGHT] Simulating frontend component tree data injection against generated validation logic...');
+    
+    const systemPrompt = `You are a strict QA Engine.
+Review the following generated Validation Logic and DB Relations against the Frontend AST data shapes.
+Check for:
+1. Missing DB relations (e.g., User -> Post).
+2. Data-type mismatches (DOM Sync Level 2: if AST expects 'Date' string but DB expects 'DateTime', inject a transformation middleware).
+
+Output JSON:
+{
+  "issuesFound": boolean,
+  "fixedValidationLogic": "string (original or fixed)",
+  "fixedDbRelations": "string (original or fixed)",
+  "reasonings": ["string"]
+}`;
+
+    const userPrompt = `Data:
+Generated Validation: ${generatedBlocks.aiValidationLogic}
+Generated DB Rel: ${generatedBlocks.aiDbRelations}
+AST Shapes: ${JSON.stringify(astJsonData.map(e => e.schemaFields), null, 2)}`;
+
+    let result = await this.promptModel(systemPrompt, userPrompt);
+    
+    try {
+      if (result.includes('```json')) result = result.split('```json')[1].split('```')[0].trim();
+      else if (result.includes('```')) result = result.split('```')[1].split('```')[0].trim();
+      const verified = JSON.parse(result);
+      
+      if (verified.issuesFound) {
+        this.onThought(`[THOUGHT] Verification caught issues! Self-healing triggered...`);
+        verified.reasonings.forEach(r => this.onThought(`[THOUGHT] -> Fix applied: ${r}`));
+        return {
+          ...generatedBlocks,
+          aiValidationLogic: verified.fixedValidationLogic,
+          aiDbRelations: verified.fixedDbRelations
+        };
+      } else {
+        this.onThought('[THOUGHT] Virtual Dry Run passed perfectly. Zero data mismatches found.');
+        return generatedBlocks;
+      }
+    } catch (e) {
+      this.onThought('[WARNING] Verification parsing failed. Using Pass 1 results.');
+      return generatedBlocks;
+    }
+  }
+
+  // --- Autonomous Deployment Engine ---
+  async generateDeploymentConfig(stack, astJsonData) {
+    this.onThought(`[THOUGHT] Generating Autonomous Deployment workflows for [${stack}]...`);
+    
+    const systemPrompt = `Generate a highly optimized docker-compose.yml and a .github/workflows/deploy.yml for a production ${stack} backend.
+Include PostgreSQL, Redis, and best-practice health checks.
+Output JSON:
+{
+  "dockerCompose": "string",
+  "githubWorkflow": "string"
+}`;
+
+    const userPrompt = `Target Stack: ${stack}\nAST Endpoints Count: ${astJsonData ? astJsonData.length : 0}`;
+
+    const res = await this.promptModel(systemPrompt, userPrompt);
+    
+    try {
+      let clean = res;
+      if (clean.includes('```json')) clean = clean.split('```json')[1].split('```')[0].trim();
+      else if (clean.includes('```')) clean = clean.split('```')[1].split('```')[0].trim();
+      const parsed = JSON.parse(clean);
+      this.onThought('[THOUGHT] Deployment workflows synthesized successfully.');
+      return parsed;
+    } catch (e) {
+      return { dockerCompose: "# Fallback Config", githubWorkflow: "# Fallback Workflow" };
+    }
+  }
+
+  async dispose() {
+    this.onThought('[THOUGHT] Shutting down AI context...');
+    // Together AI doesn't hold local VRAM or contexts to dispose, doing nothing.
+  }
+}

package/src/analyzer.js

@@ -1,10 +1,10 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
-const fs = require("fs-extra");
-const path = require("path");
-const { glob } = require("glob");
+import fs from "fs-extra";
+import path from "node:path";
+import { glob } from "glob";
 
-const parser = require("@babel/parser");
-const traverse = require("@babel/traverse").default;
+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"]);
 
@@ -200,11 +200,10 @@ function isJSONStringifyCall(node) {
 // -------------------------
 // DB insights: guess db + infer models + seeds
 // -------------------------
-function guessDbTypeFromRepo(rootDir) {
-  // Best-effort; if it's only frontend repo, usually null.
+function guessDbTypeFromRepo(rootDir, endpoints = []) {
   try {
     const pkgPath = path.join(rootDir, "package.json");
-    if (!fs.existsSync(pkgPath)) return null;
+    if (!fs.existsSync(pkgPath)) return heuristicallyGuessDB(endpoints);
 
     const pkg = fs.readJsonSync(pkgPath);
     const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
@@ -214,12 +213,25 @@ function guessDbTypeFromRepo(rootDir) {
     if (deps.sequelize) return "sql-sequelize";
     if (deps.typeorm) return "sql-typeorm";
 
-    return null;
+    return heuristicallyGuessDB(endpoints);
   } catch {
-    return null;
+    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();
 
@@ -255,6 +267,59 @@ function inferModelsFromEndpoints(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;
@@ -278,7 +343,7 @@ function generateSeedsFromModels(models, perModel = 3) {
 // -------------------------
 // MAIN frontend analyzer
 // -------------------------
-async function analyzeFrontend(srcPath) {
+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.`);
@@ -381,18 +446,19 @@ async function analyzeFrontend(srcPath) {
         if (!apiPath) return;
 
         const route = normalizeRouteForBackend(apiPath.split("?")[0]);
+        const normalizedRoute = route.replace(/\/+/g, "/").replace(/\/$/, "") || "/";
         const controllerName = deriveControllerNameFromUrl(apiPath);
-        const actionName = deriveActionName(method, route);
+        const actionName = deriveActionName(method, normalizedRoute);
 
-        const key = `${method}:${route}`;
+        const key = `${method}:${normalizedRoute}`;
         if (!endpoints.has(key)) {
           endpoints.set(key, {
             path: apiPath,
-            route,
+            route: normalizedRoute,
             method,
             controllerName,
             actionName,
-            pathParams: extractPathParams(route),
+            pathParams: extractPathParams(normalizedRoute),
             queryParams: extractQueryParamsFromUrl(apiPath),
             schemaFields,
             requestBody: schemaFields ? { fields: schemaFields } : null,
@@ -409,7 +475,7 @@ async function analyzeFrontend(srcPath) {
 // -------------------------
 // Optional: full project analyze (endpoints + db insights)
 // -------------------------
-async function analyze(projectRoot = process.cwd()) {
+export async function analyze(projectRoot = process.cwd()) {
   const rootDir = path.resolve(projectRoot);
 
   const frontendSrc = ["src", "app", "pages"]
@@ -420,17 +486,66 @@ async function analyze(projectRoot = process.cwd()) {
 
   const models = inferModelsFromEndpoints(endpoints);
   const seeds = generateSeedsFromModels(models, 3);
-  const guessedDb = guessDbTypeFromRepo(rootDir);
+  const guessedDb = guessDbTypeFromRepo(rootDir, endpoints);
+  const relationships = detectRelationships(endpoints);
 
   return {
     rootDir: normalizeSlashes(rootDir),
     endpoints,
+    relationships,
     dbInsights: {
-      guessedDb, // null | mongodb-mongoose | sql-prisma | ...
-      models,    // inferred entities + fields
-      seeds,     // dummy seed rows
+      guessedDb,
+      models,
+      seeds,
     },
   };
 }
 
-module.exports = { analyzeFrontend, analyze };
+// -------------------------
+// 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;
+}