@dbcube/cli 5.2.4 → 5.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dbcube/cli",
-  "version": "5.2.4",
+  "version": "5.2.6",
   "main": "src/index.js",
   "scripts": {
     "dbcube": "node src/index.js"
@@ -28,11 +28,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@dbcube/schema-builder": "^5.2.4",
+    "@dbcube/schema-builder": "^5.2.6",
     "@inquirer/prompts": "^8.5.2",
     "alwait": "^1.0.0",
     "chalk": "4.1.2",
-    "dbcube": "^5.2.4",
+    "dbcube": "^5.2.6",
     "dotenv": "^17.4.2",
     "fs-extra": "^11.3.5",
     "glob": "^13.0.6",

package/src/commands/dev.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const chalk = require('chalk');
+const ui = require('../utils/ui');
 const { execSync } = require('child_process');
 
 /**
@@ -66,18 +67,15 @@ function onChange(filename) {
 async function main() {
     const cubesDir = path.join(process.cwd(), 'dbcube');
     if (!fs.existsSync(cubesDir)) {
-        console.error(`${chalk.red('❌')} dbcube/ directory not found — run: npx dbcube init`);
+        ui.error('dbcube/ directory not found.', ['Run: npx dbcube init']);
         process.exit(1);
     }
 
-    console.log(`\n${chalk.green.bold('🚀 DBCube dev mode')}`);
-    console.log(`${chalk.gray('Save a .cube file and the change applies automatically.')}\n`);
-    console.log(`${chalk.green('👀 watching dbcube/ ...')} ${chalk.gray('(Ctrl+C to stop)')}`);
+    ui.header('DBCube dev mode', '🛰️');
+    ui.dim('Save a .cube file and the change applies automatically.');
+    console.log(`${chalk.green('›')} watching dbcube/ ... ${chalk.gray('(Ctrl+C to stop)')}\n`);
 
     fs.watch(cubesDir, { recursive: true }, (_event, filename) => onChange(filename));
 }
 
-main().catch(error => {
-    console.error('Error fatal:', error);
-    process.exit(1);
-});
+main().catch(ui.handleError);

package/src/commands/doctor.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const chalk = require('chalk');
 const ConfigFileUtils = require('../utils/ConfigFileUtils');
+const ui = require('../utils/ui');
 const { Engine } = require('@dbcube/schema-builder');
 
 /**
@@ -13,7 +14,7 @@ const warn = (msg) => console.log(`  ${chalk.yellow('⚠')} ${msg}`);
 const fail = (msg) => console.log(`  ${chalk.red('✗')} ${msg}`);
 
 async function main() {
-    console.log(`\n🩺 ${chalk.green.bold('DBCube Doctor')}\n`);
+    ui.header('DBCube Doctor', '🩺');
     let problems = 0;
 
     // 1. Node version
@@ -21,13 +22,14 @@ async function main() {
     if (major >= 16) ok(`Node.js ${process.versions.node}`);
     else { fail(`Node.js ${process.versions.node} — DBCube requires >= 16`); problems++; }
 
-    // 2. Config file
-    const configPath = path.join(process.cwd(), 'dbcube.config.js');
+    // 2. Config file (.js o .cjs — getConfigPath prefiere .cjs en proyectos ESM)
+    const configPath = ConfigFileUtils.getConfigPath();
+    const configName = path.basename(configPath);
     if (!fs.existsSync(configPath)) {
-        fail('dbcube.config.js not found — run: npx dbcube init');
+        fail(`${configName} not found — run: npx dbcube init`);
         problems++;
     } else {
-        ok('dbcube.config.js found');
+        ok(`${configName} found`);
     }
 
     // 3. Configured databases
@@ -93,7 +95,4 @@ async function main() {
     process.exit(0);
 }
 
-main().catch(error => {
-    console.error('Error fatal:', error);
-    process.exit(1);
-});
+main().catch(ui.handleError);

package/src/commands/generate.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const chalk = require('chalk');
+const ui = require('../utils/ui');
 
 /**
  * dbcube generate — Generates TypeScript interfaces from .table.cube files.
@@ -154,7 +155,4 @@ async function main() {
     console.log(`  const rows = await db.table('${schemaEntries[0] ? schemaEntries[0].tableName : 'users'}').get() as ${schemaEntries[0] ? schemaEntries[0].ifaceName : 'User'}[];\n`);
 }
 
-main().catch(error => {
-    console.error('Error fatal:', error);
-    process.exit(1);
-});
+main().catch(ui.handleError);

package/src/commands/help.js

@@ -1,13 +1,14 @@
 const chalk = require('chalk');
+const ui = require('../utils/ui');
 
 /**
  * Shows help information with all available Dbcube CLI commands
  */
 async function showHelp() {
     try {
-        console.log(`\n${chalk.green('🚀 Dbcube CLI - Command Reference')}`);
-        console.log(`${chalk.gray('A powerful database toolkit for modern applications')}\n`);
-        
+        ui.banner();
+        console.log('');
+
         console.log(`${chalk.cyan.bold('USAGE:')}`);
         console.log(`  ${chalk.white('npx dbcube')} ${chalk.yellow('<command>')} ${chalk.gray('[options]')}\n`);
 
@@ -97,13 +98,9 @@ async function showHelp() {
         console.log(`  ${chalk.white('Issues:')} ${chalk.blue('https://github.com/Dbcube/query-builder/issues')}\n`);
         
     } catch (error) {
-        console.error('❌ Error showing help:', error.message);
-        process.exit(1);
+        ui.handleError(error);
     }
 }
 
 // Ejecutar función
-showHelp().catch(error => {
-    console.error('Error fatal:', error);
-    process.exit(1);
-});
+showHelp().catch(ui.handleError);

package/src/commands/init.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const chalk = require('chalk');
 const ConfigFileUtils = require('../utils/ConfigFileUtils');
+const ui = require('../utils/ui');
 
 /**
  * dbcube init — Scaffolds a new DBCube project:
@@ -9,15 +10,17 @@ const ConfigFileUtils = require('../utils/ConfigFileUtils');
  */
 async function main() {
     const root = process.cwd();
-    console.log(`\n💚 ${chalk.green('Initializing DBCube project...')}\n`);
+    ui.header('Initializing DBCube project', '📦');
+    console.log('');
 
-    // 1. dbcube.config.js
-    const configPath = path.join(root, 'dbcube.config.js');
+    // 1. dbcube.config.(js|cjs) — getConfigPath elige .cjs en proyectos ESM
+    const configPath = ConfigFileUtils.getConfigPath();
+    const configName = path.basename(configPath);
     if (fs.existsSync(configPath)) {
-        console.log(`  ${chalk.yellow('•')} dbcube.config.js already exists — skipped`);
+        console.log(`  ${chalk.yellow('•')} ${configName} already exists — skipped`);
     } else {
         ConfigFileUtils.crearArchivoConfig(configPath);
-        console.log(`  ${chalk.green('✓')} dbcube.config.js created`);
+        console.log(`  ${chalk.green('✓')} ${configName} created`);
     }
 
     // 2. dbcube/ directory
@@ -76,7 +79,4 @@ async function main() {
     console.log(`  4. ${chalk.white('npx dbcube generate')}              ${chalk.gray('— generate TypeScript types')}\n`);
 }
 
-main().catch(error => {
-    console.error('Error fatal:', error);
-    process.exit(1);
-});
+main().catch(ui.handleError);

package/src/commands/migrate/rollback.js

@@ -3,6 +3,7 @@ const path = require('path');
 const chalk = require('chalk');
 const { Schema } = require('@dbcube/schema-builder');
 const ConfigFileUtils = require('../../utils/ConfigFileUtils');
+const ui = require('../../utils/ui');
 const { loadHistory, saveHistory } = require('./lib');
 
 /**
@@ -66,7 +67,4 @@ async function main() {
     }
 }
 
-main().catch(error => {
-    console.error(`${chalk.red('❌ Rollback failed:')}`, error.message);
-    process.exit(1);
-});
+main().catch(ui.handleError);

package/src/commands/migrate/status.js

@@ -1,5 +1,6 @@
 const path = require('path');
 const chalk = require('chalk');
+const ui = require('../../utils/ui');
 const { loadHistory, hashFile, collectAlterFiles } = require('./lib');
 
 /**
@@ -49,7 +50,4 @@ async function main() {
     console.log('');
 }
 
-main().catch(error => {
-    console.error('Error fatal:', error);
-    process.exit(1);
-});
+main().catch(ui.handleError);

package/src/commands/run/database/create/addDatabaseConfig.js

@@ -21,8 +21,7 @@ async function addDatabaseConfiguration(databaseName = null, motor = null) {
             databaseName = await input({
                 message: 'Nombre de referencia a la base de datos:',
                 validate: (value) => {
-                    const rootPath = path.resolve(process.cwd());
-                    const configPath = path.join(rootPath, 'dbcube.config.js');
+                    const configPath = ConfigFileUtils.getConfigPath();
                     const getconfig = require(configPath);
                     const config = new Config();
                     getconfig(config);

package/src/commands/run/database/create/createDatabase.js

@@ -63,13 +63,13 @@ async function main() {
 
         await createDatabasePhysically(parsedArgs.name);
     } catch (error) {
-        console.error('Error inesperado:', error);
+        console.error(`\n${chalk.red('✖')} ${error.message || error}`);
         process.exit(1);
     }
 }
 
 // Ejecutar el comando
 main().catch(error => {
-    console.error('Error fatal:', error);
+    console.error(`\n${chalk.red('✖')} ${error.message || error}`);
     process.exit(1);
 });

package/src/commands/run/database/create/index.js

@@ -10,22 +10,15 @@ const path = require('path');
  * Función para crear una nueva base de datos con configuración (Proceso completo en dos fases)
  */
 async function createNewDatabase() {
-    console.clear();
     try {
-        console.log(`\n💚 ${chalk.green("Proceso de creación de base de datos...")}`);
-        console.log('📋 Fase 1: Configuración');
-        console.log('🏗️  Fase 2: Creación física\n');
-
-        // Fase 1: Ejecutar addDatabaseConfig.js
-        console.log('🔧 Iniciando configuración de base de datos...');
-
+        // Fase 1: configuración interactiva (addDatabaseConfig.js trae su propia UI)
         try {
             execFileSync(process.execPath, [path.join(__dirname, 'addDatabaseConfig.js')], {
                 stdio: 'inherit',
                 cwd: process.cwd()
             });
         } catch (error) {
-            console.error('❌ Error en la fase de configuración:', error.message);
+            console.error(`\n${chalk.red('✖')} No se pudo completar la configuración.`);
             process.exit(1);
         }
 
@@ -37,32 +30,24 @@ async function createNewDatabase() {
         try {
             databaseName = fs.readFileSync(tempFile, 'utf8');
         } catch (error) {
-            console.error('❌ Error: No se pudo obtener el nombre de la base de datos configurada');
+            console.error(`\n${chalk.red('✖')} No se pudo obtener el nombre de la base de datos configurada.`);
             process.exit(1);
         } finally {
-            // Limpiar el archivo temporal pase lo que pase
             try { fs.unlinkSync(tempFile); } catch { /* ya no existe */ }
         }
 
-        console.log('\n🏗️ Iniciando creación física de la base de datos...');
-
-        // Fase 2: Ejecutar createDatabase.js. execFileSync con array de
-        // argumentos: el nombre no pasa por el shell (sin inyección de comandos)
+        // Fase 2: creación física (createDatabase.js trae su propia UI de resumen)
         try {
             execFileSync(process.execPath, [path.join(__dirname, 'createDatabase.js'), `--name=${databaseName}`], {
                 stdio: 'inherit',
                 cwd: process.cwd()
             });
         } catch (error) {
-            console.error('❌ Error en la fase de creación:', error.message);
+            // createDatabase.js ya imprimió el detalle del error
             process.exit(1);
         }
-
-        console.log(`\n🎉 ${chalk.green("¡Base de datos creada exitosamente!")}`);
-        console.log(`✅ Configuración y creación de '${databaseName}' completadas\n`);
-
     } catch (error) {
-        console.error('Error al crear la base de datos:', error);
+        console.error(`\n${chalk.red('✖')} ${error.message}`);
         process.exit(1);
     }
 }
@@ -81,12 +66,12 @@ async function useExistingDatabase(databaseName) {
                 cwd: process.cwd()
             });
         } catch (error) {
-            console.error('❌ Error al crear la base de datos:', error.message);
+            // createDatabase.js ya imprimió el detalle del error
             process.exit(1);
         }
 
     } catch (error) {
-        console.log('❌ Error al crear la base de datos:', error);
+        console.error(`\n${chalk.red('✖')} ${error.message}`);
         process.exit(1);
     }
 }
@@ -134,12 +119,19 @@ async function main() {
             await useExistingDatabase(selected);
         }
     } catch (error) {
-        console.error('Error inesperado:', error);
+        // Ctrl+C / cierre del prompt interactivo: salir en silencio, sin stack.
+        if (error && (error.name === 'ExitPromptError' || /force closed/i.test(error.message || ''))) {
+            console.log(`\n${chalk.gray('Cancelado.')}`);
+            process.exit(0);
+        }
+        // Errores de config ya vienen con mensaje claro y accionable.
+        console.error(`\n${chalk.red('✖')} ${error.message}`);
+        process.exit(1);
     }
 }
 
 // Ejecutar el ejemplo
 main().catch(error => {
-    console.error('Error fatal:', error);
+    console.error(`\n${chalk.red('✖')} ${error.message}`);
     process.exit(1);
 });

package/src/commands/run/download.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 const chalk = require('chalk');
+const ui = require('../../utils/ui');
 const { select } = require('@inquirer/prompts');
 const path = require('path');
 const fs = require('fs');
@@ -292,7 +293,4 @@ async function main() {
     }
 }
 
-main().catch(err => {
-    console.error(chalk.red('\n❌ Error inesperado:'), err.message);
-    process.exit(1);
-});
+main().catch(ui.handleError);

package/src/commands/run/pull.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const chalk = require('chalk');
 const ConfigFileUtils = require('../../utils/ConfigFileUtils');
+const ui = require('../../utils/ui');
 const { Engine } = require('@dbcube/schema-builder');
 
 /**
@@ -211,7 +212,11 @@ async function main() {
     const dbs = targetDb ? configured.filter(d => d.name === targetDb) : configured;
 
     if (dbs.length === 0) {
-        console.error(`${chalk.red('❌')} ${targetDb ? `Database '${targetDb}' is not configured` : 'No databases configured'} in dbcube.config.js`);
+        ui.error(
+            targetDb ? `Database '${targetDb}' is not configured in dbcube.config.js`
+                     : 'No databases configured in dbcube.config.js',
+            ['Run: npx dbcube run database:create']
+        );
         process.exit(1);
     }
 
@@ -247,7 +252,4 @@ async function main() {
     process.exit(0);
 }
 
-main().catch(error => {
-    console.error(`${chalk.red('❌ Pull failed:')}`, error.message);
-    process.exit(1);
-});
+main().catch(ui.handleError);

package/src/commands/run/seeder/add.js

@@ -1,33 +1,21 @@
-const { Schema } = require('@dbcube/schema-builder');
-const ConfigFileUtils = require('./../../../utils/ConfigFileUtils');
-
-async function main() {
-  try {
-    const args = process.argv.slice(2);
-    const seederName = args.find(a => !a.startsWith('--'));
-
-    const configuredDatabases = await ConfigFileUtils.getConfiguredDatabases();
-
-    for (const config of configuredDatabases) {
-      const schema = new Schema(config.name);
-      await schema.executeSeeders(seederName);
-    }
-  } catch (error) {
-    if (error.message.includes("reading 'init'")) {
-      console.error('❌ Configuracion de base de datos no encontrada\n');
-      console.error('Ejecute el comando para crear una nueva base de datos:');
-      console.error(`\tnpx dbcube run database:create`);
-      console.error('\nO verifique que la base de datos este configurada en el archivo dbcube.config.js\n');
-      process.exit(1);
-    } else if (error.message.includes("reading 'getDatabase'")) {
-      console.error('- Se sugiere cambiar el linea o crear la base de datos a la que se hace referencia.');
-    } else {
-      console.error(`❌ ${error.message}`);
-      if (process.env.DEBUG) console.error(error);
-      process.exit(1);
-    }
-  }
-}
-
-// Ejecutar el ejemplo
-main().catch(console.error);
+const { Schema } = require('@dbcube/schema-builder');
+const ConfigFileUtils = require('./../../../utils/ConfigFileUtils');
+const ui = require('./../../../utils/ui');
+
+async function main() {
+  try {
+    const args = process.argv.slice(2);
+    const seederName = args.find(a => !a.startsWith('--'));
+
+    const configuredDatabases = await ConfigFileUtils.getConfiguredDatabases();
+
+    for (const config of configuredDatabases) {
+      const schema = new Schema(config.name);
+      await schema.executeSeeders(seederName);
+    }
+  } catch (error) {
+    ui.handleError(error);
+  }
+}
+
+main().catch(ui.handleError);

package/src/commands/run/table/alter.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const { Schema } = require('@dbcube/schema-builder');
 const ConfigFileUtils = require('./../../../utils/ConfigFileUtils');
+const ui = require('./../../../utils/ui');
 const { loadHistory, saveHistory, hashFile, collectAlterFiles, buildReverse } = require('../../migrate/lib');
 
 /**
@@ -73,33 +74,21 @@ async function main() {
       console.log('   Status: npx dbcube migrate:status · Rollback: npx dbcube migrate:rollback\n');
     }
   } catch (error) {
-    if (error.message.includes("reading 'init'")) {
-      console.error('❌ Configuracion de base de datos no encontrada\n');
-      console.error('Ejecute el comando para crear una nueva base de datos:');
-      console.error(`\tdbcube run database:create`);
-      console.error('\nO verifique que la base de datos este configurada en el archivo dbcube.config.js\n');
-      process.exit(1);
-    } else if (error.message.includes("There are no .alter.cube files")) {
-      console.error('❌ No se encontraron archivos .alter.cube en la carpeta dbcube/\n');
-      console.error('Crea un archivo .alter.cube con la siguiente estructura:');
-      console.error('');
-      console.error('  @database("nombre_db");');
-      console.error('  @table("nombre_tabla");');
-      console.error('');
-      console.error('  @addColumn({');
-      console.error('      nueva_columna: {');
-      console.error('          type: "varchar";');
-      console.error('          length: "255";');
-      console.error('          options: ["not null"];');
-      console.error('      };');
-      console.error('  });');
-      console.error('');
-      process.exit(1);
-    } else {
-      console.error('Error:', error.message);
+    if (error.message && error.message.includes("There are no .alter.cube files")) {
+      ui.error('No .alter.cube files found in dbcube/.', [
+        'Create one, e.g. dbcube/add_email.alter.cube:',
+      ]);
+      console.error(ui.chalk.gray([
+        '  @database("my_db");',
+        '  @table("users");',
+        '  @addColumn({',
+        '      email: { type: "varchar"; length: "255"; options: ["not null"]; };',
+        '  });',
+      ].join('\n')) + '\n');
       process.exit(1);
     }
+    ui.handleError(error);
   }
 }
 
-main().catch(console.error);
+main().catch(ui.handleError);

package/src/commands/run/table/fresh.js

@@ -1,6 +1,7 @@
 const chalk = require('chalk');
 const { Schema } = require('@dbcube/schema-builder');
 const ConfigFileUtils = require('./../../../utils/ConfigFileUtils');
+const ui = require('./../../../utils/ui');
 
 /**
  * dbcube run table:fresh [--seeder] [--force]
@@ -63,19 +64,8 @@ async function main() {
       console.log(`\n${chalk.yellow('Aborted.')} ${chalk.gray('No changes were made.')}\n`);
       process.exit(0);
     }
-    if (error.message.includes("reading 'init'")) {
-      console.error('❌ Configuracion de base de datos no encontrada\n');
-      console.error('Ejecute el comando para crear una nueva base de datos:');
-      console.error(`\tdbcube run database:create`);
-      console.error('\nO verifique que la base de datos este configurada en el archivo dbcube.config.js\n');
-      process.exit(1);
-    } else if (error.message.includes("reading 'getDatabase'")) {
-      console.error('- Se sugiere cambiar el linea o crear la base de datos a la que se hace referencia.');
-    } else {
-      console.error('Error:', error.message);
-      process.exit(1);
-    }
+    ui.handleError(error);
   }
 }
 
-main().catch(console.error);
+main().catch(ui.handleError);

package/src/commands/run/table/refresh.js

@@ -1,30 +1,17 @@
-const { Schema } = require('@dbcube/schema-builder');
-const ConfigFileUtils = require('./../../../utils/ConfigFileUtils');
-
-async function main() {
-  try {
-    const configuredDatabases = await ConfigFileUtils.getConfiguredDatabases();
-    // Recorrer cada archivo y mostrar su contenido
-    for (const config of configuredDatabases) {
-      const schema = new Schema(config.name);
-      await schema.refreshTables();
-    }
-  } catch (error) {
-    if (error.message.includes("reading 'init'")) {
-      console.error('❌ Configuracion de base de datos no encontrada\n');
-      console.error('Ejecute el comando para crear una nueva base de datos:');
-      console.error(`\tnpx dbcube run database:create`);
-      console.error('\nO verifique que la base de datos este configurada en el archivo dbcube.config.js\n');
-      process.exit(1);
-    } else if (error.message.includes("reading 'getDatabase'")) {
-      console.error('- Se sugiere cambiar el linea o crear la base de datos a la que se hace referencia.');
-    } else {
-      console.error(`❌ ${error.message}`);
-      if (process.env.DEBUG) console.error(error);
-      process.exit(1);
-    }
-  }
-}
-
-// Ejecutar el ejemplo
-main().catch(console.error);
+const { Schema } = require('@dbcube/schema-builder');
+const ConfigFileUtils = require('./../../../utils/ConfigFileUtils');
+const ui = require('./../../../utils/ui');
+
+async function main() {
+  try {
+    const configuredDatabases = await ConfigFileUtils.getConfiguredDatabases();
+    for (const config of configuredDatabases) {
+      const schema = new Schema(config.name);
+      await schema.refreshTables();
+    }
+  } catch (error) {
+    ui.handleError(error);
+  }
+}
+
+main().catch(ui.handleError);

package/src/commands/run/trigger/fresh.js

@@ -1,32 +1,18 @@
-const { Schema } = require('@dbcube/schema-builder');
-const ConfigFileUtils = require('./../../../utils/ConfigFileUtils');
-
-async function main() {
-  try {
-    const configuredDatabases = await ConfigFileUtils.getConfiguredDatabases();
-
-    // Recorrer cada archivo y mostrar su contenido
-    for (const config of configuredDatabases) {
-      const schema = new Schema(config.name);
-      await schema.executeTriggers();
-    }
-  } catch (error) {
-    if (error.message.includes("reading 'init'")) {
-      console.error('❌ Configuracion de base de datos no encontrada\n');
-      console.error('Ejecute el comando para crear una nueva base de datos:');
-      console.error(`\tnpx dbcube run database:create`);
-      console.error('\nO verifique que la base de datos este configurada en el archivo dbcube.config.js\n');
-      process.exit(1);
-    } else if (error.message.includes("reading 'getDatabase'")) {
-      console.error('- Se sugiere cambiar el linea o crear la base de datos a la que se hace referencia.');
-    } else {
-      console.error(`❌ ${error.message}`);
-      if (process.env.DEBUG) console.error(error);
-      process.exit(1);
-    }
-  }
-  console.log('\n');
-}
-
-// Ejecutar el ejemplo
-main().catch(console.error);
+const { Schema } = require('@dbcube/schema-builder');
+const ConfigFileUtils = require('./../../../utils/ConfigFileUtils');
+const ui = require('./../../../utils/ui');
+
+async function main() {
+  try {
+    const configuredDatabases = await ConfigFileUtils.getConfiguredDatabases();
+
+    for (const config of configuredDatabases) {
+      const schema = new Schema(config.name);
+      await schema.executeTriggers();
+    }
+  } catch (error) {
+    ui.handleError(error);
+  }
+}
+
+main().catch(ui.handleError);

package/src/commands/update.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 const chalk = require('chalk');
+const ui = require('../utils/ui');
 const ora = require('ora');
 const path = require('path');
 const fs = require('fs');
@@ -409,7 +410,4 @@ async function main() {
     }
 }
 
-main().catch(err => {
-    console.error(chalk.red('\n❌ Unexpected error:'), err.message);
-    process.exit(1);
-});
+main().catch(ui.handleError);

package/src/commands/validate.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const chalk = require('chalk');
+const ui = require('../utils/ui');
 const { CubeValidator } = require('@dbcube/schema-builder');
 
 /**
@@ -64,7 +65,4 @@ async function main() {
     console.log(`${chalk.green('✓')} All cube files are valid\n`);
 }
 
-main().catch(error => {
-    console.error('Error fatal:', error);
-    process.exit(1);
-});
+main().catch(ui.handleError);

package/src/commands/version.js

@@ -1,6 +1,7 @@
 const path = require('path');
 const fs = require('fs');
 const chalk = require('chalk');
+const ui = require('../utils/ui');
 
 /**
  * dbcube version — CLI, packages, engine binaries, and environment info.
@@ -32,7 +33,7 @@ async function showVersion() {
             console.log(`  ${chalk.gray(label.padEnd(16))} ${dim ? chalk.gray(value) : chalk.white(value)}`);
 
         console.log('');
-        console.log(`  ${chalk.green.bold('▣ DBCube CLI')} ${chalk.bold('v' + cliVersion)}`);
+        console.log(`  ${ui.brand('◆ DBCube CLI')} ${chalk.bold('v' + cliVersion)}`);
         console.log(`  ${chalk.gray('─'.repeat(40))}`);
 
         // Local package versions (when resolvable from the project)
@@ -55,12 +56,8 @@ async function showVersion() {
         row('platform', `${process.platform}-${process.arch}`, true);
         console.log('');
     } catch (error) {
-        console.error('❌ Error al obtener la versión:', error.message);
-        process.exit(1);
+        ui.handleError(error);
     }
 }
 
-showVersion().catch(error => {
-    console.error('Error fatal:', error);
-    process.exit(1);
-});
+showVersion().catch(ui.handleError);

package/src/utils/ConfigFileUtils.js

@@ -1,5 +1,22 @@
 const fs = require('fs');
 const path = require('path');
+const EnvLoader = require('./EnvLoader');
+
+/**
+ * Detecta si el proyecto está marcado como ESM ("type": "module" en
+ * package.json), lo que hace que dbcube.config.js (CommonJS) no se pueda
+ * cargar con require(). Devuelve true si es ESM.
+ */
+function projectIsESM() {
+    try {
+        const pkgPath = path.resolve(process.cwd(), 'package.json');
+        if (!fs.existsSync(pkgPath)) return false;
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        return pkg.type === 'module';
+    } catch {
+        return false;
+    }
+}
 
 /**
  * Clase para manejar operaciones sobre el archivo de configuración
@@ -10,10 +27,15 @@ class ConfigFileUtils {
      * @returns {string} - Ruta al archivo de configuración
      */
     static getConfigPath() {
-        // Usar la ruta raíz del proyecto
         const rootPath = path.resolve(process.cwd());
-        const configPath = path.join(rootPath, 'dbcube.config.js');
-        return configPath;
+        const cjsPath = path.join(rootPath, 'dbcube.config.cjs');
+        const jsPath = path.join(rootPath, 'dbcube.config.js');
+        // Si ya existe alguno, ese manda (preferimos .cjs).
+        if (fs.existsSync(cjsPath)) return cjsPath;
+        if (fs.existsSync(jsPath)) return jsPath;
+        // Si no existe ninguno (se va a crear): en proyectos ESM
+        // ("type": "module") debe ser .cjs para poder cargarse con require().
+        return projectIsESM() ? cjsPath : jsPath;
     }
 
     /**
@@ -21,19 +43,16 @@ class ConfigFileUtils {
      * @returns {Promise<Array<string>>} - Array con los nombres de las bases de datos
      */
     static async getConfiguredDatabases() {
-        try {
-            // Ruta al archivo de configuración
-            const configPath = this.getConfigPath();
-            
-            // Comprobar si el archivo existe
-            if (!fs.existsSync(configPath)) {
-                ConfigFileUtils.crearArchivoConfig(configPath);
-            }
-            
-            return this.loadDatabasesFromPath(configPath);
-        } catch (error) {
-            throw new Error('Error al obtener las bases de datos configuradas:', error);
+        // Sin try/catch que oculte el error: loadDatabasesFromPath ya lanza
+        // mensajes explícitos y accionables. (Antes, `new Error('msg', error)`
+        // descartaba el segundo argumento y se perdía la causa real.)
+        const configPath = this.getConfigPath();
+
+        if (!fs.existsSync(configPath)) {
+            ConfigFileUtils.crearArchivoConfig(configPath);
         }
+
+        return this.loadDatabasesFromPath(configPath);
     }
     
     /**
@@ -42,46 +61,91 @@ class ConfigFileUtils {
      * @returns {Array<string>} - Nombres de las bases de datos
      */
     static loadDatabasesFromPath(configPath) {
+        // Carga automática de .env (cargador propio de DBCube): el usuario no
+        // necesita instalar dotenv ni escribir require("dotenv") en su config.
+        EnvLoader.load();
+
+        let config;
         try {
             // Borrar la caché del módulo para asegurarnos de cargar la versión más reciente
             delete require.cache[require.resolve(configPath)];
-            
             // Cargar el archivo de configuración
-            const config = require(configPath);
-            
-            // Crear una instancia temporal de Config para obtener los datos
-            const tempConfig = {
-                databases: {},
-                data: {},
-                set: function(configData) {
-                    this.data = configData;
-                    if (configData.databases) {
-                        this.databases = configData.databases;
-                    }
-                },
-                getAllDatabases: function() {
-                    return this.databases;
+            config = require(configPath);
+        } catch (error) {
+            const missing = (error.message.match(/Cannot find module '([^']+)'/) || [])[1];
+            // ¿El módulo que no se encuentra es el PROPIO config? Entonces el
+            // problema es de carga (típicamente ESM). Si es OTRO módulo, es una
+            // dependencia del config que falta (p. ej. dotenv).
+            const missingIsConfig = missing && (configPath.includes(missing) || missing.includes('dbcube.config'));
+
+            // Caso 1: falta una dependencia que el config requiere.
+            if (error.code === 'MODULE_NOT_FOUND' && missing && !missingIsConfig) {
+                throw new Error(
+                    `dbcube.config.js requiere un módulo que no está instalado: "${missing}".\n` +
+                    `   Instálalo (p. ej. npm install ${missing}).\n` +
+                    `   Nota: DBCube ya carga el .env automáticamente — puedes quitar require("dotenv") de tu config.`
+                );
+            }
+            // Caso 2: proyecto ESM ("type": "module") → require() del config falla
+            // o el .js se interpreta como módulo ES y `module.exports` no aplica.
+            if (projectIsESM() || error.code === 'ERR_REQUIRE_ESM') {
+                throw new Error(
+                    `No se pudo cargar dbcube.config.js porque el proyecto está marcado como ESM ` +
+                    `("type": "module" en package.json), pero la configuración usa CommonJS (module.exports).\n` +
+                    `   Solución: renombra el archivo a "dbcube.config.cjs", o quita "type": "module" de package.json.`
+                );
+            }
+            // Cualquier otro error de carga: mostrarlo tal cual.
+            throw new Error(`No se pudo cargar la configuración desde ${configPath}:\n   ${error.message}`);
+        }
+
+        // Validar que la config exporte una función (firma esperada).
+        if (typeof config !== 'function') {
+            const hint = projectIsESM()
+                ? ` El proyecto es ESM ("type": "module"): renombra el archivo a "dbcube.config.cjs" o quita "type": "module".`
+                : ` Debe exportar una función: module.exports = function (config) { config.set({ databases: {...} }); }.`;
+            throw new Error(`dbcube.config.js no exporta una configuración válida.${hint}`);
+        }
+
+        // Crear una instancia temporal de Config para obtener los datos
+        const tempConfig = {
+            databases: {},
+            data: {},
+            set: function(configData) {
+                this.data = configData;
+                if (configData.databases) {
+                    this.databases = configData.databases;
                 }
-            };
-            
-            // Ejecutar la función de configuración
-            config(tempConfig);
-            
-            // Obtener los nombres de las bases de datos
-            const databaseNames = Object.keys(tempConfig.getAllDatabases());
-            const arrayDatabases = [];
-            for (const database of databaseNames) {
-                arrayDatabases.push({
-                    name: database,
-                    type: tempConfig.getAllDatabases()[database].type
-                });
+            },
+            getAllDatabases: function() {
+                return this.databases;
             }
-            return arrayDatabases;
+        };
+
+        // Ejecutar la función de configuración
+        try {
+            config(tempConfig);
         } catch (error) {
-            // Fallar claro: devolver una DB inventada ocultaría el problema
-            // y haría que los comandos operen contra una base inexistente
-            throw new Error(`No se pudo cargar la configuración desde ${configPath}: ${error.message}`);
+            throw new Error(`dbcube.config.js lanzó un error al evaluarse:\n   ${error.message}`);
+        }
+
+        const allDatabases = tempConfig.getAllDatabases();
+        if (!allDatabases || Object.keys(allDatabases).length === 0) {
+            throw new Error(
+                `dbcube.config.js no define ninguna base de datos.\n` +
+                `   Añade al menos una en config.set({ databases: { miBase: { type, config } } }).`
+            );
         }
+
+        const databaseNames = Object.keys(allDatabases);
+        const arrayDatabases = [];
+        for (const database of databaseNames) {
+            arrayDatabases.push({
+                name: database,
+                type: allDatabases[database].type
+            });
+        }
+        return arrayDatabases;
     }
 
     /**
@@ -271,15 +335,16 @@ class ConfigFileUtils {
      * @param {string} rutaDestino - Ruta completa donde se debe crear el archivo.
      */
     static crearArchivoConfig(rutaDestino) {
-        const contenido = `require('dotenv').config({ quiet: true });
-
-    module.exports = function (config) {
-        config.set({
-            databases: {
-            }
-        });  
-    };
-    `;
+        // DBCube carga el .env automáticamente, así que el template ya NO
+        // necesita require('dotenv') (que además requeriría instalar el paquete).
+        const contenido = `// DBCube carga .env automáticamente — usa process.env.MI_VAR sin dotenv.
+module.exports = function (config) {
+    config.set({
+        databases: {
+        }
+    });
+};
+`;
 
         // Asegurarse de que el directorio existe
         const dir = path.dirname(rutaDestino);

package/src/utils/EnvLoader.js

@@ -0,0 +1,94 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Cargador de variables de entorno propio de DBCube.
+ *
+ * Evita que el usuario tenga que instalar `dotenv` y escribir
+ * `require("dotenv").config()` al inicio de su dbcube.config.js. DBCube carga
+ * el `.env` del proyecto automáticamente ANTES de evaluar la configuración.
+ *
+ * Estrategia:
+ *   1. `process.loadEnvFile()` — nativo de Node 20.6+ (cero dependencias).
+ *   2. Fallback: parser propio mínimo (KEY=VALUE, comillas, comentarios, export).
+ *
+ * No sobrescribe variables ya presentes en process.env (las del shell mandan).
+ */
+class EnvLoader {
+    /**
+     * Carga el archivo .env indicado (o ./.env del cwd) en process.env.
+     * Silencioso si el archivo no existe. Devuelve true si cargó algo.
+     * @param {string} [envPath]
+     * @returns {boolean}
+     */
+    static load(envPath) {
+        const file = envPath || path.resolve(process.cwd(), '.env');
+        if (!fs.existsSync(file)) return false;
+
+        // Camino preferido: cargador nativo de Node (20.6+).
+        if (typeof process.loadEnvFile === 'function') {
+            try {
+                process.loadEnvFile(file);
+                return true;
+            } catch {
+                // Cae al parser propio si el nativo falla por algún motivo.
+            }
+        }
+
+        try {
+            const content = fs.readFileSync(file, 'utf8');
+            const parsed = EnvLoader.parse(content);
+            for (const [key, value] of Object.entries(parsed)) {
+                if (process.env[key] === undefined) {
+                    process.env[key] = value;
+                }
+            }
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    /**
+     * Parser mínimo de formato .env. Soporta:
+     *   KEY=value · KEY="value con espacios" · KEY='literal' · export KEY=value
+     *   comentarios con # · líneas en blanco · \n \t en comillas dobles.
+     * @param {string} content
+     * @returns {Record<string,string>}
+     */
+    static parse(content) {
+        const out = {};
+        for (let rawLine of content.split(/\r?\n/)) {
+            const line = rawLine.trim();
+            if (!line || line.startsWith('#')) continue;
+
+            // Permite el prefijo `export` (estilo shell).
+            const withoutExport = line.startsWith('export ') ? line.slice(7).trim() : line;
+
+            const eq = withoutExport.indexOf('=');
+            if (eq === -1) continue;
+
+            const key = withoutExport.slice(0, eq).trim();
+            if (!key) continue;
+
+            let value = withoutExport.slice(eq + 1).trim();
+
+            // Comillas dobles: interpreta escapes. Comillas simples: literal.
+            if (value.length >= 2 && value[0] === '"' && value[value.length - 1] === '"') {
+                value = value.slice(1, -1).replace(/\\n/g, '\n').replace(/\\t/g, '\t').replace(/\\"/g, '"');
+            } else if (value.length >= 2 && value[0] === "'" && value[value.length - 1] === "'") {
+                value = value.slice(1, -1);
+            } else {
+                // Sin comillas: corta un comentario en línea (espacio + #).
+                const hash = value.indexOf(' #');
+                if (hash !== -1) value = value.slice(0, hash).trim();
+            }
+
+            out[key] = value;
+        }
+        return out;
+    }
+}
+
+module.exports = EnvLoader;
+module.exports.EnvLoader = EnvLoader;

package/src/utils/ui.js

@@ -0,0 +1,89 @@
+const chalk = require('chalk');
+
+/**
+ * UI compartida del CLI de DBCube. Un solo lugar para el estilo visual:
+ * colores de marca, símbolos de estado y el manejo de errores consistente.
+ * Así todos los comandos se ven como parte del mismo producto.
+ */
+
+// Verde de marca DBCube (con fallback si la terminal no soporta truecolor).
+const brandGreen = (t) => (chalk.level >= 2 ? chalk.hex('#22C55E') : chalk.green)(t);
+
+const ui = {
+    chalk,
+    brand: (t) => brandGreen(chalk.bold(t)),
+
+    /** Banner de marca para el header del CLI/help. */
+    banner(subtitle = 'Database toolkit powered by Rust') {
+        const line = chalk.gray('─'.repeat(54));
+        console.log('');
+        console.log(`  ${brandGreen('◆')} ${ui.brand('DBCube')} ${chalk.gray('CLI')}`);
+        console.log(`  ${chalk.gray(subtitle)}`);
+        console.log(`  ${line}`);
+    },
+
+    /** Cabecera de comando: ícono + título + línea separadora. */
+    header(title, icon = '🧊') {
+        console.log(`\n${icon}  ${ui.brand(title.toUpperCase())}`);
+        console.log(chalk.gray('─'.repeat(54)));
+    },
+
+    /** Línea de detalle bajo una cabecera (clave: valor). */
+    item(label, value) {
+        if (value === undefined) {
+            console.log(`${chalk.gray('│')}  ${label}`);
+        } else {
+            console.log(`${chalk.gray('│')}  ${chalk.gray(label + ':')} ${chalk.white(value)}`);
+        }
+    },
+
+    success(message) { console.log(`${chalk.green('✔')} ${message}`); },
+    info(message) { console.log(`${chalk.cyan('ℹ')} ${message}`); },
+    warn(message) { console.log(`${chalk.yellow('⚠')} ${message}`); },
+    dim(message) { console.log(chalk.gray(message)); },
+    step(message) { console.log(`${chalk.cyan('›')} ${message}`); },
+
+    /** Error con título en rojo y pistas opcionales (→ ...). */
+    error(message, hints = []) {
+        console.error(`\n${chalk.red('✖')} ${chalk.red(message)}`);
+        for (const h of hints) console.error(`  ${chalk.gray('→')} ${chalk.gray(h)}`);
+        console.error('');
+    },
+
+    /** "Cancelado." silencioso (Ctrl+C / prompt cerrado). */
+    cancelled() {
+        console.log(`\n${chalk.gray('Cancelled.')}`);
+    },
+
+    /**
+     * Manejador central de errores de comando. Llamar desde cada catch.
+     * Traduce los fallos comunes a mensajes claros y accionables, sin stacks
+     * (salvo DBCUBE_DEBUG=1), y cierra el proceso con el código adecuado.
+     */
+    handleError(error) {
+        // Ctrl+C / cierre del prompt interactivo.
+        if (error && (error.name === 'ExitPromptError' || /force closed/i.test(error.message || ''))) {
+            ui.cancelled();
+            process.exit(0);
+        }
+
+        const msg = (error && error.message) || String(error);
+
+        // Base de datos/config no inicializada (errores internos típicos).
+        if (msg.includes("reading 'init'") || msg.includes("reading 'getDatabase'") || msg.includes("reading 'type'")) {
+            ui.error('Database configuration not found.', [
+                'Run: npx dbcube run database:create',
+                'Or check that the database is configured in dbcube.config.js',
+            ]);
+            process.exit(1);
+        }
+
+        ui.error(msg);
+        if (process.env.DBCUBE_DEBUG === '1' || process.env.DBCUBE_DEBUG === 'true') {
+            console.error(error);
+        }
+        process.exit(1);
+    },
+};
+
+module.exports = ui;