novatec-cli 3.0.6 → 3.0.8

package/bin/index.js

@@ -26,8 +26,9 @@ async function checkForUpdates() {
 async function showBanner() {
   console.clear();
   const logo = figlet.textSync('NOVATEC', { font: 'Slant' });
+  const grad = (await import('gradient-string')).default;
   console.log();
-  logo.split('\n').filter(l => l.trim()).forEach(l => console.log('  ' + chalk.bold.white(l)));
+  logo.split('\n').filter(l => l.trim()).forEach(l => console.log('  ' + grad.cristal.multiline(l)));
   console.log();
   const now = new Date().toLocaleDateString('es-MX', { day: '2-digit', month: 'short', year: 'numeric' });
   console.log('  ' + chalk.gray(`v${pkg.version}  ·  Enterprise Fullstack CLI  ·  ${now}`));
@@ -36,10 +37,40 @@ async function showBanner() {
   console.log();
   console.log(boxen(
     chalk.bold.white('  STACK DISPONIBLE\n\n') +
-    chalk.white.bold('  Frontend ') + chalk.gray(' │  ') + ['React','Next.js','Vue','Nuxt','Astro','Svelte','SolidJS','Angular','Remix','Qwik'].join(chalk.gray('  ·  ')) + '\n\n' +
-    chalk.white.bold('  Backend  ') + chalk.gray(' │  ') + ['Express','NestJS','Fastify','Hono','FastAPI','Django','Flask','Spring','Deno','Go/Gin'].join(chalk.gray('  ·  ')) + '\n\n' +
-    chalk.white.bold('  Database ') + chalk.gray(' │  ') + ['PostgreSQL','MySQL','MongoDB','SQLite','Supabase'].join(chalk.gray('  ·  ')) + '\n\n' +
-    chalk.white.bold('  Modos    ') + chalk.gray(' │  ') + chalk.white('--mode business') + chalk.gray('  (landing + auth + dashboard + CRUD)') + '\n\n' +
+    chalk.white.bold('  Frontend ') + chalk.gray(' │  ') +
+    [
+      grad('#61DAFB','#21D4FD')(' React'),
+      grad('#fff','#888')(' Next.js'),
+      grad('#42b883','#35495e')(' Vue'),
+      grad('#00DC82','#003543')(' Nuxt'),
+      grad('#FF5D01','#BC52EE')(' Astro'),
+      grad('#FF3E00','#FF8C00')(' Svelte'),
+      grad('#2C4F7C','#446B9E')(' Solid'),
+      grad('#DD0031','#C3002F')(' Angular'),
+      grad('#121212','#818CF8')(' Remix'),
+      grad('#18B6F6','#AC7EF4')(' Qwik'),
+    ].join(chalk.gray('  ·  ')) + '\n\n' +
+    chalk.white.bold('  Backend  ') + chalk.gray(' │  ') +
+    [
+      grad('#fff','#aaa')(' Express'),
+      grad('#E0234E','#FF6B6B')(' NestJS'),
+      grad('#000','#888')(' Fastify'),
+      grad('#FF5733','#FF8C00')(' Hono'),
+      grad('#009688','#26A69A')(' FastAPI'),
+      grad('#092E20','#44B78B')(' Django'),
+      grad('#fff','#aaa')(' Flask'),
+      grad('#6DB33F','#77BC1F')(' Spring'),
+      grad('#fff','#aaa')(' Deno'),
+      grad('#00ACD7','#5DC9E2')(' Go/Gin'),
+    ].join(chalk.gray('  ·  ')) + '\n\n' +
+    chalk.white.bold('  Database ') + chalk.gray(' │  ') +
+    [
+      grad('#336791','#4A90D9')(' PostgreSQL'),
+      grad('#4479A1','#00758F')(' MySQL'),
+      grad('#47A248','#00ED64')(' MongoDB'),
+      grad('#003B57','#0F80CC')(' SQLite'),
+      grad('#3ECF8E','#1C1C1C')(' Supabase'),
+    ].join(chalk.gray('  ·  ')) + '\n\n' +
     chalk.white.bold('  Comandos ') + chalk.gray(' │  ') +
     [chalk.white('create'), chalk.white('add'), chalk.white('doctor'), chalk.white('build'), chalk.white('deploy'), chalk.white('list'), chalk.white('update')]
       .join(chalk.gray('  ·  ')),
@@ -48,7 +79,7 @@ async function showBanner() {
   console.log();
   console.log(boxen(
     chalk.gray('  $ novatec create my-app\n') +
-    chalk.gray('  $ novatec create my-app --mode business --frontend next --backend express\n') +
+    chalk.gray('  $ novatec create my-app --frontend next --backend express --db postgres\n') +
     chalk.gray('  $ novatec add crud Product\n') +
     chalk.gray('  $ novatec doctor'),
     { padding: { top: 0, bottom: 0, left: 1, right: 4 }, margin: { left: 2 }, borderStyle: 'single', borderColor: 'gray', dimBorder: true }

package/lib/generators/backend.js

@@ -1,10 +1,10 @@
 import path from 'path';
 import chalk from 'chalk';
 import fse from 'fs-extra';
+import gradient from 'gradient-string';
 import { execSync } from 'child_process';
 import { isInstalled } from '../utils.js';
 
-// DB packages por backend type
 const NODE_DB_DEPS = {
   postgres: ['pg', 'pg-hstore'],
   mysql:    ['mysql2'],
@@ -14,13 +14,17 @@ const NODE_DB_DEPS = {
   none:     [],
 };
 
+const COLORS = {
+  express: ['#ffffff', '#aaaaaa'], nestjs:  ['#E0234E', '#FF6B6B'],
+  fastify: ['#000000', '#888888'], hono:    ['#FF5733', '#FF8C00'],
+  fastapi: ['#009688', '#26A69A'], django:  ['#092E20', '#44B78B'],
+  flask:   ['#ffffff', '#aaaaaa'], spring:  ['#6DB33F', '#77BC1F'],
+  deno:    ['#ffffff', '#aaaaaa'], gin:     ['#00ACD7', '#5DC9E2'],
+};
+
 function installNodeDeps(prod, dev, cwd) {
-  if (prod.length) {
-    execSync(`npm install ${prod.join(' ')}`, { cwd, stdio: 'pipe' });
-  }
-  if (dev && dev.length) {
-    execSync(`npm install -D ${dev.join(' ')}`, { cwd, stdio: 'pipe' });
-  }
+  if (prod.length) execSync(`npm install ${prod.join(' ')}`, { cwd, stdio: 'pipe' });
+  if (dev && dev.length) execSync(`npm install -D ${dev.join(' ')}`, { cwd, stdio: 'pipe' });
 }
 
 function backendPath(projectPath) {
@@ -28,7 +32,9 @@ function backendPath(projectPath) {
 }
 
 export async function generateBackend(config, projectPath) {
-  console.log(chalk.blue(`\n  ⚙  Generando backend (${chalk.bold(config.backend)})...`));
+  const [c1, c2] = COLORS[config.backend] || ['#ffffff', '#aaaaaa'];
+  const label = gradient(c1, c2)(` ◆ ${config.backend.toUpperCase()} `);
+  console.log(`\n  ${label} ${chalk.gray('Generando backend...')}`);
   const handlers = { express, nestjs, fastify, hono, fastapi, django, flask, spring, deno, gin };
   const fn = handlers[config.backend];
   if (!fn) throw new Error(`Backend no soportado: ${config.backend}`);

package/lib/generators/deploy.js

@@ -2,101 +2,9 @@ import path from 'path';
 import fse from 'fs-extra';
 import chalk from 'chalk';
 import boxen from 'boxen';
-import { execSync } from 'child_process';
+import { execSync, spawnSync } from 'child_process';
 import { isInstalled } from '../utils.js';
 
-// ── GitHub Actions CI ─────────────────────────────────────────────────────────
-export async function generateDeploy(config, root) {
-  const ciDir = path.join(root, '.github', 'workflows');
-  await fse.ensureDir(ciDir);
-  const isPython = ['fastapi','django','flask'].includes(config.backend);
-
-  await fse.writeFile(path.join(ciDir, 'ci.yml'),
-`name: CI/CD Pipeline
-
-on:
-  push:
-    branches: [main, develop]
-  pull_request:
-    branches: [main]
-
-jobs:
-  frontend:
-    name: Frontend — Build & Test
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: frontend
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: npm
-          cache-dependency-path: frontend/package-lock.json
-      - run: npm ci
-      - run: npm run lint --if-present
-      - run: npm test --if-present
-      - run: npm run build
-
-  backend:
-    name: Backend — Lint & Test
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: backend
-    steps:
-      - uses: actions/checkout@v4
-${isPython
-  ? `      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.11'
-      - run: pip install -r requirements.txt
-      - run: python -m pytest --if-present`
-  : `      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-      - run: npm ci
-      - run: npm run lint --if-present
-      - run: npm test --if-present`}
-`);
-
-  await fse.writeFile(path.join(ciDir, 'deploy.yml'),
-`name: Deploy
-
-on:
-  push:
-    branches: [main]
-
-jobs:
-  deploy-frontend:
-    name: Deploy Frontend → Vercel
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-      - run: npm install -g vercel
-      - run: cd frontend && npm ci && npm run build
-      - run: vercel --prod --token \${{ secrets.VERCEL_TOKEN }} --yes
-        env:
-          VERCEL_ORG_ID: \${{ secrets.VERCEL_ORG_ID }}
-          VERCEL_PROJECT_ID: \${{ secrets.VERCEL_PROJECT_ID }}
-
-  deploy-backend:
-    name: Deploy Backend → Railway
-    runs-on: ubuntu-latest
-    needs: deploy-frontend
-    steps:
-      - uses: actions/checkout@v4
-      - uses: railwayapp/railway-github-action@v1
-        with:
-          railway-token: \${{ secrets.RAILWAY_TOKEN }}
-          service: backend
-`);
-}
-
 // ── novatec build ─────────────────────────────────────────────────────────────
 export async function runBuild(options) {
   const root = process.cwd();
@@ -107,12 +15,13 @@ export async function runBuild(options) {
   console.log(chalk.white('  Building proyecto...\n'));
 
   if ((options.frontend || !options.backend) && hasFe) {
-    const spinner = (await import('ora')).default({ text: chalk.white('Build frontend...'), spinner: 'dots', color: 'white' }).start();
+    const ora = (await import('ora')).default;
+    const spinner = ora({ text: chalk.white('Build frontend...'), spinner: 'dots', color: 'white' }).start();
     try {
       execSync('npm run build', { cwd: path.join(root, 'frontend'), stdio: 'pipe', encoding: 'utf8' });
-      spinner.succeed(chalk.white('Frontend build OK'));
+      spinner.succeed(chalk.white('Frontend build ✔'));
     } catch (err) {
-      spinner.fail(chalk.red('Frontend build falló\n' + (err.stderr || '')));
+      spinner.fail(chalk.red('Frontend build falló: ' + (err.stderr || err.message || '').split('\n')[0]));
     }
   }
 
@@ -121,13 +30,16 @@ export async function runBuild(options) {
     if (await fse.pathExists(pkgPath)) {
       const pkg = await fse.readJSON(pkgPath);
       if (pkg.scripts?.build) {
-        const spinner = (await import('ora')).default({ text: chalk.white('Build backend...'), spinner: 'dots', color: 'white' }).start();
+        const ora = (await import('ora')).default;
+        const spinner = ora({ text: chalk.white('Build backend...'), spinner: 'dots', color: 'white' }).start();
         try {
           execSync('npm run build', { cwd: path.join(root, 'backend'), stdio: 'pipe', encoding: 'utf8' });
-          spinner.succeed(chalk.white('Backend build OK'));
-        } catch {
-          spinner.fail(chalk.red('Backend build falló'));
+          spinner.succeed(chalk.white('Backend build ✔'));
+        } catch (err) {
+          spinner.fail(chalk.red('Backend build falló: ' + (err.stderr || err.message || '').split('\n')[0]));
         }
+      } else {
+        console.log(chalk.gray('  Backend: no tiene script build, omitiendo.'));
       }
     }
   }
@@ -139,36 +51,145 @@ export async function runBuild(options) {
 
 // ── novatec deploy ────────────────────────────────────────────────────────────
 export async function runDeploy(options) {
+  const root = process.cwd();
+  const hasFe = await fse.pathExists(path.join(root, 'frontend'));
+  const hasBe = await fse.pathExists(path.join(root, 'backend'));
+
+  const deployFe = options.frontend || (!options.frontend && !options.backend);
+  const deployBe = options.backend  || (!options.frontend && !options.backend);
+
+  // Verificar que estamos en un proyecto novatec
+  if (!hasFe && !hasBe) {
+    console.log(boxen(
+      chalk.yellow('  Ejecuta este comando dentro de un proyecto NovaTec\n\n') +
+      chalk.gray('  cd mi-proyecto\n') +
+      chalk.gray('  novatec deploy'),
+      { padding: 1, margin: { left: 2 }, borderStyle: 'round', borderColor: 'yellow', dimBorder: true }
+    ));
+    process.exit(1);
+  }
+
   console.log();
   console.log(boxen(
     chalk.bold.white('  DEPLOY — NovaTec CLI\n\n') +
-    chalk.white('  Frontend → Vercel\n') +
-    chalk.white('  Backend  → Railway\n\n') +
-    chalk.gray('  Asegúrate de tener instalados:\n') +
-    chalk.gray('  npm install -g vercel\n') +
-    chalk.gray('  npm install -g @railway/cli'),
+    (deployFe && hasFe ? chalk.white('  ▲ Frontend  →  Vercel\n')  : '') +
+    (deployBe && hasBe ? chalk.white('  ◆ Backend   →  Railway\n') : ''),
     { padding: 1, margin: { left: 2 }, borderStyle: 'round', borderColor: 'white', dimBorder: true }
   ));
 
-  const root = process.cwd();
+  // ── FRONTEND → VERCEL ───────────────────────────────────────────────────────
+  if (deployFe && hasFe) {
+    console.log(chalk.white('\n  ▲ Desplegando frontend en Vercel...\n'));
 
-  if ((options.frontend || !options.backend)) {
+    // Instalar Vercel CLI si no está
     if (!isInstalled('vercel')) {
-      console.log(chalk.yellow('\n  Instalando Vercel CLI...'));
-      execSync('npm install -g vercel', { stdio: 'inherit' });
+      console.log(chalk.gray('  Instalando Vercel CLI...'));
+      try {
+        execSync('npm install -g vercel', { stdio: 'pipe' });
+        console.log(chalk.green('  ✔ Vercel CLI instalado'));
+      } catch (e) {
+        console.log(chalk.red('  ✖ Error instalando Vercel CLI: ' + e.message));
+        console.log(chalk.gray('  Instala manualmente: npm install -g vercel'));
+        process.exit(1);
+      }
+    }
+
+    // Verificar login
+    try {
+      execSync('vercel whoami', { stdio: 'pipe' });
+    } catch {
+      console.log(chalk.yellow('  No estás logueado en Vercel. Iniciando login...\n'));
+      spawnSync('vercel', ['login'], { cwd: path.join(root, 'frontend'), stdio: 'inherit' });
+    }
+
+    // Deploy
+    console.log(chalk.gray('  Ejecutando: vercel --prod\n'));
+    const r = spawnSync('vercel', ['--prod'], {
+      cwd: path.join(root, 'frontend'),
+      stdio: 'inherit',
+    });
+
+    if (r.status === 0) {
+      console.log(chalk.green('\n  ✔ Frontend desplegado en Vercel'));
+    } else {
+      console.log(chalk.red('\n  ✖ Error desplegando frontend'));
     }
-    console.log(chalk.white('\n  Desplegando frontend en Vercel...'));
-    execSync('vercel --prod', { cwd: path.join(root, 'frontend'), stdio: 'inherit' });
   }
 
-  if ((options.backend || !options.frontend)) {
+  // ── BACKEND → RAILWAY ───────────────────────────────────────────────────────
+  if (deployBe && hasBe) {
+    console.log(chalk.white('\n  ◆ Desplegando backend en Railway...\n'));
+
+    // Instalar Railway CLI si no está
     if (!isInstalled('railway')) {
-      console.log(chalk.yellow('\n  Instalando Railway CLI...'));
-      execSync('npm install -g @railway/cli', { stdio: 'inherit' });
+      console.log(chalk.gray('  Instalando Railway CLI...'));
+      try {
+        execSync('npm install -g @railway/cli', { stdio: 'pipe' });
+        console.log(chalk.green('  ✔ Railway CLI instalado'));
+      } catch (e) {
+        console.log(chalk.red('  ✖ Error instalando Railway CLI: ' + e.message));
+        console.log(chalk.gray('  Instala manualmente: npm install -g @railway/cli'));
+        process.exit(1);
+      }
+    }
+
+    // Verificar login
+    try {
+      execSync('railway whoami', { stdio: 'pipe' });
+    } catch {
+      console.log(chalk.yellow('  No estás logueado en Railway. Iniciando login...\n'));
+      spawnSync('railway', ['login'], { stdio: 'inherit' });
+    }
+
+    // Verificar si hay proyecto Railway vinculado
+    const railwayJson = path.join(root, 'backend', '.railway');
+    const hasRailwayProject = await fse.pathExists(railwayJson);
+
+    if (!hasRailwayProject) {
+      console.log(chalk.yellow('  No hay proyecto Railway vinculado.'));
+      console.log(chalk.gray('  Vinculando proyecto (se abrirá selector)...\n'));
+      const link = spawnSync('railway', ['link'], {
+        cwd: path.join(root, 'backend'),
+        stdio: 'inherit',
+      });
+      if (link.status !== 0) {
+        console.log(chalk.gray('\n  O crea uno nuevo con: railway init'));
+        console.log(chalk.gray('  Luego ejecuta: novatec deploy --backend'));
+        process.exit(1);
+      }
+    }
+
+    // Deploy
+    console.log(chalk.gray('  Ejecutando: railway up\n'));
+    const r = spawnSync('railway', ['up', '--detach'], {
+      cwd: path.join(root, 'backend'),
+      stdio: 'inherit',
+    });
+
+    if (r.status === 0) {
+      console.log(chalk.green('\n  ✔ Backend desplegado en Railway'));
+      console.log(chalk.gray('  Ver logs: railway logs'));
+      console.log(chalk.gray('  Abrir:    railway open'));
+    } else {
+      console.log(chalk.red('\n  ✖ Error desplegando backend'));
+      console.log(chalk.gray('  Ver logs: railway logs'));
     }
-    console.log(chalk.white('\n  Desplegando backend en Railway...'));
-    execSync('railway up', { cwd: path.join(root, 'backend'), stdio: 'inherit' });
   }
 
+  // ── RESUMEN ─────────────────────────────────────────────────────────────────
+  console.log();
+  console.log(boxen(
+    chalk.bold.white('  GUÍA RÁPIDA\n\n') +
+    chalk.white('  Vercel (Frontend)\n') +
+    chalk.gray('  1. vercel login\n') +
+    chalk.gray('  2. cd frontend && vercel --prod\n') +
+    chalk.gray('  3. Variables de entorno → vercel.com/dashboard\n\n') +
+    chalk.white('  Railway (Backend)\n') +
+    chalk.gray('  1. railway login\n') +
+    chalk.gray('  2. cd backend && railway init\n') +
+    chalk.gray('  3. railway up\n') +
+    chalk.gray('  4. Variables de entorno → railway.app/dashboard'),
+    { padding: 1, margin: { left: 2 }, borderStyle: 'single', borderColor: 'gray', dimBorder: true }
+  ));
   console.log();
 }

package/lib/generators/frontend.js

@@ -1,9 +1,9 @@
 import path from 'path';
 import chalk from 'chalk';
 import fse from 'fs-extra';
+import gradient from 'gradient-string';
 import { execSync } from 'child_process';
 
-// Comandos de scaffolding por framework
 const SCAFFOLD = {
   react:   'npm create vite@latest frontend -- --template react',
   vue:     'npm create vite@latest frontend -- --template vue',
@@ -17,11 +17,26 @@ const SCAFFOLD = {
   qwik:    'npm create qwik@latest frontend -- --no-install',
 };
 
+const COLORS = {
+  react:   ['#61DAFB', '#21D4FD'],
+  next:    ['#ffffff', '#888888'],
+  vue:     ['#42b883', '#35495e'],
+  nuxt:    ['#00DC82', '#003543'],
+  astro:   ['#FF5D01', '#BC52EE'],
+  svelte:  ['#FF3E00', '#FF8C00'],
+  solid:   ['#2C4F7C', '#446B9E'],
+  angular: ['#DD0031', '#C3002F'],
+  remix:   ['#818CF8', '#6366F1'],
+  qwik:    ['#18B6F6', '#AC7EF4'],
+};
+
 export async function generateFrontend(config, projectPath) {
   const cmd = SCAFFOLD[config.frontend];
   if (!cmd) throw new Error(`Frontend no soportado: ${config.frontend}`);
 
-  console.log(chalk.blue(`\n  ⚛  Generando frontend (${chalk.bold(config.frontend)})...`));
+  const [c1, c2] = COLORS[config.frontend] || ['#ffffff', '#aaaaaa'];
+  const label = gradient(c1, c2)(` ◆ ${config.frontend.toUpperCase()} `);
+  console.log(chalk.blue(`\n  ${label} ${chalk.gray('Generando frontend...')}`));
 
   try {
     execSync(cmd, { cwd: projectPath, stdio: 'pipe' });

package/lib/prompts.js

@@ -1,54 +1,88 @@
 import inquirer from 'inquirer';
 import chalk from 'chalk';
+import gradient from 'gradient-string';
 import fse from 'fs-extra';
 import path from 'path';
 import boxen from 'boxen';
 
+// Colores reales de cada framework/DB
+const g = {
+  react:    gradient('#61DAFB', '#21D4FD'),
+  next:     gradient('#ffffff', '#888888'),
+  vue:      gradient('#42b883', '#35495e'),
+  nuxt:     gradient('#00DC82', '#003543'),
+  astro:    gradient('#FF5D01', '#BC52EE'),
+  svelte:   gradient('#FF3E00', '#FF8C00'),
+  solid:    gradient('#2C4F7C', '#446B9E'),
+  angular:  gradient('#DD0031', '#C3002F'),
+  remix:    gradient('#121212', '#818CF8'),
+  qwik:     gradient('#18B6F6', '#AC7EF4'),
+  express:  gradient('#ffffff', '#aaaaaa'),
+  nestjs:   gradient('#E0234E', '#FF6B6B'),
+  fastify:  gradient('#000000', '#888888'),
+  hono:     gradient('#FF5733', '#FF8C00'),
+  fastapi:  gradient('#009688', '#26A69A'),
+  django:   gradient('#092E20', '#44B78B'),
+  flask:    gradient('#ffffff', '#aaaaaa'),
+  spring:   gradient('#6DB33F', '#77BC1F'),
+  deno:     gradient('#ffffff', '#aaaaaa'),
+  gin:      gradient('#00ACD7', '#5DC9E2'),
+  postgres: gradient('#336791', '#4A90D9'),
+  mysql:    gradient('#4479A1', '#00758F'),
+  mongo:    gradient('#47A248', '#00ED64'),
+  sqlite:   gradient('#003B57', '#0F80CC'),
+  supabase: gradient('#3ECF8E', '#1C1C1C'),
+};
+
+function logo(key, text) {
+  return g[key] ? g[key](text) : chalk.white(text);
+}
+
 export const FRONTEND_CHOICES = [
-  { name: 'React       — Vite + React 18',        value: 'react'   },
-  { name: 'Next.js     — SSR/SSG App Router',     value: 'next'    },
-  { name: 'Vue 3       — Vite + Composition API', value: 'vue'     },
-  { name: 'Nuxt 3      — Vue SSR/SSG',            value: 'nuxt'    },
-  { name: 'Astro       — MPA ultra-rápido',       value: 'astro'   },
-  { name: 'SvelteKit   — Svelte SSR/SSG',         value: 'svelte'  },
-  { name: 'SolidJS     — Sin Virtual DOM',        value: 'solid'   },
-  { name: 'Angular     — Framework empresarial',  value: 'angular' },
-  { name: 'Remix       — Full-stack React',       value: 'remix'   },
-  { name: 'Qwik        — Resumability',           value: 'qwik'    },
+  { name: logo('react',   ' ◆ React      ') + chalk.gray(' — Vite + React 18'),        value: 'react'   },
+  { name: logo('next',    ' ▲ Next.js    ') + chalk.gray(' — SSR/SSG App Router'),     value: 'next'    },
+  { name: logo('vue',     ' ◈ Vue 3      ') + chalk.gray(' — Vite + Composition API'), value: 'vue'     },
+  { name: logo('nuxt',    ' ◈ Nuxt 3     ') + chalk.gray(' — Vue SSR/SSG'),            value: 'nuxt'    },
+  { name: logo('astro',   ' ✦ Astro      ') + chalk.gray(' — MPA ultra-rápido'),       value: 'astro'   },
+  { name: logo('svelte',  ' ◆ SvelteKit  ') + chalk.gray(' — Svelte SSR/SSG'),         value: 'svelte'  },
+  { name: logo('solid',   ' ◆ SolidJS    ') + chalk.gray(' — Sin Virtual DOM'),        value: 'solid'   },
+  { name: logo('angular', ' ◆ Angular    ') + chalk.gray(' — Framework empresarial'),  value: 'angular' },
+  { name: logo('remix',   ' ◆ Remix      ') + chalk.gray(' — Full-stack React'),       value: 'remix'   },
+  { name: logo('qwik',    ' ⚡ Qwik       ') + chalk.gray(' — Resumability'),           value: 'qwik'    },
 ];
 
 export const BACKEND_CHOICES = [
-  { name: 'Express     — Minimalista Node.js',    value: 'express'  },
-  { name: 'NestJS      — Modular TypeScript',     value: 'nestjs'   },
-  { name: 'Fastify     — Ultra-rápido Node',      value: 'fastify'  },
-  { name: 'Hono        — Edge-ready ligero',      value: 'hono'     },
-  { name: 'FastAPI     — Async Python',           value: 'fastapi'  },
-  { name: 'Django      — Baterías incluidas',     value: 'django'   },
-  { name: 'Flask       — Micro-framework Python', value: 'flask'    },
-  { name: 'Spring Boot — Empresarial Java',       value: 'spring'   },
-  { name: 'Deno/Oak    — TypeScript seguro',      value: 'deno'     },
-  { name: 'Go/Gin      — Rendimiento extremo',    value: 'gin'      },
+  { name: logo('express',  ' ◆ Express    ') + chalk.gray(' — Minimalista Node.js'),    value: 'express'  },
+  { name: logo('nestjs',   ' ◆ NestJS     ') + chalk.gray(' — Modular TypeScript'),     value: 'nestjs'   },
+  { name: logo('fastify',  ' ⚡ Fastify    ') + chalk.gray(' — Ultra-rápido Node'),      value: 'fastify'  },
+  { name: logo('hono',     ' ◆ Hono       ') + chalk.gray(' — Edge-ready ligero'),      value: 'hono'     },
+  { name: logo('fastapi',  ' ◆ FastAPI    ') + chalk.gray(' — Async Python'),           value: 'fastapi'  },
+  { name: logo('django',   ' ◆ Django     ') + chalk.gray(' — Baterías incluidas'),     value: 'django'   },
+  { name: logo('flask',    ' ◆ Flask      ') + chalk.gray(' — Micro-framework Python'), value: 'flask'    },
+  { name: logo('spring',   ' ◆ Spring Boot') + chalk.gray(' — Empresarial Java'),       value: 'spring'   },
+  { name: logo('deno',     ' ◆ Deno/Oak   ') + chalk.gray(' — TypeScript seguro'),      value: 'deno'     },
+  { name: logo('gin',      ' ◆ Go/Gin     ') + chalk.gray(' — Rendimiento extremo'),    value: 'gin'      },
 ];
 
 export const DB_CHOICES = [
-  { name: 'PostgreSQL  — Relacional robusto',     value: 'postgres'  },
-  { name: 'MySQL       — Relacional popular',     value: 'mysql'     },
-  { name: 'MongoDB     — NoSQL documentos',       value: 'mongo'     },
-  { name: 'SQLite      — Embebido ligero',        value: 'sqlite'    },
-  { name: 'Supabase    — BaaS con Auth incluida', value: 'supabase'  },
-  { name: 'Ninguna',                              value: 'none'      },
+  { name: logo('postgres', ' ◆ PostgreSQL ') + chalk.gray(' — Relacional robusto'),     value: 'postgres'  },
+  { name: logo('mysql',    ' ◆ MySQL      ') + chalk.gray(' — Relacional popular'),     value: 'mysql'     },
+  { name: logo('mongo',    ' ◆ MongoDB    ') + chalk.gray(' — NoSQL documentos'),       value: 'mongo'     },
+  { name: logo('sqlite',   ' ◆ SQLite     ') + chalk.gray(' — Embebido ligero'),        value: 'sqlite'    },
+  { name: logo('supabase', ' ◆ Supabase   ') + chalk.gray(' — BaaS con Auth incluida'), value: 'supabase'  },
+  { name: chalk.gray(' ○ Ninguna'),                                                      value: 'none'      },
 ];
 
 export const ARCH_CHOICES = [
-  { name: 'MVC         — Model-View-Controller (clásico)',  value: 'mvc'       },
-  { name: 'Hexagonal   — Ports & Adapters',                value: 'hexagonal' },
-  { name: 'Clean       — Clean Architecture (capas)',      value: 'clean'     },
+  { name: chalk.white(' ◆ MVC        ') + chalk.gray(' — Model-View-Controller (clásico)'),  value: 'mvc'       },
+  { name: chalk.white(' ◆ Hexagonal  ') + chalk.gray(' — Ports & Adapters'),                value: 'hexagonal' },
+  { name: chalk.white(' ◆ Clean      ') + chalk.gray(' — Clean Architecture (capas)'),      value: 'clean'     },
 ];
 
 export const PM_CHOICES = [
-  { name: 'npm',  value: 'npm'  },
-  { name: 'pnpm', value: 'pnpm' },
-  { name: 'yarn', value: 'yarn' },
+  { name: chalk.white(' ◆ npm'),  value: 'npm'  },
+  { name: chalk.white(' ◆ pnpm'), value: 'pnpm' },
+  { name: chalk.white(' ◆ yarn'), value: 'yarn' },
 ];
 
 export async function askProjectOptions(nameArg, options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "novatec-cli",
-  "version": "3.0.6",
+  "version": "3.0.8",
   "description": "🚀 NOVATEC FULLSTACK CLI — Generador profesional de proyectos full stack | React, Next.js, Vue, Express, NestJS, FastAPI y más",
   "type": "module",
   "main": "./lib/create.js",