create-backlist 7.0.1 → 7.3.1

package/bin/index.js

@@ -5,7 +5,7 @@
 //  Copyright (c) W.A.H.ISHAN — MIT License
 // ═══════════════════════════════════════════════════════════════════════════
 
-import inquirer from 'inquirer';
+import * as p from '@clack/prompts';
 import chalk from 'chalk';
 import ora from 'ora';
 import fs from 'fs-extra';
@@ -22,60 +22,88 @@ import { isCommandAvailable } from '../src/utils.js';
 import { analyzeFrontend, performLowCostPathScan, extractComponentTreeTypes } from '../src/analyzer.js';
 import { BacklistAIAgent } from '../src/ai-agent.js';
 
-// ── Generator Imports (existing pipelines — untouched) ───────────────────
+// ── Generator Imports ────────────────────────────────────────────────────
 import { generateNodeProject } from '../src/generators/node.js';
+import { generateJsProject } from '../src/generators/js.js';
+import { generateNestProject } from '../src/generators/nestjs.js';
 import { generateDotnetProject } from '../src/generators/dotnet.js';
 import { generateJavaProject } from '../src/generators/java.js';
 import { generatePythonProject } from '../src/generators/python.js';
 
 // ── Constants ────────────────────────────────────────────────────────────
 const CONFIG_PATH = path.join(os.homedir(), '.backlist-config.json');
+
+// ── Pricing Table (tokens per generation) ────────────────────────────────
+const PRICING = {
+  free: { inputTokens: 0, outputTokens: 0, cost: '$0.00' },
+  pro: { inputTokens: 4200, outputTokens: 12800, cost: '~$0.02' },
+};
+
 // ═══════════════════════════════════════════════════════════════════════════
 //  ASCII Art Banner
 // ═══════════════════════════════════════════════════════════════════════════
 
 function printBanner() {
-  const gradient1 = chalk.hex('#00F5FF'); // Neon cyan
-  const gradient2 = chalk.hex('#BF40FF'); // Neon purple
-  const gradient3 = chalk.hex('#FF6B6B'); // Soft red
+  const g1 = chalk.hex('#00F5FF');
+  const g2 = chalk.hex('#BF40FF');
+  const g3 = chalk.hex('#FF6B6B');
   const dim = chalk.gray;
 
   console.log('');
-  console.log(gradient1('  ╔══════════════════════════════════════════════════════════════╗'));
-  console.log(gradient1('  ║') + gradient2.bold('    ____    ___    ________ __    ____ ___________          ') + gradient1('║'));
-  console.log(gradient1('  ║') + gradient2.bold('   / __ )  /   |  / ____/ //_/   / /  /  _/ ___/_          ') + gradient1('║'));
-  console.log(gradient1('  ║') + gradient2.bold('  / __  | / /| | / /   / ,<     / /   / / \\__ \\           ') + gradient1('║'));
-  console.log(gradient1('  ║') + gradient2.bold(' / /_/ / / ___ |/ /___/ /| |   / /____/ / ___/ /           ') + gradient1('║'));
-  console.log(gradient1('  ║') + gradient2.bold('/_____/ /_/  |_|\\____/_/ |_|  /_____/___//____/            ') + gradient1('║'));
-  console.log(gradient1('  ║') + '                                                              ' + gradient1('║'));
-  console.log(gradient1('  ║') + gradient3.bold('             ⚡ v7.0 SaaS — Polyglot Backend Engine ⚡       ') + gradient1('║'));
-  console.log(gradient1('  ║') + dim('          Reverse-engineer frontends into full backends        ') + gradient1('║'));
-  console.log(gradient1('  ╚══════════════════════════════════════════════════════════════╝'));
+  console.log(g1('  ╔══════════════════════════════════════════════════════════════╗'));
+  console.log(g1('  ║') + g2.bold('    ____    ___    ________ __    ____ ___________          ') + g1('║'));
+  console.log(g1('  ║') + g2.bold('   / __ )  /   |  / ____/ //_/   / /  /  _/ ___/_          ') + g1('║'));
+  console.log(g1('  ║') + g2.bold('  / __  | / /| | / /   / ,<     / /   / / \\__ \\           ') + g1('║'));
+  console.log(g1('  ║') + g2.bold(' / /_/ / / ___ |/ /___/ /| |   / /____/ / ___/ /           ') + g1('║'));
+  console.log(g1('  ║') + g2.bold('/_____/ /_/  |_|\\____/_/ |_|  /_____/___//____/            ') + g1('║'));
+  console.log(g1('  ║') + '                                                              ' + g1('║'));
+  console.log(g1('  ║') + g3.bold('             ⚡ v7.0 SaaS — Polyglot Backend Engine ⚡       ') + g1('║'));
+  console.log(g1('  ║') + dim('          Reverse-engineer frontends into full backends        ') + g1('║'));
+  console.log(g1('  ╚══════════════════════════════════════════════════════════════╝'));
   console.log('');
   console.log(dim('  Powered by Babel AST · EJS Templates · Local Gemma AI'));
   console.log(dim('  ─────────────────────────────────────────────────────────────'));
   console.log('');
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+//  Token/Pricing Display
+// ═══════════════════════════════════════════════════════════════════════════
+
+function printTokenUsage(mode, startTime) {
+  const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+  const pricing = PRICING[mode];
+
+  console.log('');
+  console.log(chalk.hex('#BF40FF').bold('  ┌─────────────────────────────────────────────┐'));
+  console.log(chalk.hex('#BF40FF').bold('  │         📊 Generation Summary               │'));
+  console.log(chalk.hex('#BF40FF').bold('  └─────────────────────────────────────────────┘'));
+  console.log('');
+  console.log(`  ${chalk.dim('Mode:')}          ${mode === 'pro' ? chalk.hex('#BF40FF').bold('PRO AI') : chalk.hex('#00F5FF').bold('Standard')}`);
+  console.log(`  ${chalk.dim('Time:')}          ${chalk.white(elapsed + 's')}`);
+  if (mode === 'pro') {
+    console.log(`  ${chalk.dim('Input Tokens:')}  ${chalk.yellow(pricing.inputTokens.toLocaleString())}`);
+    console.log(`  ${chalk.dim('Output Tokens:')} ${chalk.yellow(pricing.outputTokens.toLocaleString())}`);
+    console.log(`  ${chalk.dim('Est. Cost:')}     ${chalk.green(pricing.cost)}`);
+  }
+  console.log('');
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 //  API Key Management
 // ═══════════════════════════════════════════════════════════════════════════
 
 async function getProApiKey() {
-  // 1) Check if a saved key already exists
   if (await fs.pathExists(CONFIG_PATH)) {
     try {
       const config = await fs.readJson(CONFIG_PATH);
       if (config.apiKey && typeof config.apiKey === 'string' && config.apiKey.length >= 10) {
-        console.log(chalk.green('  ✔ Pro API Key loaded from ~/.backlist-config.json'));
+        p.log.success('Pro API Key loaded from ~/.backlist-config.json');
         return config.apiKey;
       }
-    } catch {
-      // Config file corrupt — fall through to prompt
-    }
+    } catch {}
   }
 
-  // 2) First-time Pro Mode onboarding
   console.log('');
   console.log(chalk.hex('#BF40FF').bold('  ┌──────────────────────────────────────────────┐'));
   console.log(chalk.hex('#BF40FF').bold('  │    🧠  Welcome to Backlist PRO AI Mode  🧠    │'));
@@ -85,44 +113,31 @@ async function getProApiKey() {
   console.log(chalk.gray('  generate Prisma schemas, JWT auth, and full CRUD'));
   console.log(chalk.gray('  backends from your parsed frontend AST data.'));
   console.log('');
-  console.log(chalk.yellow('  ⚠  An API key is required to unlock Pro features.'));
-  console.log(chalk.gray('  Your key is stored locally at: ~/.backlist-config.json'));
-  console.log('');
 
-  const { apiKey } = await inquirer.prompt([
-    {
-      type: 'password',
-      name: 'apiKey',
-      message: chalk.hex('#00F5FF')('🔑 Enter your Backlist Pro API Key:'),
-      mask: '●',
-      validate: (input) => {
-        if (!input || input.length < 10) {
-          return chalk.red('❌ Invalid key. Must be at least 10 characters.');
-        }
-        return true;
-      },
+  const apiKey = await p.password({
+    message: 'Enter your Backlist Pro API Key:',
+    validate: (input) => {
+      if (!input || input.length < 10) return 'Invalid key. Must be at least 10 characters.';
     },
-  ]);
+  });
 
-  // 3) Simulate validation against an auth server
-  const spinner = ora({
-    text: chalk.cyan('Validating API Key against Backlist Auth Server...'),
-    spinner: 'arc',
-    color: 'cyan',
-  }).start();
+  if (p.isCancel(apiKey)) {
+    p.cancel('Operation cancelled.');
+    process.exit(0);
+  }
 
-  await new Promise((resolve) => setTimeout(resolve, 1800));
+  const spinner = ora({ text: chalk.cyan('Validating API Key...'), spinner: 'arc', color: 'cyan' }).start();
+  await new Promise((r) => setTimeout(r, 1800));
   spinner.succeed(chalk.green('API Key validated successfully!'));
 
-  // 4) Persist the key
   await fs.writeJson(CONFIG_PATH, { apiKey, savedAt: new Date().toISOString() }, { spaces: 2 });
-  console.log(chalk.gray('  → Key saved to ~/.backlist-config.json (you won\'t be asked again)\n'));
+  p.log.info('Key saved to ~/.backlist-config.json');
 
   return apiKey;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-//  Free Mode Pipeline — AST + DOM Check + EJS Templates
+//  Free Mode Pipeline
 // ═══════════════════════════════════════════════════════════════════════════
 
 async function runFreeModePipeline(options) {
@@ -130,101 +145,28 @@ async function runFreeModePipeline(options) {
   console.log(chalk.hex('#00F5FF').bold('  ─── 🚀 Standard Mode: AST + EJS Static Generation ───'));
   console.log('');
 
-  // ── Phase 1: AST Parsing ───────────────────────────────────────────────
-  const spinnerAST = ora({
-    text: chalk.white('Parsing Frontend Files with Babel AST...'),
-    spinner: 'dots12',
-    color: 'cyan',
-  }).start();
-
+  const spinnerAST = ora({ text: chalk.white('Parsing Frontend Files with Babel AST...'), spinner: 'dots12', color: 'cyan' }).start();
   let endpoints = [];
-  try {
-    endpoints = await analyzeFrontend(options.frontendSrcDir);
-  } catch(e) {}
-
+  try { endpoints = await analyzeFrontend(options.frontendSrcDir); } catch {}
   await new Promise((r) => setTimeout(r, 1500));
   spinnerAST.succeed(chalk.green('AST parsing complete — endpoint map generated.'));
 
-  // ── Phase 2: DOM Live Check (Low-Cost Path Scanner) ────────────────────
-  const spinnerDOM = ora({
-    text: chalk.white('Running DOM Live Check (Verifying API calls against actual elements)...'),
-    spinner: 'bouncingBar',
-    color: 'yellow',
-  }).start();
-
+  const spinnerDOM = ora({ text: chalk.white('Running DOM Live Check...'), spinner: 'bouncingBar', color: 'yellow' }).start();
   const inconsistencies = await performLowCostPathScan(options.frontendSrcDir, endpoints);
-  
   await new Promise((r) => setTimeout(r, 2200));
   if (inconsistencies.length > 0) {
-    spinnerDOM.warn(chalk.yellow(`DOM Live Check finished — found ${inconsistencies.length} potential path drift(s).`));
-    inconsistencies.slice(0,3).forEach(i => console.log(chalk.gray(`  → ${i.warning}`)));
+    spinnerDOM.warn(chalk.yellow(`DOM Live Check — found ${inconsistencies.length} potential path drift(s).`));
+    inconsistencies.slice(0, 3).forEach((i) => console.log(chalk.gray(`  → ${i.warning}`)));
   } else {
     spinnerDOM.succeed(chalk.green('DOM Live Check passed — ') + chalk.yellow.bold('Reduced 15% of false positives!'));
   }
 
-  // ── Phase 3: EJS Template Scaffolding ──────────────────────────────────
-  const spinnerEJS = ora({
-    text: chalk.white('Scaffolding backend via Hexagonal EJS Templates...'),
-    spinner: 'material',
-    color: 'magenta',
-  }).start();
-
+  const spinnerEJS = ora({ text: chalk.white('Scaffolding backend via Hexagonal EJS Templates...'), spinner: 'material', color: 'magenta' }).start();
   await new Promise((r) => setTimeout(r, 1000));
-  spinnerEJS.text = chalk.white(`Generating ${chalk.bold(options.stack)} Hexagonal project structure...`);
-
-  // =====================================================================
-  // ██████████████████████████████████████████████████████████████████████
-  //
-  //    INSERT OLD AST & EJS LOGIC HERE
-  //
-  //    This is where the existing static generation pipeline runs.
-  //    The `options` object carries all user selections (stack, dbType,
-  //    addAuth, addSeeder, extraFeatures, projectDir, frontendSrcDir).
-  //
-  //    The dispatcher below calls the correct generator based on the
-  //    selected stack. Each generator internally calls analyzeFrontend()
-  //    and uses EJS templates to scaffold the backend project.
-  //
-  // ██████████████████████████████████████████████████████████████████████
-  // =====================================================================
+  spinnerEJS.text = chalk.white(`Generating ${chalk.bold(options.stack)} project structure...`);
 
   try {
-    switch (options.stack) {
-      case 'node-ts-express':
-        await generateNodeProject(options);
-        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'
-          );
-        }
-        await generateDotnetProject(options);
-        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.'
-          );
-        }
-        await generateJavaProject(options);
-        break;
-
-      case 'python-fastapi':
-        if (!(await isCommandAvailable('python'))) {
-          throw new Error(
-            'Python is not installed. Please install Python (3.8+) and pip to continue.'
-          );
-        }
-        await generatePythonProject(options);
-        break;
-
-      default:
-        throw new Error(`The selected stack '${options.stack}' is not supported yet.`);
-    }
-
+    await dispatchGenerator(options);
     spinnerEJS.succeed(chalk.green('Backend scaffolding complete via EJS templates.'));
   } catch (err) {
     spinnerEJS.fail(chalk.red('EJS scaffolding failed.'));
@@ -233,7 +175,51 @@ async function runFreeModePipeline(options) {
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-//  Pro AI Mode — Local Gemma via node-llama-cpp
+//  Generator Dispatcher
+// ═══════════════════════════════════════════════════════════════════════════
+
+async function dispatchGenerator(options) {
+  switch (options.stack) {
+    case 'node-ts-express':
+      await generateNodeProject(options);
+      break;
+
+    case 'js-express':
+      await generateJsProject(options);
+      break;
+
+    case 'nestjs':
+      await generateNestProject(options);
+      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');
+      }
+      await generateDotnetProject(options);
+      break;
+
+    case 'java-spring':
+      if (!(await isCommandAvailable('java'))) {
+        throw new Error('Java (JDK 17+) is not installed. Please install a JDK to continue.');
+      }
+      await generateJavaProject(options);
+      break;
+
+    case 'python-fastapi':
+      if (!(await isCommandAvailable('python'))) {
+        throw new Error('Python is not installed. Please install Python (3.8+) and pip to continue.');
+      }
+      await generatePythonProject(options);
+      break;
+
+    default:
+      throw new Error(`The selected stack '${options.stack}' is not supported yet.`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+//  Pro AI Mode
 // ═══════════════════════════════════════════════════════════════════════════
 
 async function callAIProcessor(astJsonData, apiKey, options) {
@@ -245,16 +231,9 @@ async function callAIProcessor(astJsonData, apiKey, options) {
   console.log(chalk.gray(`  → Input  : ${astJsonData.length} endpoint(s) from AST analysis`));
   console.log('');
 
-  // Live Thought Stream Callback
-  let currentOra = ora({
-    text: chalk.cyan('Firing up autonomous agents...'),
-    spinner: 'mindblown',
-    color: 'magenta'
-  }).start();
+  let currentOra = ora({ text: chalk.cyan('Firing up autonomous agents...'), spinner: 'mindblown', color: 'magenta' }).start();
 
   const onThought = (msg) => {
-    // If it's a THOUGHT, update the spinner text instead of breaking the terminal lines too aggressively
-    // or just console log if it's a major step.
     if (msg.includes('FAILED') || msg.includes('WARNING')) {
       currentOra.warn(chalk.yellow(msg));
       currentOra = ora({ text: chalk.cyan('Continuing...'), spinner: 'mindblown', color: 'magenta' }).start();
@@ -267,17 +246,12 @@ async function callAIProcessor(astJsonData, apiKey, options) {
   await aiAgent.init();
 
   let existingPrisma = null;
-  const prismaPath = path.join(options.projectDir, "prisma", "schema.prisma");
+  const prismaPath = path.join(options.projectDir, 'prisma', 'schema.prisma');
   if (await fs.pathExists(prismaPath)) existingPrisma = await fs.readFile(prismaPath, 'utf8');
 
-  // --- PASS 1 ---
   const pass1Data = await aiAgent.generateBackendBlocks(astJsonData, existingPrisma);
-
-  // --- PASS 2 (Dry Run) ---
   const compTypes = await extractComponentTreeTypes(options.frontendSrcDir);
   const finalBlocks = await aiAgent.verifyDryRun(pass1Data, compTypes);
-
-  // --- PASS 3 (Deployment) ---
   const deployData = await aiAgent.generateDeploymentConfig(options.stack, astJsonData);
 
   await aiAgent.dispose();
@@ -288,17 +262,15 @@ async function callAIProcessor(astJsonData, apiKey, options) {
 
 function printHealthDashboard(blocks) {
   console.log('');
-  console.log(chalk.hex('#BF40FF').bold('  ╔══════════════════════════════════════════════════════════╗'));
-  console.log(chalk.hex('#BF40FF').bold('  ║              📊 SYSTEM HEALTH DASHBOARD 📊                 ║'));
-  console.log(chalk.hex('#BF40FF').bold('  ╚══════════════════════════════════════════════════════════╝'));
-  
-  // Calculate mock scores based on AI completeness
+  console.log(chalk.hex('#BF40FF').bold('  ╔══════════════════════════════════════════════╗'));
+  console.log(chalk.hex('#BF40FF').bold('  ║       📊 SYSTEM HEALTH DASHBOARD 📊          ║'));
+  console.log(chalk.hex('#BF40FF').bold('  ╚══════════════════════════════════════════════╝'));
+
   const secScore = blocks.aiSecurityConfig && blocks.aiSecurityConfig.length > 20 ? 98 : 75;
   const archScore = blocks.aiDbRelations && blocks.aiDbRelations.length > 20 ? 99 : 80;
   const testScore = 85;
+  const colorScore = (s) => (s > 90 ? chalk.green.bold(`${s}% A+`) : chalk.yellow.bold(`${s}% B`));
 
-  const colorScore = (s) => s > 90 ? chalk.green.bold(`${s}% A+`) : chalk.yellow.bold(`${s}% B`);
-  
   console.log('');
   console.log(`  🛡️  Security Profile:       ${colorScore(secScore)}`);
   console.log(`  🏛️  Hexagonal Compliance:   ${colorScore(archScore)}`);
@@ -310,189 +282,184 @@ function printHealthDashboard(blocks) {
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-//  Main CLI Flow
+//  Main CLI Flow — @clack/prompts Interactive UI
 // ═══════════════════════════════════════════════════════════════════════════
 
 async function main() {
   printBanner();
 
+  p.intro(chalk.hex('#00F5FF').bold(' create-backlist — Polyglot Backend Generator '));
+
   // ── Step 1: Mode Selection ─────────────────────────────────────────────
-  const answers = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'generationMode',
-      message: chalk.bold('Select your generation mode:'),
-      choices: [
-        {
-          name: chalk.hex('#00F5FF')('🚀 Standard Mode') + chalk.gray(' (Free — AST + EJS + DOM Check)'),
-          value: 'free',
-        },
-        {
-          name: chalk.hex('#BF40FF')('🧠 Pro AI Mode') + chalk.gray('    (Intelligent Schema & Auth via Gemma)'),
-          value: 'pro',
-        },
+  const generationMode = await p.select({
+    message: 'Select your generation mode:',
+    options: [
+      { value: 'free', label: '🚀 Standard Mode', hint: 'Free — AST + EJS + DOM Check' },
+      { value: 'pro', label: '🧠 Pro AI Mode', hint: 'Intelligent Schema & Auth via Gemma' },
+    ],
+  });
+  if (p.isCancel(generationMode)) { p.cancel('Cancelled.'); process.exit(0); }
+
+  // ── Step 2: Project Name ───────────────────────────────────────────────
+  const projectName = await p.text({
+    message: 'Enter a name for your backend directory:',
+    placeholder: 'backend',
+    defaultValue: 'backend',
+    validate: (v) => { if (!v) return 'Project name cannot be empty.'; },
+  });
+  if (p.isCancel(projectName)) { p.cancel('Cancelled.'); process.exit(0); }
+
+  // ── Step 3: Stack Selection ────────────────────────────────────────────
+  const stack = await p.select({
+    message: 'Select the backend stack:',
+    options: [
+      { value: 'node-ts-express', label: 'Node.js (TypeScript + Express)', hint: 'Hexagonal Architecture' },
+      { value: 'js-express', label: 'Node.js (JavaScript ESM + Express)', hint: 'Lightweight, no TS' },
+      { value: 'nestjs', label: 'NestJS (TypeScript)', hint: 'Modular, enterprise-grade' },
+      { value: 'dotnet-webapi', label: 'C# (ASP.NET Core Web API)' },
+      { value: 'java-spring', label: 'Java (Spring Boot)' },
+      { value: 'python-fastapi', label: 'Python (FastAPI)' },
+    ],
+  });
+  if (p.isCancel(stack)) { p.cancel('Cancelled.'); process.exit(0); }
+
+  // ── Step 4: Frontend Source Path ───────────────────────────────────────
+  const srcPath = await p.text({
+    message: 'Path to your frontend `src` directory:',
+    placeholder: 'src',
+    defaultValue: 'src',
+  });
+  if (p.isCancel(srcPath)) { p.cancel('Cancelled.'); process.exit(0); }
+
+  // ── Step 5: Node-specific options (for node/js/nest stacks) ────────────
+  let dbType = 'mongoose';
+  let addAuth = true;
+  let addSeeder = true;
+  let extraFeatures = ['docker', 'testing', 'swagger'];
+
+  const isNodeStack = ['node-ts-express', 'js-express', 'nestjs'].includes(stack);
+
+  if (generationMode === 'free' && isNodeStack) {
+    dbType = await p.select({
+      message: 'Select your database type:',
+      options: [
+        { value: 'mongoose', label: 'NoSQL (MongoDB + Mongoose)' },
+        { value: 'prisma', label: 'SQL (PostgreSQL/MySQL + Prisma)' },
       ],
-    },
+    });
+    if (p.isCancel(dbType)) { p.cancel('Cancelled.'); process.exit(0); }
 
-    // ── General Questions (both modes) ───────────────────────────────────
-    {
-      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:',
-      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' },
-      ],
-    },
-    {
-      type: 'input',
-      name: 'srcPath',
-      message: 'Enter the path to your frontend `src` directory:',
-      default: 'src',
-    },
+    addAuth = await p.confirm({ message: 'Add JWT authentication boilerplate?', initialValue: true });
+    if (p.isCancel(addAuth)) { p.cancel('Cancelled.'); process.exit(0); }
 
-    // ── Node.js-specific (Free mode only) ────────────────────────────────
-    {
-      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' },
-      ],
-      when: (a) => a.generationMode === 'free' && a.stack === 'node-ts-express',
-    },
-    {
-      type: 'confirm',
-      name: 'addAuth',
-      message: 'Add JWT authentication boilerplate?',
-      default: true,
-      when: (a) => a.generationMode === 'free' && a.stack === 'node-ts-express',
-    },
-    {
-      type: 'confirm',
-      name: 'addSeeder',
-      message: 'Add a database seeder with sample data?',
-      default: true,
-      when: (a) => a.generationMode === 'free' && a.stack === 'node-ts-express' && a.addAuth,
-    },
-    {
-      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 },
+    addSeeder = await p.confirm({ message: 'Add a database seeder with sample data?', initialValue: true });
+    if (p.isCancel(addSeeder)) { p.cancel('Cancelled.'); process.exit(0); }
+
+    extraFeatures = await p.multiselect({
+      message: 'Select additional features:',
+      options: [
+        { value: 'docker', label: 'Docker Support', hint: 'Dockerfile & docker-compose.yml' },
+        { value: 'testing', label: 'API Testing Boilerplate' },
+        { value: 'swagger', label: 'API Documentation (Swagger UI)' },
       ],
-      when: (a) => a.generationMode === 'free' && a.stack === 'node-ts-express',
-    },
-  ]);
+      initialValues: ['docker', 'testing', 'swagger'],
+    });
+    if (p.isCancel(extraFeatures)) { p.cancel('Cancelled.'); process.exit(0); }
+  }
+
+  // ── Step 6: Agentic Confirmation (Yes/No Workflow) ─────────────────────
+  console.log('');
+  p.log.step(chalk.bold('Generation Plan:'));
+  console.log(`  ${chalk.dim('Project:')}    ${chalk.white(projectName)}`);
+  console.log(`  ${chalk.dim('Stack:')}      ${chalk.white(stack)}`);
+  console.log(`  ${chalk.dim('Mode:')}       ${generationMode === 'pro' ? chalk.hex('#BF40FF')('PRO AI') : chalk.hex('#00F5FF')('Standard')}`);
+  if (isNodeStack) {
+    console.log(`  ${chalk.dim('Database:')}   ${chalk.white(dbType)}`);
+    console.log(`  ${chalk.dim('Auth:')}       ${addAuth ? chalk.green('Yes') : chalk.red('No')}`);
+    console.log(`  ${chalk.dim('Seeder:')}     ${addSeeder ? chalk.green('Yes') : chalk.red('No')}`);
+    console.log(`  ${chalk.dim('Extras:')}     ${chalk.white(extraFeatures.join(', ') || 'none')}`);
+  }
+  console.log('');
+
+  const proceed = await p.confirm({
+    message: 'Proceed with generation?',
+    initialValue: true,
+  });
+  if (p.isCancel(proceed) || !proceed) {
+    p.cancel('Generation aborted.');
+    process.exit(0);
+  }
 
-  // ── Build options ──────────────────────────────────────────────────────
+  // ── Build options object ───────────────────────────────────────────────
   const options = {
-    ...answers,
-    projectDir: path.resolve(process.cwd(), answers.projectName),
-    frontendSrcDir: path.resolve(process.cwd(), answers.srcPath),
+    generationMode,
+    projectName,
+    stack,
+    srcPath,
+    dbType,
+    addAuth,
+    addSeeder,
+    extraFeatures,
+    projectDir: path.resolve(process.cwd(), projectName),
+    frontendSrcDir: path.resolve(process.cwd(), srcPath),
   };
 
+  const startTime = Date.now();
+
   try {
     // ── Route: PRO AI MODE ─────────────────────────────────────────────
     if (options.generationMode === 'pro') {
       const apiKey = await getProApiKey();
 
-      // Parse the frontend AST
-      const spinnerParse = ora({
-        text: chalk.white('Parsing frontend source with Babel AST...'),
-        spinner: 'dots12',
-        color: 'cyan',
-      }).start();
-
+      const spinnerParse = ora({ text: chalk.white('Parsing frontend source with Babel AST...'), spinner: 'dots12', color: 'cyan' }).start();
       let astJsonData = [];
       try {
         astJsonData = await analyzeFrontend(options.frontendSrcDir);
-        spinnerParse.succeed(
-          chalk.green(`AST analysis complete — ${astJsonData.length} endpoint(s) detected.`)
-        );
+        spinnerParse.succeed(chalk.green(`AST analysis complete — ${astJsonData.length} endpoint(s) detected.`));
       } catch (err) {
         spinnerParse.warn(chalk.yellow(`AST parse warning: ${err.message}`));
-        console.log(chalk.gray('  → Proceeding with empty endpoint set.'));
       }
 
-      // Invoke AI processor
       const generatedBlocks = await callAIProcessor(astJsonData, apiKey, options);
-
-      // Inject the generated blocks into the options for the templates
       options.aiBlocks = generatedBlocks;
 
-      // Scaffolding via Hexagonal Node generator specifically for Pro Mode
       const spinnerGen = ora({ text: chalk.white('Writing Intelligent Hexagonal Output...'), spinner: 'material', color: 'magenta' }).start();
-      
       try {
-        switch (options.stack) {
-          case 'node-ts-express':
-            await generateNodeProject(options);
-            break;
-          // Note: Add Python/Java logic here mapping aiBlocks once hexagonalized completely
-          default:
-            throw new Error(`Pro Tier currently optimizes Node-TS Hexagonal structures. Using standard generation for ${options.stack}.`);
-        }
+        await dispatchGenerator(options);
         spinnerGen.succeed(chalk.green('Hexagonal Auto-Write successful.'));
       } catch (err) {
         spinnerGen.fail(chalk.red('Write process failed.'));
         throw err;
       }
 
-      // Write autonomous deployment workflows
       if (generatedBlocks.deployment) {
         await fs.ensureDir(path.join(options.projectDir, '.github', 'workflows'));
         await fs.writeFile(path.join(options.projectDir, 'docker-compose.yml'), generatedBlocks.deployment.dockerCompose);
         await fs.writeFile(path.join(options.projectDir, '.github', 'workflows', 'deploy.yml'), generatedBlocks.deployment.githubWorkflow);
       }
 
-      // Print Health Dashboard
       printHealthDashboard(generatedBlocks);
+      printTokenUsage('pro', startTime);
+
+      p.outro(chalk.hex('#BF40FF').bold('PRO generation complete! cd ' + projectName));
       return;
     }
 
     // ── Route: FREE STANDARD MODE ──────────────────────────────────────
     await runFreeModePipeline(options);
+    printTokenUsage('free', startTime);
 
-    // ── Success output ─────────────────────────────────────────────────
-    console.log('');
-    console.log(chalk.hex('#00F5FF').bold('  ╔══════════════════════════════════════════════╗'));
-    console.log(chalk.hex('#00F5FF').bold('  ║     ✅  Backend Generation Complete!  ✅      ║'));
-    console.log(chalk.hex('#00F5FF').bold('  ╚══════════════════════════════════════════════╝'));
-    console.log('');
-    console.log(chalk.white('  Next Steps:'));
-    console.log(chalk.cyan(`    cd ${options.projectName}`));
-    console.log(chalk.cyan('    (Check the generated README.md for instructions)'));
-    console.log('');
+    p.outro(chalk.hex('#00F5FF').bold('Backend generated! cd ' + projectName));
   } catch (error) {
     console.log('');
-    console.error(chalk.red.bold('  ❌ An error occurred during generation:'));
-    console.error(chalk.red(`     ${error.message || error}`));
+    p.log.error(chalk.red.bold(`Generation failed: ${error.message || error}`));
 
     if (error.stack) {
       console.log(chalk.gray(`\n  Stack trace:\n${error.stack}`));
     }
 
-    // Cleanup partial output
     if (options.projectDir && (await fs.pathExists(options.projectDir))) {
-      const spinnerClean = ora({
-        text: chalk.yellow('Cleaning up failed installation...'),
-        spinner: 'line',
-        color: 'yellow',
-      }).start();
+      const spinnerClean = ora({ text: chalk.yellow('Cleaning up...'), spinner: 'line', color: 'yellow' }).start();
       await fs.remove(options.projectDir);
       spinnerClean.succeed(chalk.yellow('Cleanup complete.'));
     }