ts-prorm-orm 1.1.0

package/dist/cli.js

@@ -0,0 +1,2200 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * CLI Tools - Command-line interface for the ORM. This is the single,
+ * canonical CLI implementation exposed via the published `orm-cli` bin.
+ * Provides commands: init, migration:create, migration:run, migration:revert,
+ * migration:status, model:create, seeder:create, db:*, diagram:*
+ *
+ * Usage:
+ *   orm-cli init
+ *   orm-cli migration:create -- --name <migration-name>
+ *   orm-cli migration:run
+ *   orm-cli migration:revert
+ *   orm-cli migration:status
+ *   orm-cli model:create --dialect sqlite --database ./mydb.sqlite
+ *
+ * Model Generator (programmatic):
+ *   CLI.model('User', { name: 'STRING', email: 'STRING' })
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLI = void 0;
+exports.init = init;
+exports.getProrm = getProrm;
+exports.migrationCreate = migrationCreate;
+exports.migrationRun = migrationRun;
+exports.migrationRevert = migrationRevert;
+exports.migrationStatus = migrationStatus;
+exports.showHelp = showHelp;
+exports.model = model;
+exports.generateModels = generateModels;
+exports.configure = configure;
+exports.getOutputDir = getOutputDir;
+exports.setOutputDir = setOutputDir;
+exports.listModels = listModels;
+exports.removeModel = removeModelFile;
+exports.diagramModel = diagramModel;
+exports.diagramER = diagramER;
+exports.diagramMigration = diagramMigration;
+exports.modelCreateCommand = modelCreateCommand;
+exports.prismaImportCommand = prismaImportCommand;
+exports.seederCreate = seederCreate;
+exports.dbSeed = dbSeed;
+exports.dbSeedUndo = dbSeedUndo;
+exports.dbSeedUndoAll = dbSeedUndoAll;
+exports.dbSeedStatus = dbSeedStatus;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const migrations_1 = require("./migrations");
+const diagrams_1 = require("./diagrams");
+const seeder_1 = require("./migrations/seeder");
+const prorm_1 = require("./prorm");
+/**
+ * Connect to a database and get schema information
+ */
+async function getDbSchema(connectionString) {
+    // Parse connection string: mysql://user:pass@host:port/db, postgres://..., sqlite:./path
+    let dialect = 'sqlite';
+    let database = ':memory:';
+    let username = '';
+    let password = '';
+    let host = 'localhost';
+    let port = 3306;
+    let storage = ':memory:';
+    if (connectionString.startsWith('mysql://') || connectionString.startsWith('mariadb://')) {
+        const url = new URL(connectionString);
+        dialect = connectionString.startsWith('mysql') ? 'mysql' : 'mariadb';
+        username = url.username;
+        password = url.password;
+        host = url.hostname;
+        port = parseInt(url.port) || 3306;
+        database = url.pathname.slice(1);
+    }
+    else if (connectionString.startsWith('postgres://') ||
+        connectionString.startsWith('postgresql://')) {
+        const url = new URL(connectionString);
+        dialect = 'postgres';
+        username = url.username;
+        password = url.password;
+        host = url.hostname;
+        port = parseInt(url.port) || 5432;
+        database = url.pathname.slice(1);
+    }
+    else if (connectionString.startsWith('sqlite:')) {
+        dialect = 'sqlite';
+        storage = connectionString.replace('sqlite:', '');
+        if (!storage)
+            storage = ':memory:';
+    }
+    else {
+        // Assume it's a file path for sqlite
+        dialect = 'sqlite';
+        storage = connectionString;
+    }
+    const seq = new prorm_1.Prorm({
+        dialect,
+        database,
+        username,
+        password,
+        host,
+        port,
+        storage: dialect === 'sqlite' ? storage : undefined,
+        logging: false,
+    });
+    await seq.authenticate();
+    log(`Connected to ${dialect} database`, 'info');
+    // Query table information based on dialect
+    let tables = [];
+    if (dialect === 'mysql' || dialect === 'mariadb') {
+        const [rows] = (await seq.query(`SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA = ?`, {
+            replacements: [database],
+        }));
+        for (const row of rows) {
+            const tableName = row.TABLE_NAME;
+            const [cols] = (await seq.query(`SELECT * FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?`, {
+                replacements: [database, tableName],
+            }));
+            tables.push({
+                name: tableName,
+                columns: cols.map((c) => ({
+                    name: c.COLUMN_NAME,
+                    type: c.COLUMN_TYPE,
+                    allowNull: c.IS_NULLABLE === 'YES',
+                    defaultValue: c.COLUMN_DEFAULT,
+                    primaryKey: c.COLUMN_KEY === 'PRI',
+                    unique: c.COLUMN_KEY === 'UNI',
+                    autoIncrement: c.EXTRA === 'auto_increment',
+                })),
+            });
+        }
+    }
+    else if (dialect === 'postgres') {
+        const [tablesRes] = (await seq.query(`SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'`));
+        for (const row of tablesRes) {
+            const tableName = row.table_name;
+            const [cols] = (await seq.query(`SELECT column_name, data_type, is_nullable, column_default, character_maximum_length FROM information_schema.columns WHERE table_name = $1 AND table_schema = 'public'`, {
+                replacements: [tableName],
+            }));
+            tables.push({
+                name: tableName,
+                columns: cols.map((c) => ({
+                    name: c.column_name,
+                    type: c.data_type + (c.character_maximum_length ? `(${c.character_maximum_length})` : ''),
+                    allowNull: c.is_nullable === 'YES',
+                    defaultValue: c.column_default,
+                    primaryKey: false,
+                    unique: false,
+                    autoIncrement: false,
+                })),
+            });
+        }
+    }
+    else if (dialect === 'sqlite') {
+        const [tablesRes] = (await seq.query(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`));
+        for (const row of tablesRes) {
+            const tableName = row.name;
+            const [cols] = (await seq.query(`PRAGMA table_info("${tableName}")`));
+            tables.push({
+                name: tableName,
+                columns: cols.map((c) => ({
+                    name: c.name,
+                    type: c.type,
+                    allowNull: c.notnull === 0,
+                    defaultValue: c.dflt_value,
+                    primaryKey: c.pk === 1,
+                    unique: false,
+                    autoIncrement: c.autoincrement === 1,
+                })),
+            });
+        }
+    }
+    await seq.close();
+    return tables;
+}
+/**
+ * Convert database schema to ModelDiagramOptions[]
+ */
+function schemaToModels(tables) {
+    return tables.map((table) => ({
+        name: table.name.charAt(0).toUpperCase() +
+            table.name.slice(1).replace(/_([a-z])/g, (_, c) => c.toUpperCase()),
+        tableName: table.name,
+        fields: Object.fromEntries(table.columns.map((col) => [
+            col.name,
+            {
+                type: col.type,
+                primaryKey: col.primaryKey,
+                allowNull: col.allowNull,
+                defaultValue: col.defaultValue,
+                autoIncrement: col.autoIncrement,
+                unique: col.unique,
+            },
+        ])),
+        timestamps: true,
+    }));
+}
+// ==================== Model Generator ====================
+// Map of shorthand types to DataTypes
+const TYPE_MAP = {
+    STRING: 'DataTypes.STRING(255)',
+    TEXT: 'DataTypes.TEXT()',
+    INTEGER: 'DataTypes.INTEGER()',
+    BIGINT: 'DataTypes.BIGINT()',
+    FLOAT: 'DataTypes.FLOAT()',
+    DOUBLE: 'DataTypes.DOUBLE()',
+    DECIMAL: 'DataTypes.DECIMAL(10, 2)',
+    BOOLEAN: 'DataTypes.BOOLEAN()',
+    DATE: 'DataTypes.DATE()',
+    DATEONLY: 'DataTypes.DATEONLY()',
+    TIME: 'DataTypes.TIME()',
+    UUID: 'DataTypes.UUID()',
+    JSON: 'DataTypes.JSON()',
+    JSONB: 'DataTypes.JSONB()',
+    BLOB: 'DataTypes.BLOB()',
+    ENUM: "DataTypes.ENUM('value1', 'value2')",
+    ARRAY: 'DataTypes.ARRAY(DataTypes.STRING)',
+};
+let modelConfig = {
+    outputDir: process.cwd(),
+};
+/**
+ * Configure model generator options
+ */
+function configure(options) {
+    modelConfig = { ...modelConfig, ...options };
+}
+/**
+ * Get the output directory for generated models
+ */
+function getOutputDir() {
+    return modelConfig.outputDir;
+}
+/**
+ * Set the output directory for generated models
+ */
+function setOutputDir(dir) {
+    modelConfig.outputDir = dir;
+}
+/**
+ * Parse a type string into DataTypes expression
+ */
+function parseModelType(typeStr) {
+    // Check for type with length (e.g., STRING(100))
+    const match = typeStr.match(/^(\w+)\((\d+)\)$/);
+    if (match) {
+        const [, type, length] = match;
+        if (TYPE_MAP[type]) {
+            return TYPE_MAP[type].replace(/\(\d+\)/, `(${length})`);
+        }
+        return `DataTypes.${type}(${length})`;
+    }
+    // Check for simple type
+    if (TYPE_MAP[typeStr]) {
+        return TYPE_MAP[typeStr];
+    }
+    // Default to STRING
+    return 'DataTypes.STRING(255)';
+}
+/**
+ * Generate field definitions from simple field map
+ */
+function generateFieldDefs(fields, primaryKey, autoIncrement, allowNull, unique) {
+    const lines = [];
+    const fieldNames = Object.keys(fields);
+    // Add user-defined fields (skip id - it's added if primaryKey is true)
+    fieldNames.forEach((fieldName) => {
+        const typeStr = fields[fieldName];
+        const parsedType = parseModelType(typeStr);
+        const fieldDef = [];
+        fieldDef.push(`    ${fieldName}: {`);
+        fieldDef.push(`      type: ${parsedType},`);
+        // Only add allowNull if it's true (default is false)
+        if (allowNull) {
+            fieldDef.push(`      allowNull: ${allowNull},`);
+        }
+        if (unique) {
+            fieldDef.push(`      unique: true,`);
+        }
+        // Remove trailing comma and close
+        const lastIdx = fieldDef.length - 1;
+        fieldDef[lastIdx] = fieldDef[lastIdx].replace(/,$/, '');
+        fieldDef.push('    },');
+        lines.push(fieldDef.join('\n'));
+    });
+    // Prepend id field if primaryKey is enabled
+    if (primaryKey) {
+        const idField = `    id: {
+      type: DataTypes.INTEGER(),
+      primaryKey: true,
+      autoIncrement: ${autoIncrement},
+    },`;
+        lines.unshift(idField);
+    }
+    return lines.join('\n');
+}
+/**
+ * Generate the complete model file content
+ */
+function generateModelFile(modelName, tableName, fieldDefs, timestamps, paranoid) {
+    const options = [];
+    options.push(`tableName: '${tableName}',`);
+    options.push(`timestamps: ${timestamps},`);
+    if (paranoid) {
+        options.push(`paranoid: true,`);
+    }
+    return `import { DataTypes, Model } from 'ts-prorm-orm';
+
+/**
+ * ${modelName} model
+ * Generated by CLI model generator
+ */
+export interface ${modelName}Attributes {
+  id?: number;
+}
+
+export interface ${modelName}Instance extends Model, ${modelName}Attributes {
+  // Instance methods can be added here
+}
+
+const ${modelName} = (prorm: any) => {
+  const ${modelName}Model = prorm.define('${modelName}', {
+${fieldDefs}
+  }, {
+${options.map((opt) => `    ${opt}`).join('\n')}
+  });
+
+  // Define associations
+  // ${modelName}Model.associate = (models: any) => {
+  //   ${modelName}Model.hasMany(models.Post, { foreignKey: 'userId', as: 'posts' });
+  //   ${modelName}Model.belongsTo(models.Other, { foreignKey: 'otherId', as: 'other' });
+  // };
+
+  return ${modelName}Model;
+};
+
+export { ${modelName} };
+export default ${modelName};
+`;
+}
+/**
+ * Generate a model file from model name and fields
+ * @param modelName - The name of the model (e.g., 'User')
+ * @param fields - Object defining fields (e.g., { name: 'STRING', email: 'STRING' })
+ * @param options - Optional model configuration
+ */
+function model(modelName, fields, options = {}) {
+    const { tableName = modelName.toLowerCase() + 's', timestamps = true, paranoid = false, primaryKey = true, autoIncrement = true, allowNull = false, unique = false, } = options;
+    // Build field definitions
+    const fieldDefs = generateFieldDefs(fields, primaryKey, autoIncrement, allowNull, unique);
+    // Generate the model file content
+    const modelContent = generateModelFile(modelName, tableName, fieldDefs, timestamps, paranoid);
+    // Determine output path
+    const outputPath = path.join(modelConfig.outputDir, `${modelName}.ts`);
+    // Write the file
+    fs.writeFileSync(outputPath, modelContent, 'utf-8');
+    console.log(`Model "${modelName}" created at: ${outputPath}`);
+    return outputPath;
+}
+/**
+ * Generate multiple models at once
+ */
+function generateModels(definitions) {
+    const generatedFiles = [];
+    for (const [modelName, fields] of Object.entries(definitions)) {
+        const filePath = model(modelName, fields);
+        generatedFiles.push(filePath);
+    }
+    return generatedFiles;
+}
+/**
+ * Get list of generated model files in the output directory
+ */
+function listModels() {
+    const outputDir = modelConfig.outputDir;
+    if (!fs.existsSync(outputDir)) {
+        return [];
+    }
+    return fs
+        .readdirSync(outputDir)
+        .filter((file) => file.endsWith('.ts') && file !== 'index.ts')
+        .sort();
+}
+/**
+ * Remove a generated model file
+ */
+function removeModelFile(modelName) {
+    const filePath = path.join(modelConfig.outputDir, `${modelName}.ts`);
+    if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+        console.log(`Model "${modelName}" removed from: ${filePath}`);
+        return true;
+    }
+    console.log(`Model "${modelName}" not found at: ${filePath}`);
+    return false;
+}
+/**
+ * CLI object for chained usage: CLI.model('User', { ... })
+ */
+const CLI = {
+    model,
+    generateModels,
+    configure,
+    getOutputDir,
+    setOutputDir,
+    listModels,
+    removeModel: removeModelFile,
+};
+exports.CLI = CLI;
+// Default configuration
+const defaultConfig = {
+    migrationsPath: path.join(process.cwd(), 'migrations'),
+    seedersPath: path.join(process.cwd(), 'seeders'),
+    verbose: true,
+};
+/**
+ * Get project root directory
+ */
+function getProjectRoot() {
+    return process.cwd();
+}
+/**
+ * Create directory if it doesn't exist
+ */
+function createDirectory(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+        console.log(`Created: ${dirPath}`);
+    }
+    else {
+        console.log(`Exists: ${dirPath}`);
+    }
+}
+/**
+ * Create config file
+ */
+function createConfigFile(configDir) {
+    const configContent = `import { Prorm } from 'ts-prorm-orm';
+
+// Zero-config default: SQLite. Set DB_DIALECT (and related DB_* env vars)
+// to switch to mysql, postgres, or mariadb.
+const prorm = new Prorm({
+  dialect: (process.env.DB_DIALECT as any) || 'sqlite',
+  storage: process.env.DB_STORAGE || './database.sqlite',
+  host: process.env.DB_HOST || 'localhost',
+  port: parseInt(process.env.DB_PORT || '3306'),
+  database: process.env.DB_NAME || 'myapp',
+  username: process.env.DB_USER || 'root',
+  password: process.env.DB_PASSWORD || '',
+  logging: console.log,
+  define: {
+    timestamps: true,
+    underscored: false,
+  },
+});
+
+export default prorm;
+`;
+    const configPath = path.join(configDir, 'config.ts');
+    if (!fs.existsSync(configPath)) {
+        fs.writeFileSync(configPath, configContent);
+        console.log(`Created: ${configPath}`);
+    }
+    else {
+        console.log(`Exists: ${configPath}`);
+    }
+}
+/**
+ * Create models index file
+ */
+function createModelsIndexFile(modelsDir) {
+    const indexContent = `import { DataTypes, Model, Prorm } from 'ts-prorm-orm';
+import prorm from '../config/config';
+
+export { prorm, DataTypes, Model };
+
+// Import models and define associations here
+// Example:
+// import { User } from './user';
+// User.hasMany(Post);
+// Post.belongsTo(User);
+
+export const models = {
+  // Add your models here
+};
+`;
+    const indexPath = path.join(modelsDir, 'index.ts');
+    if (!fs.existsSync(indexPath)) {
+        fs.writeFileSync(indexPath, indexContent);
+        console.log(`Created: ${indexPath}`);
+    }
+    else {
+        console.log(`Exists: ${indexPath}`);
+    }
+}
+/**
+ * Create migrations index file
+ */
+function createMigrationsIndexFile(migrationsDir) {
+    const indexContent = `// Migration files go here
+// Each migration should export 'up' and 'down' functions
+//
+// Example migration:
+// export async function up(queryInterface: any) {
+//   await queryInterface.createTable('users', {
+//     id: {
+//       type: DataTypes.INTEGER,
+//       autoIncrement: true,
+//       primaryKey: true,
+//     },
+//     name: {
+//       type: DataTypes.STRING,
+//       allowNull: false,
+//     },
+//     createdAt: {
+//       type: DataTypes.DATE,
+//       allowNull: false,
+//     },
+//     updatedAt: {
+//       type: DataTypes.DATE,
+//       allowNull: false,
+//     },
+//   });
+// }
+//
+// export async function down(queryInterface: any) {
+//   await queryInterface.dropTable('users');
+// }
+`;
+    const indexPath = path.join(migrationsDir, 'index.ts');
+    if (!fs.existsSync(indexPath)) {
+        fs.writeFileSync(indexPath, indexContent);
+        console.log(`Created: ${indexPath}`);
+    }
+    else {
+        console.log(`Exists: ${indexPath}`);
+    }
+}
+/**
+ * Initialize a new Prorm project
+ */
+function init(options = {}) {
+    const projectRoot = options.directory || getProjectRoot();
+    console.log(`Initializing Prorm project in: ${projectRoot}`);
+    console.log('----------------------------------------');
+    const configDir = path.join(projectRoot, 'config');
+    const modelsDir = path.join(projectRoot, 'models');
+    const migrationsDir = path.join(projectRoot, 'migrations');
+    createDirectory(configDir);
+    createDirectory(modelsDir);
+    createDirectory(migrationsDir);
+    createConfigFile(configDir);
+    createModelsIndexFile(modelsDir);
+    createMigrationsIndexFile(migrationsDir);
+    console.log('----------------------------------------');
+    console.log('Prorm project initialized successfully!');
+    console.log('');
+    console.log('Next steps:');
+    console.log('  1. Update config/config.ts with your database credentials');
+    console.log('  2. Add your models in the models/ directory');
+    console.log('  3. Run migrations using your migration tool');
+}
+// ============================================
+// Migration CLI Commands
+// ============================================
+/**
+ * Print colored console output
+ */
+function log(message, type = 'info') {
+    const colors = {
+        info: '\x1b[36m', // Cyan
+        success: '\x1b[32m', // Green
+        error: '\x1b[31m', // Red
+        warning: '\x1b[33m', // Yellow
+    };
+    const reset = '\x1b[0m';
+    console.log(`${colors[type]}${message}${reset}`);
+}
+/**
+ * Command: db:create
+ * Creates the target database if it does not exist
+ */
+async function dbCreate() {
+    const dbDialect = process.env.DB_DIALECT || process.env.DIALECT || 'sqlite';
+    const dbName = process.env.DB_NAME || process.env.DB_DATABASE || 'database.db';
+    const dbUser = process.env.DB_USER || process.env.DB_USERNAME || '';
+    const dbPass = process.env.DB_PASSWORD || process.env.DB_PASS || '';
+    const dbHost = process.env.DB_HOST || 'localhost';
+    const dbPort = parseInt(process.env.DB_PORT || '5432', 10);
+    log(`Creating database: ${dbName}...`, 'info');
+    try {
+        switch (dbDialect) {
+            case 'sqlite':
+                // SQLite - just verify we can create the file
+                const sqlitePath = path.isAbsolute(dbName) ? dbName : path.join(process.cwd(), dbName);
+                if (!fs.existsSync(sqlitePath)) {
+                    fs.writeFileSync(sqlitePath, ''); // Create empty file
+                    log(`Created SQLite database: ${sqlitePath}`, 'success');
+                }
+                else {
+                    log(`Database already exists: ${sqlitePath}`, 'warning');
+                }
+                break;
+            case 'postgres':
+            case 'postgresql': {
+                // PostgreSQL - connect to postgres system db and create
+                const adminSeq = new prorm_1.Prorm({
+                    dialect: 'postgres',
+                    database: 'postgres',
+                    username: dbUser,
+                    password: dbPass,
+                    host: dbHost,
+                    port: dbPort,
+                    logging: false,
+                });
+                await adminSeq.query(`CREATE DATABASE ${dbName}`);
+                await adminSeq.close();
+                log(`Created PostgreSQL database: ${dbName}`, 'success');
+                break;
+            }
+            case 'mysql': {
+                // MySQL - connect to mysql system db and create
+                const adminSeq = new prorm_1.Prorm({
+                    dialect: 'mysql',
+                    database: 'mysql',
+                    username: dbUser,
+                    password: dbPass,
+                    host: dbHost,
+                    port: dbPort,
+                    logging: false,
+                });
+                await adminSeq.query(`CREATE DATABASE \`${dbName}\``);
+                await adminSeq.close();
+                log(`Created MySQL database: ${dbName}`, 'success');
+                break;
+            }
+            case 'mariadb': {
+                // MariaDB - similar to MySQL
+                const adminSeq = new prorm_1.Prorm({
+                    dialect: 'mariadb',
+                    database: 'mysql',
+                    username: dbUser,
+                    password: dbPass,
+                    host: dbHost,
+                    port: dbPort,
+                    logging: false,
+                });
+                await adminSeq.query(`CREATE DATABASE \`${dbName}\``);
+                await adminSeq.close();
+                log(`Created MariaDB database: ${dbName}`, 'success');
+                break;
+            }
+            default:
+                throw new Error(`Unsupported dialect: ${dbDialect}`);
+        }
+    }
+    catch (error) {
+        if (error.message?.includes('already exists')) {
+            log(`Database already exists: ${dbName}`, 'warning');
+        }
+        else {
+            log(`Error creating database: ${error.message}`, 'error');
+            throw error;
+        }
+    }
+}
+/**
+ * Command: db:drop
+ * Drops the target database
+ */
+async function dbDrop() {
+    const dbDialect = process.env.DB_DIALECT || process.env.DIALECT || 'sqlite';
+    const dbName = process.env.DB_NAME || process.env.DB_DATABASE || 'database.db';
+    const dbUser = process.env.DB_USER || process.env.DB_USERNAME || '';
+    const dbPass = process.env.DB_PASSWORD || process.env.DB_PASS || '';
+    const dbHost = process.env.DB_HOST || 'localhost';
+    const dbPort = parseInt(process.env.DB_PORT || '5432', 10);
+    log(`Dropping database: ${dbName}...`, 'info');
+    try {
+        switch (dbDialect) {
+            case 'sqlite':
+                // SQLite - just delete the file
+                const sqlitePath = path.isAbsolute(dbName) ? dbName : path.join(process.cwd(), dbName);
+                if (fs.existsSync(sqlitePath)) {
+                    fs.unlinkSync(sqlitePath);
+                    log(`Dropped SQLite database: ${sqlitePath}`, 'success');
+                }
+                else {
+                    log(`Database does not exist: ${sqlitePath}`, 'warning');
+                }
+                break;
+            case 'postgres':
+            case 'postgresql': {
+                // PostgreSQL - connect to postgres system db and drop
+                const adminSeq = new prorm_1.Prorm({
+                    dialect: 'postgres',
+                    database: 'postgres',
+                    username: dbUser,
+                    password: dbPass,
+                    host: dbHost,
+                    port: dbPort,
+                    logging: false,
+                });
+                // Terminate all connections to the database first
+                await adminSeq
+                    .query(`
+          SELECT pg_terminate_backend(pg_stat_activity.pid)
+          FROM pg_stat_activity
+          WHERE pg_stat_activity.datname = '${dbName}'
+          AND pid <> pg_backend_pid()
+        `)
+                    .catch(() => {
+                    /* ignore errors */
+                });
+                await adminSeq.query(`DROP DATABASE IF EXISTS ${dbName}`);
+                await adminSeq.close();
+                log(`Dropped PostgreSQL database: ${dbName}`, 'success');
+                break;
+            }
+            case 'mysql': {
+                // MySQL - connect to mysql system db and drop
+                const adminSeq = new prorm_1.Prorm({
+                    dialect: 'mysql',
+                    database: 'mysql',
+                    username: dbUser,
+                    password: dbPass,
+                    host: dbHost,
+                    port: dbPort,
+                    logging: false,
+                });
+                await adminSeq.query(`DROP DATABASE IF EXISTS \`${dbName}\``);
+                await adminSeq.close();
+                log(`Dropped MySQL database: ${dbName}`, 'success');
+                break;
+            }
+            case 'mariadb': {
+                // MariaDB - similar to MySQL
+                const adminSeq = new prorm_1.Prorm({
+                    dialect: 'mariadb',
+                    database: 'mysql',
+                    username: dbUser,
+                    password: dbPass,
+                    host: dbHost,
+                    port: dbPort,
+                    logging: false,
+                });
+                await adminSeq.query(`DROP DATABASE IF EXISTS \`${dbName}\``);
+                await adminSeq.close();
+                log(`Dropped MariaDB database: ${dbName}`, 'success');
+                break;
+            }
+            default:
+                throw new Error(`Unsupported dialect: ${dbDialect}`);
+        }
+    }
+    catch (error) {
+        log(`Error dropping database: ${error.message}`, 'error');
+        throw error;
+    }
+}
+/**
+ * Load Prorm instance from environment or config
+ */
+async function getProrm() {
+    // Try to load from config file or environment
+    const configPaths = [
+        path.join(process.cwd(), 'config', 'database.js'),
+        path.join(process.cwd(), 'config', 'database.ts'),
+        path.join(process.cwd(), 'database.js'),
+        path.join(process.cwd(), 'database.ts'),
+        path.join(process.cwd(), '.env'),
+    ];
+    let prorm = null;
+    // Check for environment variables first
+    const databaseUrl = process.env.DATABASE_URL || process.env.DATABASE;
+    const dbDialect = process.env.DB_DIALECT || process.env.DIALECT || 'sqlite';
+    const dbName = process.env.DB_NAME || process.env.DB_DATABASE || 'database.db';
+    const dbUser = process.env.DB_USER || process.env.DB_USERNAME || '';
+    const dbPass = process.env.DB_PASSWORD || process.env.DB_PASS || '';
+    const dbHost = process.env.DB_HOST || 'localhost';
+    const dbPort = parseInt(process.env.DB_PORT || '5432', 10);
+    if (databaseUrl) {
+        // Parse database URL (e.g., postgres://user:pass@localhost:5432/db)
+        const url = new URL(databaseUrl);
+        // Normalize protocol to a supported Dialect (e.g. 'postgresql' -> 'postgres')
+        const urlDialect = url.protocol.replace(':', '');
+        prorm = new prorm_1.Prorm({
+            dialect: (urlDialect === 'postgresql' ? 'postgres' : urlDialect),
+            database: url.pathname.replace('/', ''),
+            username: url.username,
+            password: url.password,
+            host: url.hostname,
+            port: parseInt(url.port, 10) || 5432,
+            logging: false,
+        });
+    }
+    else {
+        // Create based on dialect
+        switch (dbDialect) {
+            case 'sqlite':
+                prorm = new prorm_1.Prorm({
+                    dialect: 'sqlite',
+                    storage: dbName,
+                    logging: false,
+                });
+                break;
+            case 'postgres':
+            case 'postgresql':
+                prorm = new prorm_1.Prorm({
+                    dialect: 'postgres',
+                    host: dbHost,
+                    port: dbPort,
+                    database: dbName,
+                    username: dbUser,
+                    password: dbPass,
+                    logging: false,
+                });
+                break;
+            case 'mysql':
+                prorm = new prorm_1.Prorm({
+                    dialect: 'mysql',
+                    host: dbHost,
+                    port: dbPort,
+                    database: dbName,
+                    username: dbUser,
+                    password: dbPass,
+                    logging: false,
+                });
+                break;
+            case 'mariadb':
+                prorm = new prorm_1.Prorm({
+                    dialect: 'mariadb',
+                    host: dbHost,
+                    port: dbPort,
+                    database: dbName,
+                    username: dbUser,
+                    password: dbPass,
+                    logging: false,
+                });
+                break;
+            default:
+                throw new Error(`Unsupported dialect: ${dbDialect}`);
+        }
+    }
+    // Establish the connection, then test it. `authenticate()` requires
+    // `connect()` to have been called first (it throws "Database connection
+    // not established" otherwise), so both steps are needed here.
+    try {
+        await prorm.connect();
+        await prorm.authenticate();
+        log('Database connection established', 'success');
+    }
+    catch (error) {
+        log(`Failed to connect to database: ${error}`, 'error');
+        throw error;
+    }
+    return prorm;
+}
+/**
+ * Ensure migrations directory exists
+ */
+function ensureMigrationsDir(migrationsPath) {
+    if (!fs.existsSync(migrationsPath)) {
+        fs.mkdirSync(migrationsPath, { recursive: true });
+        log(`Created migrations directory: ${migrationsPath}`, 'success');
+    }
+}
+/**
+ * Command: migration:create
+ * Creates a new migration file
+ */
+async function migrationCreate(name, config) {
+    if (!name) {
+        log('Error: Migration name is required. Usage: --name <migration-name>', 'error');
+        process.exit(1);
+    }
+    ensureMigrationsDir(config.migrationsPath);
+    const filepath = (0, migrations_1.createMigration)(name, { path: config.migrationsPath });
+    log(`Migration created successfully: ${path.basename(filepath)}`, 'success');
+}
+/**
+ * Command: migration:run
+ * Runs pending migrations
+ */
+async function migrationRun(options, config) {
+    const prorm = await getProrm();
+    const migrator = (0, migrations_1.createMigrator)({
+        prorm,
+        path: config.migrationsPath,
+    });
+    try {
+        // Sync migrations table
+        await migrator.syncMigrationsTable();
+        const migrationName = options.name;
+        if (migrationName) {
+            // Run specific migration
+            log(`Running migration: ${migrationName}...`, 'info');
+            const result = await migrator.up({ migration: migrationName });
+            if (result.executed > 0) {
+                log(`Migration "${migrationName}" executed successfully`, 'success');
+            }
+            else {
+                log(`Migration "${migrationName}" already applied or not found`, 'warning');
+            }
+        }
+        else {
+            // Run all pending migrations
+            const pending = await migrator.pending();
+            if (pending.length === 0) {
+                log('No pending migrations to run', 'info');
+                return;
+            }
+            log(`Running ${pending.length} pending migration(s)...`, 'info');
+            const result = await migrator.up();
+            log(`Executed ${result.executed} migration(s)`, 'success');
+            if (config.verbose && result.migrations.length > 0) {
+                result.migrations.forEach((name) => {
+                    console.log(`  - ${name}`);
+                });
+            }
+        }
+    }
+    finally {
+        await prorm.close();
+    }
+}
+/**
+ * Command: migration:revert
+ * Reverts migrations
+ */
+async function migrationRevert(options, config) {
+    const prorm = await getProrm();
+    const migrator = (0, migrations_1.createMigrator)({
+        prorm,
+        path: config.migrationsPath,
+    });
+    try {
+        // Sync migrations table
+        await migrator.syncMigrationsTable();
+        const migrationName = options.name;
+        const steps = options.steps ? parseInt(options.steps, 10) : undefined;
+        if (migrationName) {
+            // Revert specific migration
+            log(`Reverting migration: ${migrationName}...`, 'info');
+            const result = await migrator.down({ migration: migrationName });
+            if (result.reverted > 0) {
+                log(`Migration "${migrationName}" reverted successfully`, 'success');
+            }
+            else {
+                log(`Migration "${migrationName}" not found or not applied`, 'warning');
+            }
+        }
+        else if (steps !== undefined) {
+            // Revert N migrations
+            log(`Reverting ${steps} migration(s)...`, 'info');
+            const result = await migrator.down({ steps });
+            log(`Reverted ${result.reverted} migration(s)`, 'success');
+            if (config.verbose && result.migrations.length > 0) {
+                result.migrations.forEach((name) => {
+                    console.log(`  - ${name}`);
+                });
+            }
+        }
+        else {
+            // Revert last migration
+            const executed = await migrator.executed();
+            if (executed.length === 0) {
+                log('No migrations to revert', 'info');
+                return;
+            }
+            log('Reverting last migration...', 'info');
+            const result = await migrator.down();
+            log(`Reverted ${result.reverted} migration(s)`, 'success');
+            if (config.verbose && result.migrations.length > 0) {
+                result.migrations.forEach((name) => {
+                    console.log(`  - ${name}`);
+                });
+            }
+        }
+    }
+    finally {
+        await prorm.close();
+    }
+}
+/**
+ * Command: migration:status
+ * Shows migration status
+ */
+async function migrationStatus(config) {
+    const prorm = await getProrm();
+    const migrator = (0, migrations_1.createMigrator)({
+        prorm,
+        path: config.migrationsPath,
+    });
+    try {
+        // Sync migrations table
+        await migrator.syncMigrationsTable();
+        const statuses = await migrator.status();
+        if (statuses.length === 0) {
+            log('No migrations found', 'warning');
+            return;
+        }
+        console.log('\nMigration Status:');
+        console.log('================');
+        const pending = statuses.filter((s) => s.status === 'pending');
+        const executed = statuses.filter((s) => s.status === 'up');
+        // Show executed migrations first
+        if (executed.length > 0) {
+            console.log('\nExecuted Migrations:');
+            executed.forEach((s) => {
+                const batch = s.batch ? `[Batch ${s.batch}]` : '';
+                console.log(`  [UP] ${s.name} ${batch}`);
+            });
+        }
+        // Show pending migrations
+        if (pending.length > 0) {
+            console.log('\nPending Migrations:');
+            pending.forEach((s) => {
+                console.log(`  [DOWN] ${s.name}`);
+            });
+        }
+        console.log('\n----------------');
+        console.log(`Total: ${statuses.length} (${executed.length} executed, ${pending.length} pending)`);
+        console.log('');
+    }
+    finally {
+        await prorm.close();
+    }
+}
+// ==================== Seeder CLI Functions ====================
+/**
+ * Ensure seeders directory exists
+ */
+function ensureSeedersDir(seedersPath) {
+    if (!fs.existsSync(seedersPath)) {
+        fs.mkdirSync(seedersPath, { recursive: true });
+        log('Created seeders directory: ' + seedersPath, 'success');
+    }
+}
+/**
+ * Command: seeder:create
+ * Creates a new seeder file
+ */
+async function seederCreate(name, config) {
+    if (!name) {
+        log('Error: Seeder name is required. Usage: --name <seeder-name>', 'error');
+        process.exit(1);
+    }
+    ensureSeedersDir(config.seedersPath);
+    const timestamp = Date.now();
+    const filepath = config.seedersPath + '/' + timestamp + '-' + name + '.js';
+    const tmpl = 'module.exports = { up: async (q,s)=>{}, down: async (q,s)=>{} };';
+    fs.writeFileSync(filepath, tmpl);
+    log('Seeder created: ' + filepath, 'success');
+}
+/**
+ * Command: db:seed
+ * Runs all pending seeders, or a single one when --name is given.
+ * --env <name> restricts to seeders whose `env` field matches (or have none).
+ * --force (only valid together with --name) re-runs a seeder even if it was
+ * already recorded as executed.
+ */
+async function dbSeed(options, config) {
+    const prorm = await getProrm();
+    const sr = new seeder_1.SeederRunner(prorm, { seedersPath: config.seedersPath });
+    try {
+        await sr.ensureSeedsTable();
+        const ran = await sr.runSeeders(config.seedersPath, {
+            only: options.name,
+            env: options.env || process.env.NODE_ENV,
+            force: Boolean(options.force),
+        });
+        log('Executed ' + ran.length + ' seeder(s)', 'success');
+        if (config.verbose && ran.length > 0) {
+            ran.forEach(function (name) {
+                console.log('  - ' + name);
+            });
+        }
+    }
+    finally {
+        await prorm.close();
+    }
+}
+/**
+ * Command: db:seed:undo
+ * Undoes a single seeder: the one named by --name, or the most recently
+ * executed one if no --name is given. Use db:seed:undo:all to undo every
+ * executed seeder in reverse order.
+ */
+async function dbSeedUndo(options, config) {
+    const prorm = await getProrm();
+    const sr = new seeder_1.SeederRunner(prorm, { seedersPath: config.seedersPath });
+    try {
+        await sr.ensureSeedsTable();
+        if (options.name) {
+            await sr.undoSeeder(options.name);
+            log('Seeder undone: ' + options.name, 'success');
+        }
+        else {
+            const executed = await sr.getExecutedSeeds();
+            if (executed.length === 0) {
+                log('No executed seeders to undo', 'info');
+            }
+            else {
+                const last = executed[executed.length - 1];
+                await sr.undoSeeder();
+                log('Seeder undone: ' + last, 'success');
+            }
+        }
+    }
+    finally {
+        await prorm.close();
+    }
+}
+/**
+ * Command: db:seed:undo:all
+ * Undoes every executed seeder, in reverse execution order.
+ */
+async function dbSeedUndoAll(config) {
+    const prorm = await getProrm();
+    const sr = new seeder_1.SeederRunner(prorm, { seedersPath: config.seedersPath });
+    try {
+        await sr.ensureSeedsTable();
+        await sr.undoAllSeeders();
+        log('All seeders undone', 'success');
+    }
+    finally {
+        await prorm.close();
+    }
+}
+/**
+ * Command: db:seed:status
+ * Shows seeder status
+ */
+async function dbSeedStatus(config) {
+    const prorm = await getProrm();
+    const sr = new seeder_1.SeederRunner(prorm, { seedersPath: config.seedersPath });
+    try {
+        await sr.ensureSeedsTable();
+        const statuses = await sr.getSeedStatus();
+        console.log('\nSeeder Status:');
+        console.log('=============');
+        const pending = statuses.filter((s) => s.status === 'pending');
+        const executed = statuses.filter((s) => s.status === 'executed');
+        if (executed.length > 0) {
+            console.log('\nExecuted Seeders:');
+            executed.forEach((s) => console.log('  [UP] ' + s.name));
+        }
+        if (pending.length > 0) {
+            console.log('\nPending Seeders:');
+            pending.forEach((s) => console.log('  [DOWN] ' + s.name));
+        }
+        console.log('\n----------------');
+        console.log('Total: ' +
+            statuses.length +
+            ' (' +
+            executed.length +
+            ' executed, ' +
+            pending.length +
+            ' pending)');
+    }
+    finally {
+        await prorm.close();
+    }
+}
+// ─── Diagram CLI handlers ────────────────────────────────────────────────────
+/**
+ * Parse named CLI flags from an argv array.
+ *   --flag value   → { flag: 'value' }
+ *   --flag         → { flag: true }
+ */
+function parseFlags(args) {
+    const flags = {};
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a.startsWith('--')) {
+            const key = a.slice(2);
+            const next = args[i + 1];
+            if (next && !next.startsWith('--')) {
+                flags[key] = next;
+                i++;
+            }
+            else {
+                flags[key] = true;
+            }
+        }
+    }
+    return flags;
+}
+/**
+ * Command: diagram:model
+ *
+ * Generates a single-model SVG card.
+ *
+ * Reads model spec from --file <json> or falls back to a minimal stub
+ * using --name <ModelName>.
+ *
+ *   cli diagram:model --file ./User.json --out ./diagrams/User.svg
+ *   cli diagram:model --name Order       --out ./diagrams/Order.svg
+ */
+async function diagramModel(args) {
+    const flags = parseFlags(args);
+    const file = flags.file;
+    const outArg = flags.out;
+    const name = flags.name;
+    const theme = flags.theme;
+    const color = flags.color;
+    const db = flags.db;
+    const table = flags.table;
+    let opts;
+    // Option 1: Generate from database
+    if (db) {
+        try {
+            const tables = await getDbSchema(db);
+            const models = schemaToModels(tables);
+            if (table) {
+                // Generate single table diagram
+                const model = models.find((m) => m.tableName === table || m.name.toLowerCase() === table.toLowerCase());
+                if (!model) {
+                    log(`Table "${table}" not found in database`, 'error');
+                    process.exit(1);
+                }
+                opts = model;
+            }
+            else if (name) {
+                const model = models.find((m) => m.name.toLowerCase() === name.toLowerCase());
+                if (!model) {
+                    log(`Model "${name}" not found in database`, 'error');
+                    process.exit(1);
+                }
+                opts = model;
+            }
+            else {
+                log('diagram:model --db requires --table <name> or --name <ModelName>', 'error');
+                process.exit(1);
+            }
+        }
+        catch (err) {
+            log(`Database connection failed: ${err.message}`, 'error');
+            process.exit(1);
+        }
+    }
+    else if (file) {
+        // Option 2: Load from JSON file
+        const specPath = path.resolve(file);
+        if (!fs.existsSync(specPath)) {
+            log(`Spec file not found: ${specPath}`, 'error');
+            process.exit(1);
+        }
+        opts = JSON.parse(fs.readFileSync(specPath, 'utf-8'));
+        log(`Loaded model spec from ${specPath}`, 'info');
+    }
+    else if (name) {
+        // Option 3: Minimal stub
+        opts = { name, fields: {} };
+        log(`No --file provided — rendering empty model "${name}"`, 'warning');
+    }
+    else {
+        log('diagram:model requires --file <path> or --db <connection-string>', 'error');
+        process.exit(1);
+    }
+    // Apply colorful options from CLI
+    if (theme && ['light', 'dark'].includes(theme)) {
+        opts.theme = theme;
+        log(`Using theme: ${theme}`, 'info');
+    }
+    if (color) {
+        opts.color = color;
+        log(`Using accent color: ${color}`, 'info');
+    }
+    const defaultOut = path.join(process.cwd(), 'diagrams', `${opts.name}.svg`);
+    const outPath = outArg ? path.resolve(outArg) : defaultOut;
+    const diag = new diagrams_1.ModelDiagram(opts);
+    const saved = diag.save(outPath);
+    log(`✔  Model diagram saved → ${saved}`, 'success');
+}
+/**
+ * Command: diagram:er
+ *
+ * Generates a full ER diagram SVG from a schema JSON file.
+ *
+ * Schema JSON format:
+ *   {
+ *     "title": "My Schema",
+ *     "columns": 3,
+ *     "models": [ <model-spec>, ... ]
+ *   }
+ *
+ *   cli diagram:er --file ./schema.json --out ./diagrams/er.svg
+ *   cli diagram:er --file ./schema.json --title "Blog Schema" --columns 2
+ */
+async function diagramER(args) {
+    const flags = parseFlags(args);
+    const file = flags.file;
+    const outArg = flags.out;
+    const titleFlag = flags.title;
+    const colsFlag = flags.columns;
+    const theme = flags.theme;
+    const color = flags.color;
+    const db = flags.db;
+    let schema;
+    // Option 1: Generate from database
+    if (db) {
+        try {
+            const tables = await getDbSchema(db);
+            const models = schemaToModels(tables);
+            schema = {
+                title: 'Database Schema',
+                columns: parseInt(colsFlag ?? '', 10) || 3,
+                models,
+            };
+            log(`Generated ER diagram from database (${models.length} tables)`, 'info');
+        }
+        catch (err) {
+            log(`Database connection failed: ${err.message}`, 'error');
+            process.exit(1);
+        }
+    }
+    else if (file) {
+        // Option 2: Load from JSON file
+        const schemaPath = path.resolve(file);
+        if (!fs.existsSync(schemaPath)) {
+            log(`Schema file not found: ${schemaPath}`, 'error');
+            process.exit(1);
+        }
+        const raw = fs.readFileSync(schemaPath, 'utf-8');
+        schema = JSON.parse(raw);
+        log(`Loaded ER schema from ${schemaPath} (${schema.models.length} models)`, 'info');
+    }
+    else {
+        log('diagram:er requires --file <schema.json> or --db <connection-string>', 'error');
+        process.exit(1);
+    }
+    // Allow CLI overrides
+    if (titleFlag)
+        schema.title = titleFlag;
+    if (colsFlag)
+        schema.columns = parseInt(colsFlag, 10);
+    if (theme)
+        schema.theme = theme;
+    if (color)
+        schema.color = color;
+    const defaultOut = path.join(process.cwd(), 'diagrams', 'er-diagram.svg');
+    const outPath = outArg ? path.resolve(outArg) : defaultOut;
+    const er = new diagrams_1.ERDiagram(schema);
+    const saved = er.save(outPath);
+    log(`✔  ER diagram saved → ${saved}`, 'success');
+    log(`   Models rendered: ${schema.models.map((m) => m.name).join(', ')}`, 'info');
+}
+/**
+ * Command: diagram:migration
+ *
+ * Generates a migration diagram SVG showing schema changes.
+ *
+ * Migration JSON format:
+ *   {
+ *     "title": "Add email verification",
+ *     "description": "Add email verification fields to users",
+ *     "timestamp": "2024-01-15T10:30:00Z",
+ *     "changes": [
+ *       { "table": "users", "type": "modify", "changes": [
+ *         { "name": "emailVerified", "type": "BOOLEAN", "action": "add" },
+ *         { "name": "verifiedAt", "type": "DATE", "action": "add" }
+ *       ]},
+ *       { "table": "sessions", "type": "add", "changes": [
+ *         { "name": "id", "type": "UUID", "action": "add" },
+ *         { "name": "userId", "type": "UUID", "action": "add" }
+ *       ]}
+ *     ]
+ *   }
+ *
+ *   cli diagram:migration --file ./migration.json --out ./diagrams/migration.svg
+ *   cli diagram:migration --file ./migration.json --title "User Migration"
+ */
+function diagramMigration(args) {
+    const flags = parseFlags(args);
+    const file = flags.file;
+    const outArg = flags.out;
+    const titleFlag = flags.title;
+    const descFlag = flags.description;
+    if (!file) {
+        log('diagram:migration requires --file <migration.json>', 'error');
+        log('Migration format: { "title":"…", "description":"…", "changes": [ { "table":"...", "type":"add|modify|remove", "changes": [...] } ] }', 'info');
+        process.exit(1);
+    }
+    const migrationPath = path.resolve(file);
+    if (!fs.existsSync(migrationPath)) {
+        log(`Migration file not found: ${migrationPath}`, 'error');
+        process.exit(1);
+    }
+    const raw = fs.readFileSync(migrationPath, 'utf-8');
+    const opts = JSON.parse(raw);
+    log(`Loaded migration from ${migrationPath} (${opts.changes.length} table changes)`, 'info');
+    // CLI overrides
+    if (titleFlag)
+        opts.title = titleFlag;
+    if (descFlag)
+        opts.description = descFlag;
+    const defaultOut = path.join(process.cwd(), 'diagrams', 'migration.svg');
+    const outPath = outArg ? path.resolve(outArg) : defaultOut;
+    const diag = new diagrams_1.MigrationDiagram(opts);
+    const saved = diag.save(outPath);
+    log(`✔  Migration diagram saved → ${saved}`, 'success');
+    log(`   Changes: ${opts.changes.map((c) => `${c.type} ${c.table}`).join(', ')}`, 'info');
+}
+/**
+ * Extended visualizer generators — each renders its own JSON spec to SVG.
+ * Every one accepts `theme`/`color`/(most) `title` in its options, so the
+ * generic handler wires the matching CLI flags through.
+ */
+const EXTRA_DIAGRAMS = {
+    class: diagrams_1.ClassDiagram,
+    relational: diagrams_1.RelationalDiagram,
+    sequence: diagrams_1.SequenceDiagram,
+    state: diagrams_1.StateDiagram,
+    dependency: diagrams_1.DependencyDiagram,
+    schemadoc: diagrams_1.SchemaDocDiagram,
+    index: diagrams_1.IndexDiagram,
+    flow: diagrams_1.FlowDiagram,
+    tree: diagrams_1.TreeDiagram,
+    chen: diagrams_1.ChenDiagram,
+    package: diagrams_1.PackageDiagram,
+    gantt: diagrams_1.GanttDiagram,
+};
+/**
+ * Command: diagram:<type> for the extended visualizers (class, relational,
+ * sequence, state, dependency, schemadoc, index, flow, tree, chen, package,
+ * gantt). Reads the generator's options from --file <json>, applies
+ * --theme/--color/--title, and writes the SVG to --out.
+ *
+ *   cli diagram:class      --file ./classes.json    --out ./diagrams/classes.svg
+ *   cli diagram:relational --file ./schema.json     --out ./diagrams/erd.svg --theme dark
+ *   cli diagram:gantt      --file ./plan.json        --out ./diagrams/plan.svg --color emerald
+ */
+function diagramGeneric(type, args) {
+    const Ctor = EXTRA_DIAGRAMS[type];
+    if (!Ctor) {
+        log(`Unknown diagram type: ${type}`, 'error');
+        process.exit(1);
+    }
+    const flags = parseFlags(args);
+    const file = flags.file;
+    const outArg = flags.out;
+    const theme = flags.theme;
+    const color = flags.color;
+    const title = flags.title;
+    if (!file) {
+        log(`diagram:${type} requires --file <spec.json>`, 'error');
+        process.exit(1);
+    }
+    const specPath = path.resolve(file);
+    if (!fs.existsSync(specPath)) {
+        log(`Spec file not found: ${specPath}`, 'error');
+        process.exit(1);
+    }
+    const opts = JSON.parse(fs.readFileSync(specPath, 'utf-8'));
+    log(`Loaded ${type} spec from ${specPath}`, 'info');
+    if (theme && ['light', 'dark'].includes(theme)) {
+        opts.theme = theme;
+        log(`Using theme: ${theme}`, 'info');
+    }
+    if (color) {
+        opts.color = color;
+        log(`Using accent color: ${color}`, 'info');
+    }
+    if (title && opts.title === undefined)
+        opts.title = title;
+    const defaultOut = path.join(process.cwd(), 'diagrams', `${type}.svg`);
+    const outPath = outArg ? path.resolve(outArg) : defaultOut;
+    const saved = new Ctor(opts).save(outPath);
+    log(`✔  ${type} diagram saved → ${saved}`, 'success');
+}
+/**
+ * Map SQL column types to DataTypes (used by model:create introspection)
+ */
+function mapColumnType(sqlType) {
+    const typeUpper = sqlType.toUpperCase();
+    const varcharMatch = typeUpper.match(/VARCHAR\((\d+)\)/);
+    if (varcharMatch) {
+        return `DataTypes.STRING(${varcharMatch[1]})`;
+    }
+    const charMatch = typeUpper.match(/CHAR\((\d+)\)/);
+    if (charMatch) {
+        return `DataTypes.CHAR(${charMatch[1]})`;
+    }
+    const decimalMatch = typeUpper.match(/DECIMAL\((\d+),(\d+)\)/);
+    if (decimalMatch) {
+        return `DataTypes.DECIMAL(${decimalMatch[1]}, ${decimalMatch[2]})`;
+    }
+    const floatMatch = typeUpper.match(/FLOAT\((\d+),(\d+)\)/);
+    if (floatMatch) {
+        return `DataTypes.FLOAT({ precision: ${floatMatch[1]}, decimals: ${floatMatch[2]} })`;
+    }
+    if (typeUpper.includes('INT')) {
+        if (typeUpper.includes('TINYINT'))
+            return 'DataTypes.TINYINT()';
+        if (typeUpper.includes('SMALLINT'))
+            return 'DataTypes.SMALLINT()';
+        if (typeUpper.includes('MEDIUMINT'))
+            return 'DataTypes.MEDIUMINT()';
+        if (typeUpper.includes('BIGINT'))
+            return 'DataTypes.BIGINT()';
+        return 'DataTypes.INTEGER()';
+    }
+    if (typeUpper === 'TEXT' || typeUpper.includes('TEXT')) {
+        if (typeUpper.includes('TINY'))
+            return 'DataTypes.TEXT("tiny")';
+        if (typeUpper.includes('MEDIUM'))
+            return 'DataTypes.TEXT("medium")';
+        if (typeUpper.includes('LONG'))
+            return 'DataTypes.TEXT("long")';
+        return 'DataTypes.TEXT()';
+    }
+    if (typeUpper === 'FLOAT' || typeUpper.includes('FLOAT'))
+        return 'DataTypes.FLOAT()';
+    if (typeUpper === 'DOUBLE' || typeUpper.includes('DOUBLE'))
+        return 'DataTypes.DOUBLE()';
+    if (typeUpper.includes('REAL') || typeUpper.includes('PRECISION'))
+        return 'DataTypes.FLOAT()';
+    if (typeUpper.includes('BOOLEAN') || typeUpper.includes('BOOL') || typeUpper === 'INTEGER') {
+        return 'DataTypes.BOOLEAN()';
+    }
+    if (typeUpper.includes('DATETIME') || typeUpper.includes('TIMESTAMP')) {
+        return 'DataTypes.DATE()';
+    }
+    if (typeUpper === 'DATE')
+        return 'DataTypes.DATEONLY()';
+    if (typeUpper === 'TIME')
+        return 'DataTypes.TIME()';
+    if (typeUpper.includes('UUID'))
+        return 'DataTypes.UUID()';
+    if (typeUpper.includes('JSON')) {
+        if (typeUpper.includes('JSONB'))
+            return 'DataTypes.JSONB(true)';
+        return 'DataTypes.JSON(true)';
+    }
+    if (typeUpper.includes('BLOB') || typeUpper.includes('BINARY') || typeUpper.includes('BYTEA')) {
+        if (typeUpper.includes('TINY'))
+            return 'DataTypes.TINYBLOB()';
+        if (typeUpper.includes('MEDIUM'))
+            return 'DataTypes.MEDIUMBLOB()';
+        if (typeUpper.includes('LONG'))
+            return 'DataTypes.LONGBLOB()';
+        return 'DataTypes.BLOB()';
+    }
+    const enumMatch = sqlType.match(/enum\(['"](.+?)['"]/i);
+    if (enumMatch) {
+        const values = enumMatch[1]
+            .split("','")
+            .map((v) => `'${v}'`)
+            .join(', ');
+        return `DataTypes.ENUM(${values})`;
+    }
+    return 'DataTypes.STRING';
+}
+/**
+ * Generate an introspected model file's content from table column metadata.
+ */
+function generateIntrospectedModelFile(tableName, columns, options) {
+    const modelName = options?.modelName || toPascalCase(tableName);
+    const timestamps = options?.timestamps ?? true;
+    const underscored = options?.underscored ?? false;
+    const columnDefinitions = [];
+    const attributes = [];
+    for (const [columnName, colInfo] of Object.entries(columns)) {
+        attributes.push(columnName);
+        const dataTypeStr = mapColumnType(colInfo.type);
+        const parts = [`type: ${dataTypeStr}`];
+        if (!colInfo.allowNull) {
+            parts.push('allowNull: false');
+        }
+        if (colInfo.defaultValue !== null && colInfo.defaultValue !== undefined) {
+            const defaultVal = colInfo.defaultValue;
+            if (typeof defaultVal === 'string') {
+                if (defaultVal.toLowerCase() === 'null') {
+                    // Don't add null as default
+                }
+                else if (defaultVal.includes('(')) {
+                    parts.push(`defaultValue: prorm.literal('${defaultVal}')`);
+                }
+                else {
+                    parts.push(`defaultValue: '${defaultVal}'`);
+                }
+            }
+            else if (typeof defaultVal === 'number') {
+                parts.push(`defaultValue: ${defaultVal}`);
+            }
+            else if (typeof defaultVal === 'boolean') {
+                parts.push(`defaultValue: ${defaultVal}`);
+            }
+        }
+        if (colInfo.primaryKey) {
+            parts.push('primaryKey: true');
+        }
+        if (colInfo.autoIncrement) {
+            parts.push('autoIncrement: true');
+        }
+        columnDefinitions.push(`  ${columnName}: { ${parts.join(', ')} }`);
+    }
+    const tableNameStr = underscored ? toSnakeCase(tableName) : tableName;
+    return `/**
+ * Auto-generated model for ${tableName}
+ * Generated by CLI model:create command
+ */
+
+import { DataTypes, Prorm } from 'ts-prorm-orm';
+
+/**
+ * Attributes for the ${modelName} model.
+ */
+export interface ${modelName}Attributes {
+  ${attributes.map((attr) => `${attr}?: any;`).join('\n  ')}
+}
+
+/**
+ * Registered ${modelName} model. Populated by init${modelName}().
+ */
+export let ${modelName}: ReturnType<Prorm['define']>;
+
+/**
+ * Register the ${modelName} model with a Prorm instance.
+ */
+export function init${modelName}(prorm: Prorm): ReturnType<Prorm['define']> {
+  ${modelName} = prorm.define<${modelName}Attributes>(
+    '${modelName}',
+    {
+${columnDefinitions.join(',\n')},
+    },
+    {
+      tableName: '${tableNameStr}',
+      ${timestamps ? 'timestamps: true,' : 'timestamps: false,'}
+      ${underscored ? 'underscored: true,' : ''}
+    }
+  );
+
+  return ${modelName};
+}
+
+export default init${modelName};
+`;
+}
+/**
+ * Convert string to PascalCase
+ */
+function toPascalCase(str) {
+    return str
+        .replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase())
+        .replace(/^[a-z]/, (chr) => chr.toUpperCase());
+}
+/**
+ * Convert string to snake_case
+ */
+function toSnakeCase(str) {
+    return str
+        .replace(/([A-Z])/g, '_$1')
+        .replace(/[^a-zA-Z0-9]+/g, '_')
+        .replace(/^_|_$/g, '')
+        .toLowerCase();
+}
+/**
+ * Parse command line arguments for model:create (DB introspection)
+ */
+function parseModelCreateArgs(args) {
+    const options = {
+        dialect: 'sqlite',
+        database: '',
+        outDir: './models',
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        const nextArg = args[i + 1];
+        if (arg === '--dialect' && nextArg) {
+            options.dialect = nextArg;
+            i++;
+        }
+        else if (arg === '--database' && nextArg) {
+            options.database = nextArg;
+            i++;
+        }
+        else if (arg === '--username' && nextArg) {
+            options.username = nextArg;
+            i++;
+        }
+        else if (arg === '--password' && nextArg) {
+            options.password = nextArg;
+            i++;
+        }
+        else if (arg === '--host' && nextArg) {
+            options.host = nextArg;
+            i++;
+        }
+        else if (arg === '--port' && nextArg) {
+            options.port = parseInt(nextArg, 10);
+            i++;
+        }
+        else if (arg === '--storage' && nextArg) {
+            options.storage = nextArg;
+            i++;
+        }
+        else if (arg === '--out-dir' && nextArg) {
+            options.outDir = nextArg;
+            i++;
+        }
+        else if (arg === '--table' && nextArg) {
+            options.table = nextArg;
+            i++;
+        }
+    }
+    return options;
+}
+/**
+ * Command: model:create
+ * Generate model files from live database table introspection.
+ */
+async function modelCreateCommand(args) {
+    const options = parseModelCreateArgs(args);
+    if (!options.database) {
+        log('Error: --database is required', 'error');
+        log('Usage: orm-cli model:create --dialect sqlite --database ./mydb.sqlite', 'info');
+        process.exit(1);
+    }
+    log(`\n=== Model Generator ===`, 'info');
+    log(`Dialect: ${options.dialect}`, 'info');
+    log(`Database: ${options.database}`, 'info');
+    log(`Output: ${options.outDir}\n`, 'info');
+    const prormConfig = {
+        dialect: options.dialect,
+        logging: false,
+    };
+    if (options.dialect === 'sqlite') {
+        prormConfig.storage = options.storage || options.database;
+    }
+    else {
+        prormConfig.host = options.host || 'localhost';
+        prormConfig.database = options.database;
+        prormConfig.username = options.username || 'root';
+        prormConfig.password = options.password || '';
+        if (options.port) {
+            prormConfig.port = options.port;
+        }
+    }
+    let prorm;
+    try {
+        prorm = new prorm_1.Prorm(prormConfig);
+        await prorm.connect();
+        log('Database connection established.\n', 'success');
+    }
+    catch (error) {
+        log(`Error: Unable to connect to database: ${error.message}`, 'error');
+        process.exit(1);
+    }
+    try {
+        const tables = await prorm.showTables();
+        const targetTables = options.table ? [options.table] : tables;
+        if (targetTables.length === 0) {
+            log('No tables found in database.', 'warning');
+            await prorm.close();
+            return;
+        }
+        log(`Found ${targetTables.length} table(s): ${targetTables.join(', ')}\n`, 'info');
+        const outDir = path.resolve(options.outDir || './models');
+        if (!fs.existsSync(outDir)) {
+            fs.mkdirSync(outDir, { recursive: true });
+            log(`Created output directory: ${outDir}\n`, 'success');
+        }
+        const generatedFiles = [];
+        for (const tableName of targetTables) {
+            if (!tables.includes(tableName)) {
+                log(`Warning: Table '${tableName}' does not exist, skipping.`, 'warning');
+                continue;
+            }
+            log(`Generating model for table: ${tableName}`, 'info');
+            const tableDescription = await prorm.describeTable(tableName);
+            const modelContent = generateIntrospectedModelFile(tableName, tableDescription);
+            const modelName = toPascalCase(tableName);
+            const fileName = `${modelName}.ts`;
+            const filePath = path.join(outDir, fileName);
+            fs.writeFileSync(filePath, modelContent, 'utf-8');
+            generatedFiles.push(fileName);
+            log(`  Created: ${filePath}`, 'success');
+        }
+        log(`\n=== Generation Complete ===\n`, 'success');
+        log(`Generated ${generatedFiles.length} model file(s):`, 'info');
+        for (const file of generatedFiles) {
+            console.log(`  - ${file}`);
+        }
+        if (generatedFiles.length > 0) {
+            const indexContent = generatedFiles
+                .map((file) => {
+                const modelName = file.replace('.ts', '');
+                return `export { ${modelName}, init${modelName} } from './${modelName}';`;
+            })
+                .join('\n');
+            fs.writeFileSync(path.join(outDir, 'index.ts'), indexContent, 'utf-8');
+            log(`\nCreated index file: ${path.join(outDir, 'index.ts')}`, 'success');
+        }
+        console.log('\n');
+    }
+    catch (error) {
+        log(`Error during model generation: ${error.message}`, 'error');
+        process.exit(1);
+    }
+    finally {
+        await prorm.close();
+        log('Database connection closed.', 'info');
+    }
+}
+// ─── End model:create ────────────────────────────────────────────────────────
+/**
+ * Command: prisma:import
+ * Converts a Prisma schema.prisma file into prorm model files + an initial
+ * migration. Pure translation only (src/prisma-migrate/) — this command
+ * just handles reading the input file and writing the generated output to
+ * disk, and reports the unsupported-feature errors the converter throws
+ * (implicit many-to-many relations, composite foreign keys, unmapped
+ * Prisma scalar types) as a normal CLI error rather than a stack trace.
+ */
+async function prismaImportCommand(options) {
+    const schemaPath = options.schema || './schema.prisma';
+    const modelsOut = options['models-out'] || './models';
+    const migrationsOut = options['migrations-out'] || './migrations';
+    if (!fs.existsSync(schemaPath)) {
+        log(`Error: schema file not found at ${schemaPath}. Usage: prisma:import --schema <path> [--models-out <dir>] [--migrations-out <dir>]`, 'error');
+        process.exit(1);
+        return;
+    }
+    const { convertPrismaSchema } = require('./prisma-migrate');
+    const schemaSource = fs.readFileSync(schemaPath, 'utf-8');
+    let result;
+    try {
+        result = convertPrismaSchema(schemaSource);
+    }
+    catch (error) {
+        log(`Error converting schema: ${error.message}`, 'error');
+        process.exit(1);
+        return;
+    }
+    fs.mkdirSync(modelsOut, { recursive: true });
+    for (const model of result.models) {
+        fs.writeFileSync(path.join(modelsOut, `${model.name}.ts`), model.source);
+        log(`Created model: ${path.join(modelsOut, `${model.name}.ts`)}`, 'success');
+    }
+    fs.writeFileSync(path.join(modelsOut, 'index.ts'), result.modelsIndex);
+    log(`Created model registry: ${path.join(modelsOut, 'index.ts')}`, 'success');
+    fs.mkdirSync(migrationsOut, { recursive: true });
+    const migrationFileName = `${Date.now()}-prisma-import.js`;
+    fs.writeFileSync(path.join(migrationsOut, migrationFileName), result.migration);
+    log(`Created migration: ${path.join(migrationsOut, migrationFileName)}`, 'success');
+    log(`Converted ${result.models.length} model(s) from ${schemaPath}. Review the generated files — see the comment ` +
+        'at the top of the migration file for what was translated on a best-effort basis.', 'info');
+}
+/**
+ * Print the full CLI usage/help text to the console
+ */
+function showHelp() {
+    console.log(`
+ORM CLI Tools
+=============
+
+Usage:
+  orm-cli <command> [options]
+
+Commands:
+  init                   Initialize a new project (config, models, migrations, seeders)
+  model:create           Generate model files from live database introspection
+  migration:create       Create a new migration file
+  migration:run         Run pending migrations
+  migration:revert      Revert migrations
+  migration:status      Show migration status
+  seeder:create         Create a new seeder file
+  db:seed              Run pending seeders (--name to run just one, --env to
+                        scope by environment, --force to re-run with --name)
+  db:seed:undo         Undo one seeder (--name <n>, or the last run if omitted)
+  db:seed:undo:all     Undo all executed seeders, in reverse order
+  db:seed:status       Show seeder status
+  diagram:model        Generate an SVG model diagram
+  diagram:er           Generate an SVG ER diagram for multiple models
+  diagram:migration    Generate an SVG migration diagram
+  diagram:class        Generate a UML class diagram (--file spec.json)
+  diagram:relational   Generate a crow's-foot relational diagram (--file spec.json)
+  diagram:sequence     Generate a UML sequence diagram (--file spec.json)
+  diagram:state        Generate a state-machine diagram (--file spec.json)
+  diagram:dependency   Generate a dependency-graph diagram (--file spec.json)
+  diagram:schemadoc    Generate a data-dictionary sheet (--file spec.json)
+  diagram:index        Generate an index/constraint map (--file spec.json)
+  diagram:flow         Generate a flowchart (--file spec.json)
+  diagram:tree         Generate a tree / mind-map (--file spec.json)
+  diagram:chen         Generate a Chen-notation ER diagram (--file spec.json)
+  diagram:package      Generate a UML package diagram (--file spec.json)
+  diagram:gantt        Generate a gantt / timeline diagram (--file spec.json)
+  prisma:import         Convert a Prisma schema.prisma into prorm models + an initial migration
+
+Options:
+  --name <name>         Migration/model name
+  --steps <n>           Number of migrations to revert
+  --path <path>         Custom migrations directory path
+  --directory <path>    Project directory (for init)
+  --verbose             Show detailed output
+  --help, -h            Show this help message
+
+model:create options:
+  --dialect <dialect>   Database dialect: sqlite, mysql, postgres, mariadb (default: sqlite)
+  --database <name>     Database name or file path (required)
+  --username <user>     Database username (mysql/mariadb/postgres)
+  --password <pass>     Database password (mysql/mariadb/postgres)
+  --host <host>         Database host (default: localhost)
+  --port <port>         Database port
+  --storage <path>      SQLite storage path
+  --out-dir <path>      Output directory for models (default: ./models)
+  --table <name>        Specific table to generate a model for (default: all tables)
+
+Diagram options (diagram:model / diagram:er / diagram:migration):
+  --file <path>         JSON spec file (model/ER schema/migration)
+  --db <conn-string>    Database connection string (generates diagram from DB)
+  --table <name>        Table name for model diagram (with --db)
+  --out <path>          Output SVG file path (default: ./diagrams/<name>.svg)
+  --title <title>       ER/migration diagram title
+  --columns <n>         Number of columns in ER grid layout (default: 3)
+  --theme <theme>       Theme: light or dark (default: light)
+  --color <color>       Accent color: blue, violet, emerald, amber, pink, sky, indigo, purple, red, teal, green
+  --description <desc>  Migration description (diagram:migration only)
+
+prisma:import options:
+  --schema <path>        Path to schema.prisma (default: ./schema.prisma)
+  --models-out <path>    Output directory for generated model files (default: ./models)
+  --migrations-out <path> Output directory for the generated migration (default: ./migrations)
+
+Connection string formats:
+  mysql://user:pass@host:port/database
+  postgres://user:pass@host:port/database
+  sqlite:/path/to/database.db
+  sqlite: (for in-memory database)
+
+Examples:
+  # Initialize a new project
+  cli init
+  cli init --directory ./my-project
+
+  # Generate models from an existing database (introspection)
+  cli model:create --dialect sqlite --database ./mydb.sqlite
+  cli model:create --dialect mysql --database mydb --username root --password secret --table users
+
+  # Create a new migration
+  cli migration:create -- --name create-users-table
+
+  # Convert an existing Prisma project's schema.prisma to prorm
+  cli prisma:import --schema ./schema.prisma --models-out ./src/models --migrations-out ./migrations
+
+  # Run all pending migrations
+  cli migration:run
+
+  # Run a specific migration
+  cli migration:run -- --name 20240315120000-create-users-table
+
+  # Revert the last migration
+  cli migration:revert
+
+  # Revert a specific migration
+  cli migration:revert -- --name 20240315120000-create-users-table
+
+  # Revert last 3 migrations
+  cli migration:revert -- --steps 3
+
+  # Show migration status
+  cli migration:status
+
+  # Use custom migrations path
+  cli migration:run -- --path ./db/migrations
+
+  # Generate a model diagram from a JSON spec
+  cli diagram:model --file ./User.json --out ./diagrams/User.svg
+
+  # Generate an ER diagram from a schema JSON (multiple models)
+  cli diagram:er --file ./schema.json --out ./diagrams/er.svg
+
+  # Inline single-model diagram (no JSON file needed)
+  cli diagram:model --name User --out ./diagrams/User.svg
+
+  # Generate diagram from database (for documentation)
+  cli diagram:er --db sqlite:./database.db --out ./diagrams/schema.svg
+  cli diagram:model --db mysql://root:pass@localhost:3306/mydb --table users --out ./diagrams/User.svg
+  cli diagram:er --db postgres://user:pass@localhost:5432/mydb --title "Production DB" --color violet
+
+  # Extended visualizers — each reads its own JSON spec (--file) and writes SVG (--out)
+  cli diagram:class      --file ./classes.json    --out ./diagrams/classes.svg
+  cli diagram:relational --file ./schema.json     --out ./diagrams/erd.svg --theme dark
+  cli diagram:sequence   --file ./flow.json        --out ./diagrams/sequence.svg
+  cli diagram:state      --file ./lifecycle.json   --out ./diagrams/state.svg
+  cli diagram:dependency --file ./deps.json        --out ./diagrams/deps.svg
+  cli diagram:schemadoc  --file ./schema.json      --out ./diagrams/data-dictionary.svg
+  cli diagram:index      --file ./indexes.json     --out ./diagrams/indexes.svg
+  cli diagram:flow       --file ./pipeline.json    --out ./diagrams/flow.svg
+  cli diagram:tree       --file ./tree.json        --out ./diagrams/tree.svg
+  cli diagram:chen       --file ./entities.json    --out ./diagrams/chen.svg
+  cli diagram:package    --file ./packages.json    --out ./diagrams/packages.svg
+  cli diagram:gantt      --file ./plan.json        --out ./diagrams/plan.svg --color emerald
+
+  # JSON spec format for a single model (User.json):
+  #  {
+  #    "name": "User",
+  #    "tableName": "users",
+  #    "fields": {
+  #      "id":    { "type": "INTEGER", "primaryKey": true, "autoIncrement": true },
+  #      "email": { "type": "VARCHAR(255)", "unique": true, "allowNull": false }
+  #    },
+  #    "associations": [
+  #      { "type": "hasMany", "target": "Post", "foreignKey": "userId" }
+  #    ],
+  #    "timestamps": true
+  #  }
+  #
+  # JSON spec format for an ER diagram (schema.json):
+  #  {
+  #    "title": "My App Schema",
+  #    "columns": 3,
+  #    "models": [ <model-spec>, <model-spec>, ... ]
+  #  }
+
+Environment Variables:
+  DATABASE_URL          Full database URL (e.g., postgres://user:pass@localhost/db)
+  DB_DIALECT            Database dialect: sqlite, postgres, mysql, mariadb
+  DB_NAME               Database name
+  DB_USER               Database username
+  DB_PASSWORD           Database password
+  DB_HOST               Database host (default: localhost)
+  DB_PORT               Database port (default: 5432)
+`);
+}
+/**
+ * Parse command-line arguments for migration commands
+ */
+function parseMigrationArgs(args) {
+    const command = args[0] || 'help';
+    const options = {};
+    // Start at 1, not 2: args[0] is the command itself (e.g. 'migration:create'),
+    // so the first real flag begins at args[1]. Starting at 2 silently dropped
+    // the first flag after the command (e.g. `migration:create --name foo`
+    // lost both `--name` and its value `foo`).
+    for (let i = 1; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith('--')) {
+            const key = arg.slice(2);
+            const nextArg = args[i + 1];
+            if (nextArg && !nextArg.startsWith('--')) {
+                options[key] = nextArg;
+                i++;
+            }
+            else {
+                options[key] = true;
+            }
+        }
+        else if (arg.startsWith('-')) {
+            const key = arg.slice(1);
+            options[key] = true;
+        }
+    }
+    return { command, options };
+}
+/**
+ * Main entry point
+ */
+function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    // Handle init command (original behavior)
+    if (command === 'init') {
+        const dirIndex = args.indexOf('--directory');
+        const directory = dirIndex !== -1 ? args[dirIndex + 1] : undefined;
+        init({ directory });
+        return;
+    }
+    // Handle help
+    if (command === '--help' || command === '-h' || !command) {
+        showHelp();
+        return;
+    }
+    // Build config
+    const config = {
+        ...defaultConfig,
+        migrationsPath: (args.includes('--path') ? args[args.indexOf('--path') + 1] : undefined) ||
+            defaultConfig.migrationsPath,
+        verbose: args.includes('--verbose'),
+    };
+    // Parse migration command
+    const { command: migrationCommand, options } = parseMigrationArgs(args);
+    // Execute migration command asynchronously
+    (async () => {
+        try {
+            switch (migrationCommand) {
+                case 'model:create':
+                    await modelCreateCommand(args.slice(1));
+                    break;
+                case 'migration:create':
+                    await migrationCreate(options.name, config);
+                    break;
+                case 'migration:run':
+                    await migrationRun(options, config);
+                    break;
+                case 'migration:revert':
+                    await migrationRevert(options, config);
+                    break;
+                case 'migration:status':
+                    await migrationStatus(config);
+                    break;
+                case 'db:create':
+                    await dbCreate();
+                    break;
+                case 'db:drop':
+                    await dbDrop();
+                    break;
+                case 'seeder:create':
+                    await seederCreate(options.name, config);
+                    break;
+                case 'db:seed':
+                    await dbSeed(options, config);
+                    break;
+                case 'db:seed:undo':
+                    await dbSeedUndo(options, config);
+                    break;
+                case 'db:seed:undo:all':
+                    await dbSeedUndoAll(config);
+                    break;
+                case 'db:seed:status':
+                    await dbSeedStatus(config);
+                    break;
+                case 'diagram:model':
+                    await diagramModel(args);
+                    break;
+                case 'diagram:er':
+                    await diagramER(args);
+                    break;
+                case 'diagram:migration':
+                    await diagramMigration(args);
+                    break;
+                case 'diagram:class':
+                case 'diagram:relational':
+                case 'diagram:sequence':
+                case 'diagram:state':
+                case 'diagram:dependency':
+                case 'diagram:schemadoc':
+                case 'diagram:index':
+                case 'diagram:flow':
+                case 'diagram:tree':
+                case 'diagram:chen':
+                case 'diagram:package':
+                case 'diagram:gantt':
+                    diagramGeneric(command.slice('diagram:'.length), args);
+                    break;
+                case 'prisma:import':
+                    await prismaImportCommand(options);
+                    break;
+                default:
+                    if (command) {
+                        log(`Unknown command: ${command}`, 'error');
+                    }
+                    showHelp();
+                    process.exit(1);
+            }
+        }
+        catch (error) {
+            log(`Error: ${error.message}`, 'error');
+            process.exit(1);
+        }
+    })();
+}
+// Run if executed directly (not when imported as a module)
+if (require.main === module) {
+    main();
+}