novatec-cli 3.0.2 → 3.0.3

package/lib/create.js

@@ -6,150 +6,95 @@ import { execSync } from 'child_process';
 import { askProjectOptions } from './prompts.js';
 import { generateFrontend } from './generators/frontend.js';
 import { generateBackend } from './generators/backend.js';
-import { generateBusiness } from './generators/business.js';
-import { generateDocker } from './generators/docker.js';
-import { generateSecurity } from './generators/security.js';
-import { generateDeploy } from './generators/deploy.js';
 import { isInstalled } from './utils.js';
 
-function bar(cur, tot, label) {
-  const w = 28, f = Math.round((cur / tot) * w);
-  const pct = Math.round((cur / tot) * 100);
-  process.stdout.write(`\r  [${'█'.repeat(f)}${'░'.repeat(w - f)}] ${chalk.white(pct + '%')}  ${chalk.gray(label.substring(0, 30))}          `);
-}
-
 export async function runCreate(nameArg, options) {
   const t0 = Date.now();
   const config = await askProjectOptions(nameArg, options);
   const root = path.resolve(process.cwd(), config.name);
   await fse.ensureDir(root);
 
-  const extras = config.extras || [];
   const isPython = ['fastapi', 'django', 'flask'].includes(config.backend);
   const pm = config.pm || 'npm';
 
-  // Calcular pasos
-  const steps = ['Frontend', 'Backend', 'README', 'Env files',
-    config.mode === 'business' && 'Business mode',
-    extras.includes('docker')   && 'Docker',
-    extras.includes('security') && 'Seguridad',
-    extras.includes('ci')       && 'GitHub Actions',
-    extras.includes('eslint')   && 'ESLint',
-    extras.includes('testing')  && 'Testing',
-    extras.includes('swagger')  && 'Swagger',
-    extras.includes('logs')     && 'Logs',
-    extras.includes('seo')      && 'SEO',
-    extras.includes('git')      && 'Git',
-    config.install              && 'Instalando deps',
-  ].filter(Boolean);
-
   console.log();
-  let step = 0;
-  const tick = (label) => { step++; bar(step, steps.length, label); };
 
   // 1. Frontend
-  tick('Generando frontend...');
+  console.log(chalk.white('  [1/4] Generando frontend...'));
   await generateFrontend(config, root);
-  await connectFrontendToBackend(config, root);
 
-  // 2. Backend con arquitectura
-  tick('Generando backend...');
+  // 2. Backend
+  console.log(chalk.white('  [2/4] Generando backend...'));
   await generateBackend(config, root);
-  await applyArchitecture(config, root);
 
-  // 3. README
-  tick('README...');
-  await generateReadme(config, root);
+  // 3. Arquitectura
+  console.log(chalk.white('  [3/4] Aplicando arquitectura...'));
+  await applyArchitecture(config, root);
 
-  // 4. .env
-  tick('.env files...');
+  // 4. Archivos base (.env, README)
+  console.log(chalk.white('  [4/4] Generando archivos base...'));
   await generateEnv(config, root);
+  await generateReadme(config, root);
 
-  // 5. Business mode
-  if (config.mode === 'business') {
-    tick('Business mode...');
-    await generateBusiness(config, root);
-  }
-
-  // 6. Docker
-  if (extras.includes('docker')) {
-    tick('Docker...');
-    await generateDocker(config, root);
-  }
-
-  // 7. Seguridad
-  if (extras.includes('security')) {
-    tick('Seguridad...');
-    await generateSecurity(config, root);
-  }
-
-  // 8. GitHub Actions
-  if (extras.includes('ci')) {
-    tick('GitHub Actions...');
-    await generateDeploy(config, root);
-  }
-
-  // 9. ESLint
-  if (extras.includes('eslint')) {
-    tick('ESLint...');
-    await setupEslint(root);
-  }
-
-  // 10. Testing
-  if (extras.includes('testing')) {
-    tick('Testing...');
-    await setupTesting(root);
-  }
-
-  // 11. Swagger (ya incluido en security/backend, solo notificar)
-  if (extras.includes('swagger')) {
-    tick('Swagger...');
-    // generado en generateSecurity
-  }
-
-  // 12. Logs
-  if (extras.includes('logs')) {
-    tick('Logs...');
-    await setupLogs(config, root);
-  }
+  // 5. Instalar dependencias
+  if (config.install) {
+    console.log();
+    console.log(chalk.white('  Instalando dependencias...'));
+    const feDir = path.join(root, 'frontend');
+    const beDir = path.join(root, 'backend');
+    const installCmd = pm === 'yarn' ? 'yarn' : `${pm} install`;
 
-  // 13. SEO
-  if (extras.includes('seo')) {
-    tick('SEO...');
-    await setupSEO(config, root);
-  }
+    if (await fse.pathExists(path.join(feDir, 'package.json'))) {
+      try {
+        console.log(chalk.gray(`    → frontend (${pm} install)`));
+        execSync(installCmd, { cwd: feDir, stdio: 'inherit' });
+      } catch (e) {
+        console.log(chalk.yellow('    ⚠ Error instalando frontend: ' + e.message));
+      }
+    }
 
-  // 14. Git
-  if (extras.includes('git') && isInstalled('git')) {
-    tick('Git init...');
-    try {
-      execSync('git init', { cwd: root, stdio: 'pipe' });
-      await fse.writeFile(path.join(root, '.gitignore'), GITIGNORE);
-    } catch {}
-  }
+    if (!isPython && await fse.pathExists(path.join(beDir, 'package.json'))) {
+      try {
+        console.log(chalk.gray(`    → backend (${pm} install)`));
+        execSync(installCmd, { cwd: beDir, stdio: 'inherit' });
+      } catch (e) {
+        console.log(chalk.yellow('    ⚠ Error instalando backend: ' + e.message));
+      }
+    }
 
-  // 15. Instalar deps
-  if (config.install && isInstalled(pm)) {
-    tick('Instalando dependencias...');
-    const fe = path.join(root, 'frontend');
-    const be = path.join(root, 'backend');
-    const installCmd = pm === 'yarn' ? 'yarn' : `${pm} install`;
-    try { execSync(installCmd, { cwd: fe, stdio: 'pipe' }); } catch {}
-    if (!isPython) {
-      try { execSync(installCmd, { cwd: be, stdio: 'pipe' }); } catch {}
+    if (isPython && await fse.pathExists(path.join(beDir, 'requirements.txt'))) {
+      if (isInstalled('pip')) {
+        try {
+          console.log(chalk.gray('    → backend (pip install -r requirements.txt)'));
+          execSync('pip install -r requirements.txt', { cwd: beDir, stdio: 'inherit' });
+        } catch (e) {
+          console.log(chalk.yellow('    ⚠ Error instalando backend Python: ' + e.message));
+        }
+      } else {
+        console.log(chalk.yellow('    ⚠ pip no encontrado. Ejecuta manualmente: pip install -r requirements.txt'));
+      }
     }
   }
 
-  bar(steps.length, steps.length, 'Completado');
-  console.log('\n');
-
   const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
-  const beCmd = { express:'npm run dev', nestjs:'npm run start:dev', fastify:'npm run dev', hono:'npm run dev', fastapi:'uvicorn main:app --reload', django:'python manage.py runserver', flask:'python run.py', spring:'mvn spring-boot:run', deno:'deno task dev', gin:'go run main.go' };
 
+  const beCmd = {
+    express: 'npm run dev',
+    nestjs:  'npm run start:dev',
+    fastify: 'npm run dev',
+    hono:    'npm run dev',
+    fastapi: 'uvicorn main:app --reload',
+    django:  'python manage.py runserver',
+    flask:   'python run.py',
+    spring:  'mvn spring-boot:run',
+    deno:    'deno task dev',
+    gin:     'go run main.go',
+  };
+
+  console.log();
   console.log(boxen(
     chalk.bold.white('  ✔  PROYECTO LISTO  —  NovaTec CLI\n\n') +
     chalk.gray('  Nombre       │ ') + chalk.white(config.name) + '\n' +
-    chalk.gray('  Modo         │ ') + chalk.white(config.mode || 'estándar') + '\n' +
     chalk.gray('  Frontend     │ ') + chalk.white(config.frontend) + (config.typescript ? chalk.gray(' + TypeScript') : '') + '\n' +
     chalk.gray('  Backend      │ ') + chalk.white(config.backend) + '\n' +
     chalk.gray('  Base datos   │ ') + chalk.white(config.db || 'ninguna') + '\n' +
@@ -157,12 +102,9 @@ export async function runCreate(nameArg, options) {
     chalk.gray('  Tiempo       │ ') + chalk.white(elapsed + 's') + '\n\n' +
     chalk.gray('  ─────────────────────────────────────────────\n\n') +
     chalk.white('  # Frontend\n') +
-    chalk.gray(`  cd ${config.name}/frontend\n`) +
-    chalk.gray(`  ${pm} ${pm === 'yarn' ? '' : 'run '}dev\n\n`) +
+    chalk.gray(`  cd ${config.name}/frontend && ${pm} run dev\n\n`) +
     chalk.white('  # Backend\n') +
-    chalk.gray(`  cd ${config.name}/backend\n`) +
-    chalk.gray(`  ${beCmd[config.backend] || pm + ' run dev'}\n`) +
-    (config.mode === 'business' ? '\n' + chalk.gray('  # Dashboard → http://localhost:5173/dashboard\n') + chalk.gray('  # API Docs  → http://localhost:3001/api-docs') : ''),
+    chalk.gray(`  cd ${config.name}/backend && ${beCmd[config.backend] || pm + ' run dev'}`),
     { padding: 1, margin: { top: 1, left: 2 }, borderStyle: 'round', borderColor: 'white', dimBorder: true }
   ));
 
@@ -174,32 +116,6 @@ export async function runCreate(nameArg, options) {
   console.log();
 }
 
-// ── CONEXIÓN FE → BE ──────────────────────────────────────────────────────────
-async function connectFrontendToBackend(config, root) {
-  const feDir = path.join(root, 'frontend');
-  const isPython = ['fastapi', 'django', 'flask'].includes(config.backend);
-  const bePort = isPython ? '8000' : '3001';
-
-  // Archivo de API client
-  const apiClient = config.db === 'supabase'
-    ? `import { createClient } from '@supabase/supabase-js';\n\nexport const supabase = createClient(\n  import.meta.env.VITE_SUPABASE_URL,\n  import.meta.env.VITE_SUPABASE_ANON_KEY\n);\n\nexport const api = {\n  get: (url) => fetch(import.meta.env.VITE_API_URL + url).then(r => r.json()),\n  post: (url, data) => fetch(import.meta.env.VITE_API_URL + url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(data) }).then(r => r.json()),\n  put: (url, data) => fetch(import.meta.env.VITE_API_URL + url, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(data) }).then(r => r.json()),\n  delete: (url) => fetch(import.meta.env.VITE_API_URL + url, { method: 'DELETE' }).then(r => r.json()),\n};\n`
-    : `const BASE = import.meta.env.VITE_API_URL || 'http://localhost:${bePort}';\n\nconst headers = () => ({\n  'Content-Type': 'application/json',\n  ...(localStorage.getItem('token') ? { Authorization: \`Bearer \${localStorage.getItem('token')}\` } : {}),\n});\n\nexport const api = {\n  get:    (url)       => fetch(BASE + url, { headers: headers() }).then(r => r.json()),\n  post:   (url, data) => fetch(BASE + url, { method: 'POST',   headers: headers(), body: JSON.stringify(data) }).then(r => r.json()),\n  put:    (url, data) => fetch(BASE + url, { method: 'PUT',    headers: headers(), body: JSON.stringify(data) }).then(r => r.json()),\n  delete: (url)       => fetch(BASE + url, { method: 'DELETE', headers: headers() }).then(r => r.json()),\n};\n`;
-
-  const srcDir = path.join(feDir, 'src', 'lib');
-  await fse.ensureDir(srcDir);
-  await fse.writeFile(path.join(srcDir, 'api.js'), apiClient);
-
-  // Proxy en vite.config si aplica
-  const viteConfig = path.join(feDir, 'vite.config.js');
-  if (await fse.pathExists(viteConfig)) {
-    const content = await fse.readFile(viteConfig, 'utf8');
-    if (!content.includes('proxy')) {
-      const proxy = `\n    server: {\n      proxy: {\n        '/api': {\n          target: 'http://localhost:${bePort}',\n          changeOrigin: true,\n        },\n      },\n    },`;
-      await fse.writeFile(viteConfig, content.replace('plugins:', proxy + '\n  plugins:'));
-    }
-  }
-}
-
 // ── ARQUITECTURA ──────────────────────────────────────────────────────────────
 async function applyArchitecture(config, root) {
   const beDir = path.join(root, 'backend', 'src');
@@ -217,72 +133,67 @@ async function applyArchitecture(config, root) {
   }
 }
 
-// ── ENV ───────────────────────────────────────────────────────────────────────
+// ── .ENV ──────────────────────────────────────────────────────────────────────
 async function generateEnv(config, root) {
   const isPython = ['fastapi', 'django', 'flask'].includes(config.backend);
+  const bePort = isPython ? '8000' : '3001';
+
   const dbUrl = {
     postgres: 'postgresql://user:password@localhost:5432/mydb',
     mysql:    'mysql://user:password@localhost:3306/mydb',
     mongo:    'mongodb://localhost:27017/mydb',
     sqlite:   'file:./dev.db',
-    supabase: config.supabaseUrl || 'https://your-project.supabase.co',
+    supabase: 'https://your-project.supabase.co',
   }[config.db] || '';
 
-  const feEnv = `VITE_API_URL=http://localhost:${isPython ? '8000' : '3001'}\n` +
-    (config.db === 'supabase' ? `VITE_SUPABASE_URL=${config.supabaseUrl || 'https://your-project.supabase.co'}\nVITE_SUPABASE_ANON_KEY=${config.supabaseKey || 'your-anon-key'}\n` : '');
+  const feEnv = `VITE_API_URL=http://localhost:${bePort}\n`;
+  const beEnv = isPython
+    ? `DATABASE_URL=${dbUrl}\nSECRET_KEY=change_me_in_production\nDEBUG=True\n`
+    : `PORT=3001\nNODE_ENV=development\nJWT_SECRET=change_me_in_production\n${dbUrl ? 'DATABASE_URL=' + dbUrl + '\n' : ''}`;
 
-  const beEnv = isPython ? `DATABASE_URL=${dbUrl}\nSECRET_KEY=change_me_in_production\nDEBUG=True\n`
-    : `PORT=3001\nNODE_ENV=development\nJWT_SECRET=change_me_in_production\n${dbUrl ? 'DATABASE_URL=' + dbUrl + '\n' : ''}` +
-      (config.db === 'supabase' ? `SUPABASE_URL=${config.supabaseUrl || ''}\nSUPABASE_KEY=${config.supabaseKey || ''}\n` : '') +
-      (config.extras?.includes('stripe') ? 'STRIPE_SECRET_KEY=sk_test_...\nSTRIPE_WEBHOOK_SECRET=whsec_...\n' : '');
+  const feDir = path.join(root, 'frontend');
+  const beDir = path.join(root, 'backend');
 
-  await fse.writeFile(path.join(root, 'frontend', '.env.example'), feEnv);
-  await fse.writeFile(path.join(root, 'frontend', '.env'), feEnv);
-  if (!isPython) {
-    await fse.writeFile(path.join(root, 'backend', '.env.example'), beEnv);
-    await fse.writeFile(path.join(root, 'backend', '.env'), beEnv);
+  if (await fse.pathExists(feDir)) {
+    await fse.writeFile(path.join(feDir, '.env'), feEnv);
+    await fse.writeFile(path.join(feDir, '.env.example'), feEnv);
+  }
+  if (await fse.pathExists(beDir)) {
+    await fse.writeFile(path.join(beDir, '.env'), beEnv);
+    await fse.writeFile(path.join(beDir, '.env.example'), beEnv);
   }
 }
 
 // ── README ────────────────────────────────────────────────────────────────────
 async function generateReadme(config, root) {
   const ts = config.typescript ? ' + TypeScript' : '';
-  const content = `# ${config.name}\n\n> Generado con [NovaTec CLI](https://www.npmjs.com/package/novatec-cli) — Enterprise Fullstack Generator\n\n## Stack\n\n| Capa | Tecnología |\n|------|------------|\n| Frontend | **${config.frontend}**${ts} |\n| Backend | **${config.backend}** |\n| Base de datos | **${config.db || 'N/A'}** |\n| Arquitectura | **${config.architecture || 'mvc'}** |\n| Modo | **${config.mode || 'estándar'}** |\n\n## Inicio rápido\n\n\`\`\`bash\n# Frontend\ncd ${config.name}/frontend && npm install && npm run dev\n\n# Backend\ncd ${config.name}/backend && npm install && npm run dev\n\`\`\`\n${config.mode === 'business' ? '\n## Rutas del sistema\n\n| Ruta | Descripción |\n|------|-------------|\n| `/` | Landing page |\n| `/login` | Autenticación |\n| `/register` | Registro |\n| `/dashboard` | Panel administrativo |\n| `/api-docs` | Swagger UI |\n' : ''}\n---\n*Generado el ${new Date().toLocaleDateString('es-MX')} con NovaTec CLI v3.0.0*\n`;
+  const content =
+`# ${config.name}
+
+> Generado con [NovaTec CLI](https://www.npmjs.com/package/novatec-cli)
+
+## Stack
+
+| Capa | Tecnología |
+|------|------------|
+| Frontend | **${config.frontend}**${ts} |
+| Backend | **${config.backend}** |
+| Base de datos | **${config.db || 'N/A'}** |
+| Arquitectura | **${config.architecture || 'mvc'}** |
+
+## Inicio rápido
+
+\`\`\`bash
+# Frontend
+cd ${config.name}/frontend
+npm install
+npm run dev
+
+# Backend
+cd ${config.name}/backend
+npm install
+npm run dev
+\`\`\`
+`;
   await fse.writeFile(path.join(root, 'README.md'), content);
 }
-
-// ── ESLINT ────────────────────────────────────────────────────────────────────
-async function setupEslint(root) {
-  const fe = path.join(root, 'frontend');
-  await fse.writeFile(path.join(fe, '.eslintrc.json'), JSON.stringify({ env: { browser: true, es2021: true }, extends: ['eslint:recommended'], parserOptions: { ecmaVersion: 'latest', sourceType: 'module' }, rules: { 'no-unused-vars': 'warn' } }, null, 2));
-  await fse.writeFile(path.join(fe, '.prettierrc'), JSON.stringify({ semi: true, singleQuote: true, tabWidth: 2, trailingComma: 'es5' }, null, 2));
-}
-
-// ── TESTING ───────────────────────────────────────────────────────────────────
-async function setupTesting(root) {
-  const testDir = path.join(root, 'frontend', 'src', '__tests__');
-  await fse.ensureDir(testDir);
-  await fse.writeFile(path.join(testDir, 'app.test.js'), `import { describe, it, expect } from 'vitest';\ndescribe('App', () => { it('works', () => expect(1 + 1).toBe(2)); });\n`);
-}
-
-// ── LOGS ──────────────────────────────────────────────────────────────────────
-async function setupLogs(config, root) {
-  const isPython = ['fastapi', 'django', 'flask'].includes(config.backend);
-  if (isPython) return;
-  const loggerFile = `import winston from 'winston';\n\nexport const logger = winston.createLogger({\n  level: process.env.LOG_LEVEL || 'info',\n  format: winston.format.combine(\n    winston.format.timestamp(),\n    winston.format.colorize(),\n    winston.format.printf(({ timestamp, level, message }) => \`\${timestamp} [\${level}]: \${message}\`)\n  ),\n  transports: [\n    new winston.transports.Console(),\n    new winston.transports.File({ filename: 'logs/error.log', level: 'error' }),\n    new winston.transports.File({ filename: 'logs/combined.log' }),\n  ],\n});\n`;
-  const logDir = path.join(root, 'backend', 'src', 'utils');
-  await fse.ensureDir(logDir);
-  await fse.writeFile(path.join(logDir, 'logger.js'), loggerFile);
-  await fse.ensureDir(path.join(root, 'backend', 'logs'));
-  await fse.writeFile(path.join(root, 'backend', 'logs', '.gitkeep'), '');
-}
-
-// ── SEO ───────────────────────────────────────────────────────────────────────
-async function setupSEO(config, root) {
-  const publicDir = path.join(root, 'frontend', 'public');
-  await fse.ensureDir(publicDir);
-  await fse.writeFile(path.join(publicDir, 'robots.txt'), `User-agent: *\nAllow: /\nSitemap: https://yourdomain.com/sitemap.xml\n`);
-  await fse.writeFile(path.join(publicDir, 'sitemap.xml'), `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n  <url><loc>https://yourdomain.com/</loc><priority>1.0</priority></url>\n</urlset>\n`);
-}
-
-const GITIGNORE = `node_modules/\ndist/\n.next/\n.nuxt/\n.svelte-kit/\n.env\n*.log\nlogs/\n__pycache__/\n.venv/\n*.pyc\ntarget/\n*.class\n.DS_Store\n`;

package/lib/generators/backend.js

@@ -1,36 +1,40 @@
 import path from 'path';
 import chalk from 'chalk';
 import fse from 'fs-extra';
-import { spawnSync } from 'child_process';
-import { run, isInstalled } from '../utils.js';
+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'],
+  mongo:    ['mongoose'],
+  sqlite:   ['better-sqlite3'],
+  supabase: ['@supabase/supabase-js'],
+  none:     [],
+};
 
-function installNodeDeps(prod, dev, cwd, label) {
+function installNodeDeps(prod, dev, cwd) {
   if (prod.length) {
-    const r = spawnSync('npm', ['install', ...prod], { cwd, stdio: 'pipe', encoding: 'utf8' });
-    if (r.status !== 0) throw new Error((r.stderr || r.stdout || '').trim() || `Error instalando: ${prod.join(', ')}`);
+    execSync(`npm install ${prod.join(' ')}`, { cwd, stdio: 'pipe' });
   }
-  if (dev.length) {
-    const r = spawnSync('npm', ['install', '-D', ...dev], { cwd, stdio: 'pipe', encoding: 'utf8' });
-    if (r.status !== 0) throw new Error((r.stderr || r.stdout || '').trim() || `Error instalando dev: ${dev.join(', ')}`);
+  if (dev && dev.length) {
+    execSync(`npm install -D ${dev.join(' ')}`, { cwd, stdio: 'pipe' });
   }
 }
 
-async function generateBackend(config, projectPath) {
-  console.log(chalk.blue(`\n🔧 Generando backend (${chalk.bold(config.backend)})...`));
+function backendPath(projectPath) {
+  return path.join(projectPath, 'backend');
+}
+
+export async function generateBackend(config, projectPath) {
+  console.log(chalk.blue(`\n  ⚙  Generando backend (${chalk.bold(config.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}`);
   await fn(config, projectPath);
 }
 
-// ── HELPERS ───────────────────────────────────────────────────────────────────
-function backendPath(projectPath) { return path.join(projectPath, 'backend'); }
-
-async function writeDotenv(bPath, content) {
-  await fse.writeFile(path.join(bPath, '.env'), content);
-  await fse.writeFile(path.join(bPath, '.env.example'), content.replace(/=.+/g, '='));
-}
-
 // ── EXPRESS ───────────────────────────────────────────────────────────────────
 async function express(config, projectPath) {
   const bp = backendPath(projectPath);
@@ -38,38 +42,24 @@ async function express(config, projectPath) {
   await fse.ensureDir(path.join(bp, 'src', 'middlewares'));
   await fse.ensureDir(path.join(bp, 'src', 'controllers'));
 
-  const deps = config.backendDeps || [];
-  const hasDotenv  = deps.includes('dotenv');
-  const hasCors    = deps.includes('cors');
-  const hasHelmet  = deps.includes('helmet');
-  const hasMorgan  = deps.includes('morgan');
-  const hasSwagger = deps.includes('swagger-ui-express');
-  const hasSocket  = deps.includes('socket.io');
+  const dbDeps = NODE_DB_DEPS[config.db] || [];
 
-  const pkg = {
+  await fse.writeJSON(path.join(bp, 'package.json'), {
     name: 'backend', version: '1.0.0', main: 'src/server.js',
     scripts: { start: 'node src/server.js', dev: 'nodemon src/server.js' },
-  };
-  await fse.writeJSON(path.join(bp, 'package.json'), pkg, { spaces: 2 });
+  }, { spaces: 2 });
 
-  const server = `${hasDotenv ? "require('dotenv').config();\n" : ''}const express = require('express');
-${hasCors    ? "const cors    = require('cors');"    : ''}
-${hasHelmet  ? "const helmet  = require('helmet');"  : ''}
-${hasMorgan  ? "const morgan  = require('morgan');"  : ''}
-${hasSwagger ? "const swaggerUi = require('swagger-ui-express');\nconst swaggerDoc = require('./swagger.json');" : ''}
-${hasSocket  ? "const { createServer } = require('http');\nconst { Server } = require('socket.io');" : ''}
+  await fse.writeFile(path.join(bp, 'src', 'server.js'),
+`require('dotenv').config();
+const express = require('express');
+const cors    = require('cors');
 
 const app = express();
-${hasSocket ? 'const httpServer = createServer(app);\nconst io = new Server(httpServer, { cors: { origin: "*" } });' : ''}
-${hasCors   ? 'app.use(cors());'   : ''}
-${hasHelmet ? 'app.use(helmet());' : ''}
-${hasMorgan ? "app.use(morgan('dev'));" : ''}
+app.use(cors());
 app.use(express.json());
 app.use(express.urlencoded({ extended: true }));
 
 app.use('/api', require('./routes/index'));
-${hasSwagger ? "app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerDoc));" : ''}
-${hasSocket  ? "\nio.on('connection', (socket) => {\n  console.log('Cliente conectado:', socket.id);\n  socket.on('disconnect', () => console.log('Cliente desconectado'));\n});" : ''}
 
 app.get('/', (req, res) => res.json({ status: 'ok', message: 'API funcionando ✅' }));
 
@@ -79,49 +69,60 @@ app.use((err, req, res, next) => {
 });
 
 const PORT = process.env.PORT || 3001;
-const server${hasSocket ? ' = httpServer' : 'Inst = app'}.listen(PORT, () =>
-  console.log(\`🚀 Servidor en http://localhost:\${PORT}\`)
-);
-`;
+app.listen(PORT, () => console.log(\`🚀 Servidor en http://localhost:\${PORT}\`));
+`);
 
-  const routes = `const router = require('express').Router();
+  await fse.writeFile(path.join(bp, 'src', 'routes', 'index.js'),
+`const router = require('express').Router();
 router.get('/health', (req, res) => res.json({ status: 'healthy', timestamp: new Date() }));
 module.exports = router;
-`;
+`);
 
-  await fse.writeFile(path.join(bp, 'src', 'server.js'), server);
-  await fse.writeFile(path.join(bp, 'src', 'routes', 'index.js'), routes);
-  if (hasDotenv) await writeDotenv(bp, 'PORT=3001\nDB_URL=\nJWT_SECRET=change_me\nNODE_ENV=development\n');
-
-  await installNodeDeps(['express', ...deps], [], bp, 'Instalando dependencias Express');
+  console.log(chalk.gray('    → Instalando dependencias Express...'));
+  try {
+    installNodeDeps(['express', 'cors', 'dotenv', ...dbDeps], ['nodemon'], bp);
+    console.log(chalk.green('    ✔ Dependencias instaladas'));
+  } catch (e) {
+    console.log(chalk.yellow('    ⚠ Error instalando deps: ' + e.message));
+  }
 }
 
 // ── NESTJS ────────────────────────────────────────────────────────────────────
 async function nestjs(config, projectPath) {
-  run('npx @nestjs/cli@latest new backend --skip-git --package-manager npm', projectPath, 'Creando proyecto NestJS');
   const bp = backendPath(projectPath);
-  const deps = (config.backendDeps || []).filter(d => d !== 'nodemon');
-  if (deps.length) run(`npm install ${deps.join(' ')}`, bp, `Instalando: ${deps.join(', ')}`);
-  if (deps.includes('@nestjs/config')) await writeDotenv(bp, 'PORT=3001\nDB_URL=\nJWT_SECRET=change_me\n');
+  console.log(chalk.gray('    → Creando proyecto NestJS (puede tardar)...'));
+  try {
+    execSync('npx @nestjs/cli@latest new backend --skip-git --package-manager npm', {
+      cwd: projectPath, stdio: 'pipe',
+    });
+  } catch (e) {
+    throw new Error('Error creando NestJS: ' + e.message);
+  }
+  const dbDeps = NODE_DB_DEPS[config.db] || [];
+  if (dbDeps.length) {
+    try {
+      execSync(`npm install ${dbDeps.join(' ')}`, { cwd: bp, stdio: 'pipe' });
+    } catch {}
+  }
 }
 
 // ── FASTIFY ───────────────────────────────────────────────────────────────────
 async function fastify(config, projectPath) {
   const bp = backendPath(projectPath);
-  await fse.ensureDir(path.join(bp, 'src', 'routes'));
+  await fse.ensureDir(path.join(bp, 'src'));
+
+  const dbDeps = NODE_DB_DEPS[config.db] || [];
 
-  const pkg = {
+  await fse.writeJSON(path.join(bp, 'package.json'), {
     name: 'backend', version: '1.0.0', main: 'src/server.js',
     scripts: { start: 'node src/server.js', dev: 'nodemon src/server.js' },
-  };
-  await fse.writeJSON(path.join(bp, 'package.json'), pkg, { spaces: 2 });
+  }, { spaces: 2 });
 
-  const deps = config.backendDeps || [];
-  const hasDotenv = deps.includes('dotenv');
+  await fse.writeFile(path.join(bp, 'src', 'server.js'),
+`require('dotenv').config();
+const fastify = require('fastify')({ logger: true });
 
-  const server = `${hasDotenv ? "require('dotenv').config();\n" : ''}const fastify = require('fastify')({ logger: true });
-${deps.includes('@fastify/cors')       ? "fastify.register(require('@fastify/cors'));"       : ''}
-${deps.includes('@fastify/rate-limit') ? "fastify.register(require('@fastify/rate-limit'), { max: 100, timeWindow: '1 minute' });" : ''}
+fastify.register(require('@fastify/cors'));
 
 fastify.get('/', async () => ({ status: 'ok', message: 'API funcionando ✅' }));
 fastify.get('/api/health', async () => ({ status: 'healthy', timestamp: new Date() }));
@@ -135,25 +136,32 @@ const start = async () => {
   }
 };
 start();
-`;
-  await fse.writeFile(path.join(bp, 'src', 'server.js'), server);
-  if (hasDotenv) await writeDotenv(bp, 'PORT=3001\nDB_URL=\nJWT_SECRET=change_me\n');
-  await installNodeDeps(['fastify', ...deps], [], bp, 'Instalando dependencias Fastify');
+`);
+
+  console.log(chalk.gray('    → Instalando dependencias Fastify...'));
+  try {
+    installNodeDeps(['fastify', '@fastify/cors', 'dotenv', ...dbDeps], ['nodemon'], bp);
+    console.log(chalk.green('    ✔ Dependencias instaladas'));
+  } catch (e) {
+    console.log(chalk.yellow('    ⚠ Error instalando deps: ' + e.message));
+  }
 }
 
 // ── HONO ──────────────────────────────────────────────────────────────────────
 async function hono(config, projectPath) {
   const bp = backendPath(projectPath);
-  await fse.ensureDir(bp);
+  await fse.ensureDir(path.join(bp, 'src'));
 
-  const pkg = {
+  const dbDeps = NODE_DB_DEPS[config.db] || [];
+
+  await fse.writeJSON(path.join(bp, 'package.json'), {
     name: 'backend', version: '1.0.0', main: 'src/index.js',
     scripts: { start: 'node src/index.js', dev: 'nodemon src/index.js' },
-  };
-  await fse.writeJSON(path.join(bp, 'package.json'), pkg, { spaces: 2 });
+  }, { spaces: 2 });
 
-  const deps = config.backendDeps || [];
-  const server = `const { Hono } = require('hono');
+  await fse.writeFile(path.join(bp, 'src', 'index.js'),
+`require('dotenv').config();
+const { Hono } = require('hono');
 const { serve } = require('@hono/node-server');
 
 const app = new Hono();
@@ -164,11 +172,15 @@ app.get('/api/health', (c) => c.json({ status: 'healthy', timestamp: new Date()
 serve({ fetch: app.fetch, port: process.env.PORT || 3001 }, (info) =>
   console.log(\`🚀 Servidor en http://localhost:\${info.port}\`)
 );
-`;
-  await fse.ensureDir(path.join(bp, 'src'));
-  await fse.writeFile(path.join(bp, 'src', 'index.js'), server);
-  if (deps.includes('dotenv')) await writeDotenv(bp, 'PORT=3001\nDB_URL=\nJWT_SECRET=change_me\n');
-  await installNodeDeps(['hono', '@hono/node-server', ...deps], ['nodemon'], bp, 'Instalando dependencias Hono');
+`);
+
+  console.log(chalk.gray('    → Instalando dependencias Hono...'));
+  try {
+    installNodeDeps(['hono', '@hono/node-server', 'dotenv', ...dbDeps], ['nodemon'], bp);
+    console.log(chalk.green('    ✔ Dependencias instaladas'));
+  } catch (e) {
+    console.log(chalk.yellow('    ⚠ Error instalando deps: ' + e.message));
+  }
 }
 
 // ── FASTAPI ───────────────────────────────────────────────────────────────────
@@ -178,10 +190,20 @@ async function fastapi(config, projectPath) {
   await fse.ensureDir(path.join(bp, 'app', 'models'));
   await fse.ensureDir(path.join(bp, 'app', 'schemas'));
 
-  const deps = config.backendDeps || [];
-  const hasDotenv = deps.includes('python-dotenv');
+  const pyDbDeps = {
+    postgres: ['psycopg2-binary', 'sqlalchemy'],
+    mysql:    ['mysqlclient', 'sqlalchemy'],
+    mongo:    ['motor', 'beanie'],
+    sqlite:   ['sqlalchemy'],
+    supabase: ['supabase'],
+    none:     [],
+  }[config.db] || [];
+
+  await fse.writeFile(path.join(bp, 'main.py'),
+`from dotenv import load_dotenv
+load_dotenv()
 
-  const main = `${hasDotenv ? 'from dotenv import load_dotenv\nload_dotenv()\n\n' : ''}from fastapi import FastAPI
+from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from app.routers import health
 
@@ -193,27 +215,23 @@ app.include_router(health.router, prefix="/api", tags=["health"])
 @app.get("/")
 def root():
     return {"status": "ok", "message": "API funcionando ✅"}
-`;
-  const healthRouter = `from fastapi import APIRouter
+`);
+
+  await fse.writeFile(path.join(bp, 'app', '__init__.py'), '');
+  await fse.writeFile(path.join(bp, 'app', 'routers', '__init__.py'), '');
+  await fse.writeFile(path.join(bp, 'app', 'routers', 'health.py'),
+`from fastapi import APIRouter
 router = APIRouter()
 
 @router.get("/health")
 def health_check():
     return {"status": "healthy"}
-`;
-  const requirements = ['fastapi', 'uvicorn[standard]', ...deps].join('\n') + '\n';
-
-  await fse.writeFile(path.join(bp, 'main.py'), main);
-  await fse.writeFile(path.join(bp, 'app', '__init__.py'), '');
-  await fse.writeFile(path.join(bp, 'app', 'routers', '__init__.py'), '');
-  await fse.writeFile(path.join(bp, 'app', 'routers', 'health.py'), healthRouter);
+`);
   await fse.writeFile(path.join(bp, 'app', 'models', '__init__.py'), '');
   await fse.writeFile(path.join(bp, 'app', 'schemas', '__init__.py'), '');
-  await fse.writeFile(path.join(bp, 'requirements.txt'), requirements);
-  if (hasDotenv) await writeDotenv(bp, 'DATABASE_URL=\nSECRET_KEY=change_me\nDEBUG=True\n');
-
-  if (isInstalled('pip')) run('pip install -r requirements.txt', bp, 'Instalando dependencias FastAPI');
-  else console.log(chalk.yellow('\n  ⚠ pip no encontrado. Ejecuta: pip install -r requirements.txt'));
+  await fse.writeFile(path.join(bp, 'requirements.txt'),
+    ['fastapi', 'uvicorn[standard]', 'python-dotenv', ...pyDbDeps].join('\n') + '\n'
+  );
 }
 
 // ── DJANGO ────────────────────────────────────────────────────────────────────
@@ -221,17 +239,32 @@ async function django(config, projectPath) {
   const bp = backendPath(projectPath);
   await fse.ensureDir(bp);
 
-  const deps = config.backendDeps || [];
-  const requirements = ['django', 'gunicorn', ...deps].join('\n') + '\n';
-  await fse.writeFile(path.join(bp, 'requirements.txt'), requirements);
-  await fse.writeFile(path.join(bp, 'README_SETUP.md'),
-    `# Django Backend\n\n\`\`\`bash\npip install -r requirements.txt\ndjango-admin startproject core .\npython manage.py migrate\npython manage.py runserver\n\`\`\`\n`
+  const pyDbDeps = {
+    postgres: ['psycopg2-binary'],
+    mysql:    ['mysqlclient'],
+    mongo:    ['djongo'],
+    sqlite:   [],
+    supabase: [],
+    none:     [],
+  }[config.db] || [];
+
+  await fse.writeFile(path.join(bp, 'requirements.txt'),
+    ['django', 'gunicorn', 'django-cors-headers', 'python-dotenv', ...pyDbDeps].join('\n') + '\n'
   );
-  if (isInstalled('pip')) {
-    run('pip install -r requirements.txt', bp, 'Instalando Django y dependencias');
-    run('django-admin startproject core .', bp, 'Creando proyecto Django');
-  } else {
-    console.log(chalk.yellow('\n  ⚠ pip no encontrado. Instala manualmente.'));
+  await fse.writeFile(path.join(bp, 'README_SETUP.md'),
+`# Django Backend
+
+\`\`\`bash
+pip install -r requirements.txt
+django-admin startproject core .
+python manage.py migrate
+python manage.py runserver
+\`\`\`
+`);
+  if (isInstalled('django-admin') || isInstalled('python')) {
+    try {
+      execSync('django-admin startproject core .', { cwd: bp, stdio: 'pipe' });
+    } catch {}
   }
 }
 
@@ -240,10 +273,17 @@ async function flask(config, projectPath) {
   const bp = backendPath(projectPath);
   await fse.ensureDir(path.join(bp, 'app'));
 
-  const deps = config.backendDeps || [];
-  const hasDotenv = deps.includes('python-dotenv');
-
-  const appInit = `from flask import Flask
+  const pyDbDeps = {
+    postgres: ['psycopg2-binary', 'flask-sqlalchemy'],
+    mysql:    ['mysqlclient', 'flask-sqlalchemy'],
+    mongo:    ['flask-pymongo'],
+    sqlite:   ['flask-sqlalchemy'],
+    supabase: ['supabase'],
+    none:     [],
+  }[config.db] || [];
+
+  await fse.writeFile(path.join(bp, 'app', '__init__.py'),
+`from flask import Flask
 from flask_cors import CORS
 
 def create_app():
@@ -259,22 +299,21 @@ def create_app():
         return {'status': 'healthy'}
 
     return app
-`;
-  const run_py = `${hasDotenv ? 'from dotenv import load_dotenv\nload_dotenv()\n\n' : ''}from app import create_app
+`);
+
+  await fse.writeFile(path.join(bp, 'run.py'),
+`from dotenv import load_dotenv
+load_dotenv()
+from app import create_app
 app = create_app()
 
 if __name__ == '__main__':
     app.run(debug=True, port=5000)
-`;
-  const requirements = ['flask', 'flask-cors', ...deps].join('\n') + '\n';
-
-  await fse.writeFile(path.join(bp, 'app', '__init__.py'), appInit);
-  await fse.writeFile(path.join(bp, 'run.py'), run_py);
-  await fse.writeFile(path.join(bp, 'requirements.txt'), requirements);
-  if (hasDotenv) await writeDotenv(bp, 'FLASK_ENV=development\nSECRET_KEY=change_me\nDATABASE_URL=\n');
+`);
 
-  if (isInstalled('pip')) run('pip install -r requirements.txt', bp, 'Instalando Flask y dependencias');
-  else console.log(chalk.yellow('\n  ⚠ pip no encontrado. Ejecuta: pip install -r requirements.txt'));
+  await fse.writeFile(path.join(bp, 'requirements.txt'),
+    ['flask', 'flask-cors', 'python-dotenv', ...pyDbDeps].join('\n') + '\n'
+  );
 }
 
 // ── SPRING BOOT ───────────────────────────────────────────────────────────────
@@ -282,10 +321,18 @@ async function spring(config, projectPath) {
   const bp = backendPath(projectPath);
   await fse.ensureDir(bp);
   await fse.writeFile(path.join(bp, 'README_SETUP.md'),
-    `# Spring Boot Backend\n\nGenera el proyecto en: https://start.spring.io\n\nDependencias sugeridas:\n${(config.backendDeps || []).map(d => `- ${d}`).join('\n')}\n\nO usa Spring CLI:\n\`\`\`bash\nspring init --dependencies=web,data-jpa,security backend\n\`\`\`\n`
-  );
+`# Spring Boot Backend
+
+Genera el proyecto en: https://start.spring.io
+
+Dependencias sugeridas: Spring Web, Spring Data JPA, ${config.db === 'postgres' ? 'PostgreSQL Driver' : config.db === 'mysql' ? 'MySQL Driver' : config.db === 'mongo' ? 'Spring Data MongoDB' : 'H2 Database'}
+
+\`\`\`bash
+# Con Spring CLI
+spring init --dependencies=web,data-jpa backend
+\`\`\`
+`);
   console.log(chalk.yellow('\n  ℹ Spring Boot: genera el proyecto en https://start.spring.io'));
-  console.log(chalk.gray('    Se creó un README_SETUP.md con instrucciones.\n'));
 }
 
 // ── DENO/OAK ──────────────────────────────────────────────────────────────────
@@ -293,7 +340,8 @@ async function deno(config, projectPath) {
   const bp = backendPath(projectPath);
   await fse.ensureDir(bp);
 
-  const server = `import { Application, Router } from "https://deno.land/x/oak/mod.ts";
+  await fse.writeFile(path.join(bp, 'main.ts'),
+`import { Application, Router } from "https://deno.land/x/oak/mod.ts";
 
 const app = new Application();
 const router = new Router();
@@ -306,11 +354,15 @@ app.use(router.allowedMethods());
 
 console.log("🚀 Servidor en http://localhost:8000");
 await app.listen({ port: 8000 });
-`;
-  await fse.writeFile(path.join(bp, 'main.ts'), server);
-  await fse.writeFile(path.join(bp, 'deno.json'), JSON.stringify({ tasks: { dev: 'deno run --allow-net main.ts' } }, null, 2));
-  console.log(chalk.green('✔ Backend Deno/Oak generado'));
-  if (!isInstalled('deno')) console.log(chalk.yellow('  ⚠ Deno no instalado. Instala desde https://deno.land'));
+`);
+
+  await fse.writeJSON(path.join(bp, 'deno.json'), {
+    tasks: { dev: 'deno run --allow-net --allow-env main.ts' },
+  }, { spaces: 2 });
+
+  if (!isInstalled('deno')) {
+    console.log(chalk.yellow('  ⚠ Deno no instalado. Instala desde https://deno.land'));
+  }
 }
 
 // ── GO/GIN ────────────────────────────────────────────────────────────────────
@@ -318,7 +370,8 @@ async function gin(config, projectPath) {
   const bp = backendPath(projectPath);
   await fse.ensureDir(bp);
 
-  const main = `package main
+  await fse.writeFile(path.join(bp, 'main.go'),
+`package main
 
 import (
 	"net/http"
@@ -337,13 +390,19 @@ func main() {
 
 	r.Run(":8080")
 }
-`;
-  await fse.writeFile(path.join(bp, 'main.go'), main);
+`);
+
   await fse.writeFile(path.join(bp, 'README_SETUP.md'),
-    `# Go/Gin Backend\n\n\`\`\`bash\ngo mod init backend\ngo get github.com/gin-gonic/gin\ngo run main.go\n\`\`\`\n`
-  );
-  console.log(chalk.green('✔ Backend Go/Gin generado'));
-  if (!isInstalled('go')) console.log(chalk.yellow('  ⚠ Go no instalado. Instala desde https://go.dev'));
-}
+`# Go/Gin Backend
 
-export { generateBackend };
+\`\`\`bash
+go mod init backend
+go get github.com/gin-gonic/gin
+go run main.go
+\`\`\`
+`);
+
+  if (!isInstalled('go')) {
+    console.log(chalk.yellow('  ⚠ Go no instalado. Instala desde https://go.dev'));
+  }
+}

package/lib/generators/frontend.js

@@ -1,14 +1,14 @@
 import path from 'path';
 import chalk from 'chalk';
 import fse from 'fs-extra';
-import { run } from '../utils.js';
+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',
   solid:   'npm create vite@latest frontend -- --template solid',
-  svelte:  'npm create svelte@latest frontend -- --no-install',
+  svelte:  'npx sv create frontend --template minimal --no-add-ons',
   astro:   'npm create astro@latest frontend -- --template minimal --no-install --no-git',
   next:    'npx create-next-app@latest frontend --yes --no-git',
   nuxt:    'npx nuxi@latest init frontend --no-install',
@@ -17,65 +17,16 @@ const SCAFFOLD = {
   qwik:    'npm create qwik@latest frontend -- --no-install',
 };
 
-async function generateFrontend(config, projectPath) {
+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)})...`));
-  run(cmd, projectPath, `Scaffolding ${config.frontend}`);
-
-  const frontendPath = path.join(projectPath, 'frontend');
-
-  // Instalar dependencias base
-  run('npm install', frontendPath, 'Instalando dependencias base del frontend');
-
-  // Separar tailwind del resto (va como devDependency)
-  const tailwindPkgs = ['tailwindcss', '@astrojs/tailwind', '@nuxtjs/tailwindcss'];
-  const devDeps = (config.frontendDeps || []).filter(d => tailwindPkgs.includes(d));
-  const prodDeps = (config.frontendDeps || []).filter(d => !tailwindPkgs.includes(d) && d !== '@shadcn/ui');
-
-  if (prodDeps.length) {
-    run(`npm install ${prodDeps.join(' ')}`, frontendPath, `Instalando: ${prodDeps.join(', ')}`);
-  }
-  if (devDeps.length) {
-    run(`npm install -D ${devDeps.join(' ')}`, frontendPath, `Instalando dev: ${devDeps.join(', ')}`);
-    if (devDeps.some(d => tailwindPkgs.includes(d))) {
-      await setupTailwind(config.frontend, frontendPath);
-    }
-  }
-}
-
-async function setupTailwind(framework, frontendPath) {
-  // Astro y Nuxt tienen su propia integración, no necesitan init manual
-  if (['astro', 'nuxt'].includes(framework)) return;
+  console.log(chalk.blue(`\n  ⚛  Generando frontend (${chalk.bold(config.frontend)})...`));
 
   try {
-    run('npx tailwindcss init -p', frontendPath, 'Configurando Tailwind CSS');
-  } catch { /* puede fallar si ya existe */ }
-
-  const tailwindConfig = `/** @type {import('tailwindcss').Config} */
-module.exports = {
-  content: ['./index.html', './src/**/*.{js,ts,jsx,tsx,vue,svelte}'],
-  theme: { extend: {} },
-  plugins: [],
-};
-`;
-  await fse.writeFile(path.join(frontendPath, 'tailwind.config.js'), tailwindConfig);
-
-  const cssPath = path.join(frontendPath, 'src', 'index.css');
-  const directives = `@tailwind base;
-@tailwind components;
-@tailwind utilities;
-
-`;
-  if (await fse.pathExists(cssPath)) {
-    const existing = await fse.readFile(cssPath, 'utf8');
-    await fse.writeFile(cssPath, directives + existing);
-  } else {
-    await fse.ensureDir(path.join(frontendPath, 'src'));
-    await fse.writeFile(cssPath, directives);
+    execSync(cmd, { cwd: projectPath, stdio: 'pipe' });
+    console.log(chalk.green(`  ✔ Scaffolding ${config.frontend} completado`));
+  } catch (e) {
+    throw new Error(`Error generando frontend ${config.frontend}: ${e.message}`);
   }
-  console.log(chalk.green('✔ Tailwind CSS configurado'));
 }
-
-export { generateFrontend };

package/lib/prompts.js

@@ -4,17 +4,6 @@ import fse from 'fs-extra';
 import path from 'path';
 import boxen from 'boxen';
 
-export const PRESETS = {
-  'ecommerce':      { frontend: 'next',   backend: 'express', db: 'postgres', typescript: true,  mode: 'business', architecture: 'mvc' },
-  'reservas':       { frontend: 'next',   backend: 'express', db: 'postgres', typescript: true,  mode: 'business', architecture: 'mvc' },
-  'aula-virtual':   { frontend: 'react',  backend: 'nestjs',  db: 'postgres', typescript: true,  mode: 'business', architecture: 'clean' },
-  'empresa-web':    { frontend: 'next',   backend: 'express', db: 'postgres', typescript: false, mode: 'business', architecture: 'mvc' },
-  'react-express':  { frontend: 'react',  backend: 'express', db: 'postgres', typescript: false, mode: null,       architecture: 'mvc' },
-  'next-nestjs':    { frontend: 'next',   backend: 'nestjs',  db: 'postgres', typescript: true,  mode: null,       architecture: 'clean' },
-  'vue-fastapi':    { frontend: 'vue',    backend: 'fastapi', db: 'postgres', typescript: false, mode: null,       architecture: 'mvc' },
-  'astro-hono':     { frontend: 'astro',  backend: 'hono',    db: 'sqlite',   typescript: true,  mode: null,       architecture: 'mvc' },
-};
-
 export const FRONTEND_CHOICES = [
   { name: 'React       — Vite + React 18',        value: 'react'   },
   { name: 'Next.js     — SSR/SSG App Router',     value: 'next'    },
@@ -51,9 +40,9 @@ export const DB_CHOICES = [
 ];
 
 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: 'MVC         — Model-View-Controller (clásico)',  value: 'mvc'       },
+  { name: 'Hexagonal   — Ports & Adapters',                value: 'hexagonal' },
+  { name: 'Clean       — Clean Architecture (capas)',      value: 'clean'     },
 ];
 
 export const PM_CHOICES = [
@@ -62,150 +51,83 @@ export const PM_CHOICES = [
   { name: 'yarn', value: 'yarn' },
 ];
 
-export const EXTRAS_CHOICES = [
-  { name: 'Git init automático',              value: 'git',          checked: true  },
-  { name: 'ESLint + Prettier',                value: 'eslint',       checked: false },
-  { name: 'Husky + lint-staged',              value: 'husky',        checked: false },
-  { name: 'Vitest / Jest',                    value: 'testing',      checked: false },
-  { name: 'Docker profesional',               value: 'docker',       checked: false },
-  { name: 'Archivos .env.example',            value: 'env',          checked: true  },
-  { name: '.editorconfig',                    value: 'editorconfig', checked: false },
-  { name: 'GitHub Actions CI/CD',             value: 'ci',           checked: false },
-  { name: 'Auth JWT completa',                value: 'auth',         checked: false },
-  { name: 'Tailwind CSS auto',                value: 'tailwind',     checked: false },
-  { name: 'Swagger / OpenAPI',                value: 'swagger',      checked: false },
-  { name: 'Seguridad (helmet+cors+ratelimit)', value: 'security',    checked: false },
-  { name: 'Sistema de logs (winston)',        value: 'logs',         checked: false },
-  { name: 'Stripe (pagos)',                   value: 'stripe',       checked: false },
-  { name: 'Notificaciones toast (frontend)',  value: 'notifications',checked: false },
-  { name: 'SEO base (meta+OG+sitemap)',       value: 'seo',          checked: false },
-  { name: 'Dark mode toggle',                 value: 'darkmode',     checked: false },
-  { name: 'WhatsApp botón de contacto',       value: 'whatsapp',     checked: false },
-];
-
 export async function askProjectOptions(nameArg, options) {
-  // Preset
-  if (options.preset) {
-    const preset = PRESETS[options.preset];
-    if (!preset) {
-      console.log(chalk.red(`\n  Preset "${options.preset}" no existe.`));
-      console.log(chalk.gray('  Disponibles: ' + Object.keys(PRESETS).join(', ') + '\n'));
-      process.exit(1);
-    }
-    const name = nameArg || options.preset + '-app';
-    console.log(chalk.gray(`\n  Preset: ${chalk.white(options.preset)}\n`));
-    return { name, ...preset, pm: 'npm', frontendDeps: [], backendDeps: [], extras: ['git', 'env', 'security', 'swagger'] };
-  }
-
-  // --yes mode
-  if (options.yes) {
-    const name = nameArg || 'my-app';
-    await checkFolder(name);
-    return {
-      name,
-      frontend:     options.frontend     || 'react',
-      backend:      options.backend      || 'express',
-      db:           options.db           || 'postgres',
-      mode:         options.mode         || null,
-      architecture: options.architecture || 'mvc',
-      typescript:   options.typescript   || false,
-      pm:           options.packageManager || 'npm',
-      install:      options.install      || false,
-      git:          options.git          || false,
-      frontendDeps: [],
-      backendDeps:  [],
-      extras:       ['git', 'env'],
-    };
-  }
-
   const a = {};
 
   // Nombre
-  if (!nameArg) {
+  if (nameArg) {
+    a.name = nameArg;
+  } else {
     const { name } = await inquirer.prompt([{
       type: 'input', name: 'name',
       message: chalk.white('Nombre del proyecto:'),
       default: 'my-app',
-      validate: v => /^[a-z0-9-_]+$/i.test(v.trim()) && v.trim().length >= 2 || 'Solo letras, números, guiones. Mínimo 2 chars.',
+      validate: v => /^[a-z0-9-_]+$/i.test(v.trim()) && v.trim().length >= 2
+        || 'Solo letras, números, guiones. Mínimo 2 chars.',
     }]);
     a.name = name.trim();
-  } else { a.name = nameArg; }
+  }
 
   await checkFolder(a.name);
 
-  // Modo business
-  const { mode } = await inquirer.prompt([{
-    type: 'list', name: 'mode',
-    message: chalk.white('Modo de proyecto:'),
-    choices: [
-      { name: 'Estándar  — Solo estructura base',                                    value: null },
-      { name: 'Business  — Landing + Auth + Dashboard + CRUD (sistema completo)',    value: 'business' },
-    ],
-    default: options.mode || null,
-  }]);
-  a.mode = mode;
-
   // TypeScript
   const { typescript } = await inquirer.prompt([{
     type: 'confirm', name: 'typescript',
     message: chalk.white('¿Usar TypeScript?'),
-    default: options.typescript || false,
+    default: false,
   }]);
   a.typescript = typescript;
 
   // Frontend
-  if (!options.frontend) {
-    const { frontend } = await inquirer.prompt([{ type: 'list', name: 'frontend', message: chalk.white('Framework Frontend:'), choices: FRONTEND_CHOICES, pageSize: 12 }]);
-    a.frontend = frontend;
-  } else { a.frontend = options.frontend; }
+  const { frontend } = await inquirer.prompt([{
+    type: 'list', name: 'frontend',
+    message: chalk.white('Framework Frontend:'),
+    choices: FRONTEND_CHOICES, pageSize: 12,
+    default: options.frontend,
+  }]);
+  a.frontend = frontend;
 
   // Backend
-  if (!options.backend) {
-    const { backend } = await inquirer.prompt([{ type: 'list', name: 'backend', message: chalk.white('Framework Backend:'), choices: BACKEND_CHOICES, pageSize: 12 }]);
-    a.backend = backend;
-  } else { a.backend = options.backend; }
+  const { backend } = await inquirer.prompt([{
+    type: 'list', name: 'backend',
+    message: chalk.white('Framework Backend:'),
+    choices: BACKEND_CHOICES, pageSize: 12,
+    default: options.backend,
+  }]);
+  a.backend = backend;
 
   // DB
-  if (!options.db) {
-    const { db } = await inquirer.prompt([{ type: 'list', name: 'db', message: chalk.white('Base de datos:'), choices: DB_CHOICES, pageSize: 7 }]);
-    a.db = db;
-  } else { a.db = options.db; }
-
-  // Supabase config
-  if (a.db === 'supabase') {
-    console.log(chalk.gray('\n  Configura Supabase (puedes dejarlo vacío y editar .env después)\n'));
-    const { supabaseUrl, supabaseKey } = await inquirer.prompt([
-      { type: 'input', name: 'supabaseUrl', message: chalk.white('  Supabase URL:'), default: 'https://your-project.supabase.co' },
-      { type: 'input', name: 'supabaseKey', message: chalk.white('  Supabase Anon Key:'), default: 'your-anon-key' },
-    ]);
-    a.supabaseUrl = supabaseUrl;
-    a.supabaseKey = supabaseKey;
-  }
+  const { db } = await inquirer.prompt([{
+    type: 'list', name: 'db',
+    message: chalk.white('Base de datos:'),
+    choices: DB_CHOICES, pageSize: 7,
+    default: options.db,
+  }]);
+  a.db = db;
 
   // Arquitectura
-  if (!options.architecture) {
-    const { architecture } = await inquirer.prompt([{ type: 'list', name: 'architecture', message: chalk.white('Arquitectura del backend:'), choices: ARCH_CHOICES }]);
-    a.architecture = architecture;
-  } else { a.architecture = options.architecture; }
+  const { architecture } = await inquirer.prompt([{
+    type: 'list', name: 'architecture',
+    message: chalk.white('Arquitectura del backend:'),
+    choices: ARCH_CHOICES,
+    default: options.architecture,
+  }]);
+  a.architecture = architecture;
 
   // Package manager
-  if (!options.packageManager) {
-    const { pm } = await inquirer.prompt([{ type: 'list', name: 'pm', message: chalk.white('Package manager:'), choices: PM_CHOICES }]);
-    a.pm = pm;
-  } else { a.pm = options.packageManager; }
-
-  // Extras
-  const { extras } = await inquirer.prompt([{
-    type: 'checkbox', name: 'extras',
-    message: chalk.white('Extras del proyecto:'),
-    choices: EXTRAS_CHOICES, pageSize: 14,
+  const { pm } = await inquirer.prompt([{
+    type: 'list', name: 'pm',
+    message: chalk.white('Package manager:'),
+    choices: PM_CHOICES,
+    default: options.packageManager || 'npm',
   }]);
+  a.pm = pm;
 
-  // Auto-install
+  // Instalar dependencias
   const { install } = await inquirer.prompt([{
     type: 'confirm', name: 'install',
-    message: chalk.white('¿Instalar dependencias automáticamente?'),
-    default: options.install || false,
+    message: chalk.white('¿Instalar dependencias automáticamente al final?'),
+    default: true,
   }]);
   a.install = install;
 
@@ -214,22 +136,24 @@ export async function askProjectOptions(nameArg, options) {
   console.log(boxen(
     chalk.bold.white('  RESUMEN\n\n') +
     chalk.gray('  Nombre       │ ') + chalk.white(a.name) + '\n' +
-    chalk.gray('  Modo         │ ') + chalk.white(a.mode || 'estándar') + '\n' +
     chalk.gray('  Frontend     │ ') + chalk.white(a.frontend) + (a.typescript ? chalk.gray(' + TS') : '') + '\n' +
     chalk.gray('  Backend      │ ') + chalk.white(a.backend) + '\n' +
     chalk.gray('  Base datos   │ ') + chalk.white(a.db) + '\n' +
     chalk.gray('  Arquitectura │ ') + chalk.white(a.architecture) + '\n' +
     chalk.gray('  PM           │ ') + chalk.white(a.pm) + '\n' +
-    chalk.gray('  Instalar     │ ') + chalk.white(a.install ? 'sí' : 'no') + '\n' +
-    chalk.gray('  Extras       │ ') + chalk.white(extras.length ? extras.join(', ') : 'ninguno'),
+    chalk.gray('  Instalar     │ ') + chalk.white(a.install ? 'sí' : 'no'),
     { padding: 1, margin: { left: 2 }, borderStyle: 'round', borderColor: 'white', dimBorder: true }
   ));
   console.log();
 
-  const { confirm } = await inquirer.prompt([{ type: 'confirm', name: 'confirm', message: chalk.white('¿Crear el proyecto?'), default: true }]);
+  const { confirm } = await inquirer.prompt([{
+    type: 'confirm', name: 'confirm',
+    message: chalk.white('¿Crear el proyecto?'),
+    default: true,
+  }]);
   if (!confirm) { console.log(chalk.gray('\n  Cancelado.\n')); process.exit(0); }
 
-  return { ...a, frontendDeps: [], backendDeps: [], extras };
+  return a;
 }
 
 async function checkFolder(name) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "novatec-cli",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "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",