@dbcube/cli 5.1.4 → 5.1.5

package/src/commands/migrate/lib.js

@@ -0,0 +1,125 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+/**
+ * Migration history for .alter.cube files.
+ * Stored in dbcube/migrations.json so the history travels with the repo.
+ */
+const HISTORY_PATH = () => path.join(process.cwd(), 'dbcube', 'migrations.json');
+
+function loadHistory() {
+    try {
+        return JSON.parse(fs.readFileSync(HISTORY_PATH(), 'utf8'));
+    } catch {
+        return { applied: [], lastBatch: 0 };
+    }
+}
+
+function saveHistory(history) {
+    fs.mkdirSync(path.dirname(HISTORY_PATH()), { recursive: true });
+    fs.writeFileSync(HISTORY_PATH(), JSON.stringify(history, null, 2), 'utf8');
+}
+
+function hashFile(filePath) {
+    return crypto.createHash('sha1').update(fs.readFileSync(filePath)).digest('hex');
+}
+
+function collectAlterFiles(dir = path.join(process.cwd(), 'dbcube'), acc = []) {
+    if (!fs.existsSync(dir)) return acc;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (!['triggers', 'logs', 'node_modules', 'applied'].includes(entry.name)) collectAlterFiles(full, acc);
+        } else if (entry.name.endsWith('.alter.cube')) {
+            acc.push(full);
+        }
+    }
+    return acc;
+}
+
+/** Splits an .alter.cube into header (@database/@table) + directive blocks. */
+function parseAlterFile(content) {
+    const header = [];
+    const dbMatch = content.match(/@database\s*\([^)]*\)\s*;/);
+    const tableMatch = content.match(/@table\s*\([^)]*\)\s*;/);
+    if (dbMatch) header.push(dbMatch[0]);
+    if (tableMatch) header.push(tableMatch[0]);
+
+    const directives = [];
+    const regex = /@(changeName|addColumn|deleteColumn|renameColumn|changeType|changeLength|changeDefault|changeOptions|changeEnumValues)\s*\(([\s\S]*?)\)\s*;/g;
+    let m;
+    while ((m = regex.exec(content)) !== null) {
+        directives.push({ name: m[1], arg: m[2].trim(), raw: m[0] });
+    }
+    return { header, directives };
+}
+
+function swapLastNew(arg) {
+    // Swaps every {last: "x"; new: "y"} pair inside the directive argument
+    return arg.replace(
+        /last\s*:\s*"([^"]*)"\s*;\s*new\s*:\s*"([^"]*)"/g,
+        (_, last, next) => `last: "${next}"; new: "${last}"`
+    );
+}
+
+/** Inverts one directive. Returns a string (reverse cube code) or null if irreversible. */
+function invertDirective(d) {
+    switch (d.name) {
+        case 'changeName':
+        case 'renameColumn':
+        case 'changeType':
+        case 'changeLength':
+        case 'changeDefault':
+            return `@${d.name}(${swapLastNew(d.arg)});`;
+        case 'addColumn': {
+            // Reverse of adding columns = deleting them
+            const cols = [...d.arg.matchAll(/^\s*(\w+)\s*:\s*\{/gm)].map(m => m[1]);
+            // Top-level columns only: the first identifier after { or after a top-level };
+            const topCols = [...d.arg.matchAll(/(?:^|\};)\s*(\w+)\s*:\s*\{/g)].map(m => m[1]);
+            const names = topCols.length > 0 ? topCols : cols;
+            if (names.length === 0) return null;
+            return names.map(c => `@deleteColumn("${c}");`).join('\n');
+        }
+        case 'changeOptions': {
+            // Swap add/remove arrays
+            const swapped = d.arg
+                .replace(/\badd\s*:/g, '__TMP__:')
+                .replace(/\bremove\s*:/g, 'add:')
+                .replace(/__TMP__:/g, 'remove:');
+            return `@changeOptions(${swapped});`;
+        }
+        case 'deleteColumn':
+        case 'changeEnumValues':
+            return null; // irreversible: dropped data / unknown previous values
+        default:
+            return null;
+    }
+}
+
+/**
+ * Builds the full reverse .alter.cube content for a file.
+ * Returns { reverse: string | null, irreversible: string[] }.
+ */
+function buildReverse(content) {
+    const { header, directives } = parseAlterFile(content);
+    const irreversible = [];
+    const reversed = [];
+
+    for (const d of [...directives].reverse()) {
+        const inv = invertDirective(d);
+        if (inv === null) {
+            irreversible.push(`@${d.name}`);
+        } else {
+            reversed.push(inv);
+        }
+    }
+
+    if (irreversible.length > 0) return { reverse: null, irreversible };
+    return {
+        reverse: header.join('\n') + '\n\n' + reversed.join('\n\n') + '\n',
+        irreversible: [],
+    };
+}
+
+module.exports = { loadHistory, saveHistory, hashFile, collectAlterFiles, buildReverse };

package/src/commands/migrate/rollback.js

@@ -0,0 +1,72 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const { Schema } = require('@dbcube/schema-builder');
+const ConfigFileUtils = require('../../utils/ConfigFileUtils');
+const { loadHistory, saveHistory } = require('./lib');
+
+/**
+ * dbcube migrate:rollback — Reverts the last applied batch of .alter.cube
+ * migrations using the auto-generated reverse directives stored at apply time.
+ */
+async function main() {
+    const history = loadHistory();
+    if (history.applied.length === 0 || history.lastBatch === 0) {
+        console.log(`\n${chalk.yellow('⚠')} Nothing to rollback — no applied migrations.\n`);
+        return;
+    }
+
+    const batch = history.lastBatch;
+    const toRevert = history.applied.filter(a => a.batch === batch);
+
+    const blocked = toRevert.filter(a => !a.reverse);
+    if (blocked.length > 0) {
+        console.error(`\n${chalk.red('❌ Cannot rollback batch')} ${batch}:`);
+        for (const b of blocked) {
+            console.error(`   ${b.file} ${chalk.gray('contains irreversible directives (@deleteColumn / @changeEnumValues)')}`);
+        }
+        console.error(`\n${chalk.gray('Write a manual .alter.cube to undo those changes.')}\n`);
+        process.exit(1);
+    }
+
+    console.log(`\n⏪ ${chalk.green.bold(`Rolling back batch ${batch}`)} (${toRevert.length} migration(s))\n`);
+
+    const cubesDir = path.join(process.cwd(), 'dbcube');
+    const tempFiles = [];
+
+    try {
+        // Write reverse files (reverse application order: last applied reverts first)
+        for (const entry of [...toRevert].reverse()) {
+            const tempName = `__rollback_${Date.now()}_${entry.file}`;
+            const tempPath = path.join(cubesDir, tempName);
+            fs.writeFileSync(tempPath, entry.reverse, 'utf8');
+            tempFiles.push({ tempName, tempPath, entry });
+        }
+
+        const configuredDatabases = await ConfigFileUtils.getConfiguredDatabases();
+        for (const config of configuredDatabases) {
+            const schema = new Schema(config.name);
+            try {
+                await schema.executeAlters(tempFiles.map(t => t.tempName));
+            } catch (e) {
+                if (!String(e.message).includes('no .alter.cube files')) throw e;
+            }
+        }
+
+        // Remove reverted entries from history
+        history.applied = history.applied.filter(a => a.batch !== batch);
+        history.lastBatch = history.applied.reduce((max, a) => Math.max(max, a.batch), 0);
+        saveHistory(history);
+
+        console.log(`\n${chalk.green('✓')} Batch ${batch} rolled back. ${chalk.gray('Remember to update your .table.cube files if they reflected those changes.')}\n`);
+    } finally {
+        for (const t of tempFiles) {
+            try { fs.unlinkSync(t.tempPath); } catch { /* already gone */ }
+        }
+    }
+}
+
+main().catch(error => {
+    console.error(`${chalk.red('❌ Rollback failed:')}`, error.message);
+    process.exit(1);
+});

package/src/commands/migrate/status.js

@@ -0,0 +1,55 @@
+const path = require('path');
+const chalk = require('chalk');
+const { loadHistory, hashFile, collectAlterFiles } = require('./lib');
+
+/**
+ * dbcube migrate:status — Shows applied and pending .alter.cube migrations.
+ */
+async function main() {
+    const history = loadHistory();
+    const files = collectAlterFiles();
+    const appliedByFile = new Map(history.applied.map(a => [a.file, a]));
+
+    console.log(`\n📋 ${chalk.green.bold('Migration status')}\n`);
+
+    if (history.applied.length === 0 && files.length === 0) {
+        console.log(`  ${chalk.gray('No .alter.cube migrations found.')}\n`);
+        return;
+    }
+
+    if (history.applied.length > 0) {
+        console.log(chalk.cyan.bold('  Applied:'));
+        for (const a of history.applied) {
+            const reversible = a.reverse ? chalk.gray('reversible') : chalk.yellow('irreversible');
+            console.log(`    ${chalk.green('✓')} ${a.file}  ${chalk.gray(`batch ${a.batch} · ${a.applied_at}`)} · ${reversible}`);
+        }
+    }
+
+    const pending = [];
+    const modified = [];
+    for (const f of files) {
+        const base = path.basename(f);
+        const applied = appliedByFile.get(base);
+        if (!applied) pending.push(base);
+        else if (applied.hash !== hashFile(f)) modified.push(base);
+    }
+
+    if (pending.length > 0) {
+        console.log(`\n${chalk.cyan.bold('  Pending:')}`);
+        for (const p of pending) console.log(`    ${chalk.yellow('○')} ${p}`);
+        console.log(`\n  ${chalk.gray('Apply with:')} ${chalk.white('npx dbcube run table:alter')}`);
+    } else {
+        console.log(`\n  ${chalk.green('Everything up to date — no pending migrations.')}`);
+    }
+
+    if (modified.length > 0) {
+        console.log(`\n${chalk.red.bold('  ⚠ Modified after being applied:')}`);
+        for (const m of modified) console.log(`    ${chalk.red('!')} ${m} ${chalk.gray('— create a NEW alter file instead of editing applied ones')}`);
+    }
+    console.log('');
+}
+
+main().catch(error => {
+    console.error('Error fatal:', error);
+    process.exit(1);
+});

package/src/commands/run/pull.js

@@ -0,0 +1,192 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const ConfigFileUtils = require('../../utils/ConfigFileUtils');
+const { Engine } = require('@dbcube/schema-builder');
+
+/**
+ * dbcube run pull [database] — Introspects an EXISTING database and generates
+ * .table.cube files from its real schema. The migration path for legacy projects.
+ */
+const SQL_TYPE_MAP = {
+    'int': 'int', 'integer': 'int', 'bigint': 'bigint', 'tinyint': 'tinyint', 'smallint': 'int',
+    'character varying': 'varchar', 'varchar': 'varchar', 'char': 'varchar', 'character': 'varchar',
+    'text': 'text', 'longtext': 'text', 'mediumtext': 'text',
+    'decimal': 'decimal', 'numeric': 'decimal', 'float': 'float', 'real': 'float',
+    'double': 'double', 'double precision': 'double',
+    'boolean': 'boolean', 'bool': 'boolean',
+    'date': 'date', 'datetime': 'datetime',
+    'timestamp': 'timestamp', 'timestamp without time zone': 'timestamp', 'timestamp with time zone': 'timestamp',
+    'json': 'json', 'jsonb': 'json', 'enum': 'enum', 'uuid': 'varchar', 'blob': 'text',
+};
+
+async function raw(engine, sql) {
+    const res = await engine.run('query_engine', ['--action', 'raw', '--query', sql, '--params', '[]']);
+    if (res.status !== 200) throw new Error(res.message);
+    return res.data || [];
+}
+
+async function introspect(engine, dbName, motor) {
+    const tables = {}; // name -> { columns: [], pks: Set, fks: {col: {table, column}} }
+
+    if (motor === 'sqlite') {
+        const rows = await raw(engine, `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE 'dbcube_%'`);
+        for (const r of rows) {
+            const t = r.name;
+            const cols = await raw(engine, `PRAGMA table_info(${t})`);
+            const fkRows = await raw(engine, `PRAGMA foreign_key_list(${t})`);
+            const fks = {};
+            for (const fk of fkRows) fks[fk.from] = { table: fk.table, column: fk.to || 'id' };
+            tables[t] = {
+                columns: cols.map(c => ({
+                    name: c.name,
+                    dataType: String(c.type || 'text').toLowerCase().replace(/\(.*\)/, '').trim(),
+                    length: (String(c.type || '').match(/\((\d+(,\d+)?)\)/) || [])[1] || null,
+                    nullable: c.notnull == 0,
+                    defaultValue: c.dflt_value,
+                    isPk: c.pk > 0,
+                    autoinc: c.pk > 0 && /int/i.test(String(c.type)),
+                    enumValues: null,
+                })),
+                fks,
+            };
+        }
+    } else if (motor === 'mysql') {
+        const cols = await raw(engine, `SELECT TABLE_NAME tn, COLUMN_NAME cn, DATA_TYPE dt, CHARACTER_MAXIMUM_LENGTH len, NUMERIC_PRECISION np, NUMERIC_SCALE ns, IS_NULLABLE nullable, COLUMN_DEFAULT dv, COLUMN_KEY ck, EXTRA extra, COLUMN_TYPE ct FROM information_schema.columns WHERE table_schema = DATABASE() ORDER BY TABLE_NAME, ORDINAL_POSITION`);
+        const fkRows = await raw(engine, `SELECT TABLE_NAME tn, COLUMN_NAME cn, REFERENCED_TABLE_NAME rt, REFERENCED_COLUMN_NAME rc FROM information_schema.key_column_usage WHERE table_schema = DATABASE() AND REFERENCED_TABLE_NAME IS NOT NULL`);
+        for (const c of cols) {
+            const t = c.tn;
+            if (String(t).startsWith('dbcube_')) continue;
+            tables[t] = tables[t] || { columns: [], fks: {} };
+            let enumValues = null;
+            if (c.dt === 'enum' && c.ct) {
+                enumValues = [...String(c.ct).matchAll(/'((?:[^']|'')*)'/g)].map(m => m[1]);
+            }
+            tables[t].columns.push({
+                name: c.cn,
+                dataType: String(c.dt).toLowerCase(),
+                length: c.len ?? (c.np != null && c.ns != null && c.dt === 'decimal' ? `${c.np},${c.ns}` : null),
+                nullable: c.nullable === 'YES',
+                defaultValue: c.dv,
+                isPk: c.ck === 'PRI',
+                autoinc: /auto_increment/i.test(c.extra || ''),
+                enumValues,
+            });
+        }
+        for (const fk of fkRows) {
+            if (!tables[fk.tn]) continue;
+            tables[fk.tn].fks[fk.cn] = { table: fk.rt, column: fk.rc };
+        }
+    } else if (motor === 'postgres' || motor === 'postgresql') {
+        const cols = await raw(engine, `SELECT c.table_name tn, c.column_name cn, c.data_type dt, c.character_maximum_length len, c.numeric_precision np, c.numeric_scale ns, c.is_nullable nullable, c.column_default dv FROM information_schema.columns c WHERE c.table_schema = 'public' ORDER BY c.table_name, c.ordinal_position`);
+        const pkRows = await raw(engine, `SELECT kcu.table_name tn, kcu.column_name cn FROM information_schema.table_constraints tc JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema WHERE tc.constraint_type = 'PRIMARY KEY' AND tc.table_schema = 'public'`);
+        const fkRows = await raw(engine, `SELECT kcu.table_name tn, kcu.column_name cn, ccu.table_name rt, ccu.column_name rc FROM information_schema.table_constraints tc JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name JOIN information_schema.constraint_column_usage ccu ON tc.constraint_name = ccu.constraint_name WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = 'public'`);
+        const pks = new Set(pkRows.map(r => `${r.tn}.${r.cn}`));
+        for (const c of cols) {
+            const t = c.tn;
+            if (String(t).startsWith('dbcube_')) continue;
+            tables[t] = tables[t] || { columns: [], fks: {} };
+            tables[t].columns.push({
+                name: c.cn,
+                dataType: String(c.dt).toLowerCase(),
+                length: c.len ?? (c.np != null && c.ns != null && /numeric|decimal/.test(c.dt) ? `${c.np},${c.ns}` : null),
+                nullable: c.nullable === 'YES',
+                defaultValue: c.dv,
+                isPk: pks.has(`${t}.${c.cn}`),
+                autoinc: /nextval\(/.test(c.dv || ''),
+                enumValues: null,
+            });
+        }
+        for (const fk of fkRows) {
+            if (!tables[fk.tn]) continue;
+            tables[fk.tn].fks[fk.cn] = { table: fk.rt, column: fk.rc };
+        }
+    } else {
+        throw new Error(`pull is not supported yet for motor '${motor}' (mysql, postgresql, sqlite available)`);
+    }
+
+    return tables;
+}
+
+function renderCube(dbName, tableName, table) {
+    let out = `@database("${dbName}");\n\n`;
+    out += `@meta({\n    name: "${tableName}";\n    description: "Imported from existing database by dbcube pull";\n});\n\n`;
+    out += `@columns({\n`;
+
+    for (const col of table.columns) {
+        const cubeType = SQL_TYPE_MAP[col.dataType] || 'varchar';
+        out += `    ${col.name}: {\n`;
+        out += `        type: "${cubeType === 'enum' && !col.enumValues ? 'varchar' : cubeType}";\n`;
+        if (col.length && ['varchar', 'decimal'].includes(cubeType)) {
+            out += `        length: "${col.length}";\n`;
+        } else if (cubeType === 'varchar' && !col.length) {
+            out += `        length: "255";\n`;
+        }
+        if (cubeType === 'enum' && col.enumValues && col.enumValues.length > 0) {
+            out += `        enumValues: [${col.enumValues.map(v => `"${v}"`).join(', ')}];\n`;
+        }
+        const options = [];
+        if (col.isPk) options.push('"primary"');
+        if (col.autoinc) options.push('"autoincrement"');
+        if (!col.nullable && !col.isPk) options.push('"not null"');
+        if (options.length > 0) out += `        options: [${options.join(', ')}];\n`;
+        if (col.defaultValue != null && !col.autoinc && !/nextval|CURRENT_TIMESTAMP/i.test(String(col.defaultValue))) {
+            const dv = String(col.defaultValue).replace(/^'(.*)'(::.*)?$/, '$1');
+            out += `        defaultValue: "${dv}";\n`;
+        }
+        const fk = table.fks[col.name];
+        if (fk) {
+            out += `        foreign: {\n            table: "${fk.table}";\n            column: "${fk.column}";\n        };\n`;
+        }
+        out += `    };\n`;
+    }
+    out += `});\n`;
+    return out;
+}
+
+async function main() {
+    const targetDb = process.argv[2];
+    const configured = await ConfigFileUtils.getConfiguredDatabases();
+    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`);
+        process.exit(1);
+    }
+
+    const cubesDir = path.join(process.cwd(), 'dbcube');
+    fs.mkdirSync(cubesDir, { recursive: true });
+
+    for (const db of dbs) {
+        console.log(`\n📥 ${chalk.green.bold('Pulling schema from')} ${chalk.bold(db.name)} (${db.type})...\n`);
+        const engine = new Engine(db.name);
+        const tables = await introspect(engine, db.name, db.type);
+        const names = Object.keys(tables);
+
+        if (names.length === 0) {
+            console.log(`  ${chalk.yellow('⚠')} No tables found`);
+            continue;
+        }
+
+        for (const t of names) {
+            const cube = renderCube(db.name, t, tables[t]);
+            const file = path.join(cubesDir, `${t}.table.cube`);
+            if (fs.existsSync(file)) {
+                const backup = file + '.pulled';
+                fs.writeFileSync(backup, cube, 'utf8');
+                console.log(`  ${chalk.yellow('⚠')} ${t}.table.cube exists — wrote ${path.basename(backup)} instead (diff & merge manually)`);
+            } else {
+                fs.writeFileSync(file, cube, 'utf8');
+                console.log(`  ${chalk.green('✓')} dbcube/${t}.table.cube (${tables[t].columns.length} columns${Object.keys(tables[t].fks).length ? `, ${Object.keys(tables[t].fks).length} FK` : ''})`);
+            }
+        }
+    }
+
+    console.log(`\n${chalk.green('✓ Pull complete.')} Review the generated cubes, then your schema is fully managed by DBCube.\n`);
+    process.exit(0);
+}
+
+main().catch(error => {
+    console.error(`${chalk.red('❌ Pull failed:')}`, error.message);
+    process.exit(1);
+});

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

@@ -1,13 +1,66 @@
+const fs = require('fs');
+const path = require('path');
 const { Schema } = require('@dbcube/schema-builder');
 const ConfigFileUtils = require('./../../../utils/ConfigFileUtils');
+const { loadHistory, saveHistory, hashFile, collectAlterFiles, buildReverse } = require('../../migrate/lib');
 
+/**
+ * dbcube run table:alter [--dry-run] [--all]
+ * Applies PENDING .alter.cube migrations (tracked in dbcube/migrations.json).
+ * --dry-run: prints the SQL without executing anything.
+ * --all: re-runs every alter file, ignoring the history (legacy behavior).
+ */
 async function main() {
+  const args = process.argv.slice(2);
+  const dryRun = args.includes('--dry-run');
+  const runAll = args.includes('--all');
+
   try {
+    const history = loadHistory();
+    const appliedNames = new Set(history.applied.map(a => a.file));
+    const allFiles = collectAlterFiles();
+
+    // Only pending files (unless --all)
+    const targetFiles = runAll ? allFiles : allFiles.filter(f => !appliedNames.has(path.basename(f)));
+
+    if (targetFiles.length === 0) {
+      console.log('\n✅ No pending migrations — everything up to date.');
+      console.log('   (use --all to re-run applied alter files)\n');
+      return;
+    }
+
+    const targetNames = targetFiles.map(f => path.basename(f));
     const configuredDatabases = await ConfigFileUtils.getConfiguredDatabases();
 
     for (const config of configuredDatabases) {
       const schema = new Schema(config.name);
-      await schema.executeAlters();
+      try {
+        await schema.executeAlters(targetNames, { dryRun });
+      } catch (e) {
+        if (!String(e.message).includes('no .alter.cube files')) throw e;
+      }
+    }
+
+    // Record history (skip on dry-run)
+    if (!dryRun) {
+      const batch = history.lastBatch + 1;
+      for (const file of targetFiles) {
+        const base = path.basename(file);
+        if (appliedNames.has(base)) continue;
+        const content = fs.readFileSync(file, 'utf8');
+        const { reverse } = buildReverse(content);
+        history.applied.push({
+          file: base,
+          hash: hashFile(file),
+          batch,
+          applied_at: new Date().toISOString(),
+          reverse, // null => irreversible
+        });
+      }
+      history.lastBatch = batch;
+      saveHistory(history);
+      console.log(`\n📋 Recorded batch ${batch} in dbcube/migrations.json`);
+      console.log('   Status: npx dbcube migrate:status · Rollback: npx dbcube migrate:rollback\n');
     }
   } catch (error) {
     if (error.message.includes("reading 'init'")) {
@@ -33,11 +86,10 @@ async function main() {
       console.error('');
       process.exit(1);
     } else {
-      console.error('Error:', error);
       console.error('Error:', error.message);
+      process.exit(1);
     }
   }
 }
 
-// Ejecutar el ejemplo
 main().catch(console.error);

package/src/commands/validate.js

@@ -0,0 +1,70 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const { CubeValidator } = require('@dbcube/schema-builder');
+
+/**
+ * dbcube validate — Validates every .cube file in dbcube/ without executing
+ * anything. Exit code 1 when any file is invalid (CI-friendly).
+ */
+function collectCubeFiles(dir, acc = []) {
+    if (!fs.existsSync(dir)) return acc;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (!['triggers', 'logs', 'node_modules'].includes(entry.name)) collectCubeFiles(full, acc);
+        } else if (entry.name.endsWith('.cube')) {
+            acc.push(full);
+        }
+    }
+    return acc;
+}
+
+async function main() {
+    const cubesDir = path.join(process.cwd(), 'dbcube');
+    const files = collectCubeFiles(cubesDir);
+
+    if (files.length === 0) {
+        console.log(`${chalk.yellow('⚠')} No .cube files found in dbcube/`);
+        process.exit(0);
+    }
+
+    console.log(`\n🔎 ${chalk.green('Validating')} ${files.length} cube file(s)...\n`);
+
+    const validator = new CubeValidator();
+    let errorCount = 0;
+
+    for (const file of files) {
+        const rel = path.relative(process.cwd(), file);
+        // CubeValidator covers .table.cube structure; other types get a syntax-level pass
+        let result;
+        try {
+            result = validator.validateCubeFile(file);
+        } catch (e) {
+            result = { isValid: false, errors: [{ error: e.message, lineNumber: 1 }] };
+        }
+
+        if (result.isValid) {
+            console.log(`  ${chalk.green('✓')} ${rel}`);
+        } else {
+            errorCount++;
+            console.log(`  ${chalk.red('✗')} ${rel}`);
+            for (const err of result.errors) {
+                const line = err.lineNumber ? chalk.gray(`:${err.lineNumber}`) : '';
+                console.log(`      ${chalk.red('[error]')} ${err.error}${line}`);
+            }
+        }
+    }
+
+    console.log('');
+    if (errorCount > 0) {
+        console.log(`${chalk.red('✗')} ${errorCount} file(s) with errors\n`);
+        process.exit(1);
+    }
+    console.log(`${chalk.green('✓')} All cube files are valid\n`);
+}
+
+main().catch(error => {
+    console.error('Error fatal:', error);
+    process.exit(1);
+});

package/src/index.js

@@ -47,14 +47,26 @@ const commandMap = {
   'run:database:create:config': '../src/commands/run/database/create/addDatabaseConfig.js',
   'run:database:create:physical': '../src/commands/run/database/create/createDatabase.js',
 
+  'run:pull': '../src/commands/run/pull.js',
+
   'run:download': '../src/commands/run/download.js',
   'run:update': '../src/commands/run/update.js',
 
+  'init': '../src/commands/init.js',
+  'generate': '../src/commands/generate.js',
+  'validate': '../src/commands/validate.js',
+  'doctor': '../src/commands/doctor.js',
+  'dev': '../src/commands/dev.js',
+
+  'migrate:status': '../src/commands/migrate/status.js',
+  'migrate:rollback': '../src/commands/migrate/rollback.js',
+
   'update': '../src/commands/update.js',
 
   '--version': '../src/commands/version.js',
   '-v': '../src/commands/version.js',
 
+  'help': '../src/commands/help.js',
   '--help': '../src/commands/help.js',
   '-h': '../src/commands/help.js',
 };