noormme 1.0.0

package/dist/esm/cli/commands/inspect.js

@@ -0,0 +1,363 @@
+/// <reference types="./inspect.d.ts" />
+import chalk from 'chalk';
+import { NOORMME } from '../../noormme.js';
+export async function inspect(tableName, options = {}) {
+    console.log(chalk.blue.bold('\n🔍 NOORMME Schema Inspection - Intelligent Database Discovery\n'));
+    try {
+        // Initialize NOORMME with database path
+        const databasePath = options.database || process.env.DATABASE_PATH || './database.sqlite';
+        const db = new NOORMME({
+            dialect: 'sqlite',
+            connection: {
+                database: databasePath,
+                host: 'localhost',
+                port: 0,
+                username: '',
+                password: ''
+            }
+        });
+        await db.initialize();
+        console.log(chalk.gray(`📁 Database: ${databasePath}\n`));
+        const schemaInfo = await db.getSchemaInfo();
+        if (tableName) {
+            // Show specific table with automation insights
+            const table = schemaInfo.tables.find(t => t.name === tableName);
+            if (!table) {
+                console.error(chalk.red(`❌ Table '${tableName}' not found`));
+                console.log(chalk.gray('Available tables:'));
+                schemaInfo.tables.forEach(t => console.log(chalk.gray(`  - ${t.name}`)));
+                process.exit(1);
+            }
+            showTableDetails(table, schemaInfo.relationships, db);
+            // Show automation insights for the table
+            if (options.optimizations) {
+                await showTableOptimizations(table, db);
+            }
+            if (options.indexes) {
+                await showTableIndexAnalysis(table, db);
+            }
+            if (options.performance) {
+                await showTablePerformanceMetrics(table, db);
+            }
+        }
+        else {
+            // Show all tables with automation overview
+            console.log(chalk.green(`📊 Discovered ${schemaInfo.tables.length} tables with complete automation:\n`));
+            showTablesList(schemaInfo.tables);
+            if (options.relationships) {
+                console.log('\n' + chalk.blue.bold('🔗 Relationships:\n'));
+                showRelationships(schemaInfo.relationships);
+            }
+            if (options.optimizations) {
+                console.log('\n' + chalk.blue.bold('🔧 Optimization Overview:\n'));
+                await showOptimizationOverview(db);
+            }
+            if (options.indexes) {
+                console.log('\n' + chalk.blue.bold('📊 Index Analysis:\n'));
+                await showIndexAnalysis(db);
+            }
+            if (options.performance) {
+                console.log('\n' + chalk.blue.bold('⚡ Performance Metrics:\n'));
+                await showPerformanceOverview(db);
+            }
+            // Show automation recommendations
+            console.log('\n' + chalk.blue.bold('💡 Automation Recommendations:\n'));
+            await showAutomationRecommendations(schemaInfo, db);
+        }
+        await db.close();
+    }
+    catch (error) {
+        console.error(chalk.red('❌ Inspection failed:'), error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+function showTablesList(tables) {
+    const tableData = tables.map(table => ({
+        name: table.name,
+        columns: table.columns.length,
+        primaryKey: table.primaryKey?.join(', ') || 'None',
+        foreignKeys: table.foreignKeys.length,
+        indexes: table.indexes.length
+    }));
+    // Simple table formatting
+    console.log(chalk.gray('┌─' + '─'.repeat(20) + '┬─' + '─'.repeat(8) + '┬─' + '─'.repeat(15) + '┬─' + '─'.repeat(5) + '┬─' + '─'.repeat(8) + '┐'));
+    console.log(chalk.gray('│ ') + chalk.bold('Table Name'.padEnd(19)) + chalk.gray('│ ') + chalk.bold('Columns'.padEnd(7)) + chalk.gray('│ ') + chalk.bold('Primary Key'.padEnd(14)) + chalk.gray('│ ') + chalk.bold('FKs'.padEnd(4)) + chalk.gray('│ ') + chalk.bold('Indexes'.padEnd(7)) + chalk.gray('│'));
+    console.log(chalk.gray('├─' + '─'.repeat(20) + '┼─' + '─'.repeat(8) + '┼─' + '─'.repeat(15) + '┼─' + '─'.repeat(5) + '┼─' + '─'.repeat(8) + '┤'));
+    tableData.forEach(table => {
+        console.log(chalk.gray('│ ') + chalk.cyan(table.name.padEnd(19)) +
+            chalk.gray('│ ') + String(table.columns).padEnd(7) +
+            chalk.gray('│ ') + table.primaryKey.padEnd(14) +
+            chalk.gray('│ ') + String(table.foreignKeys).padEnd(4) +
+            chalk.gray('│ ') + String(table.indexes).padEnd(7) +
+            chalk.gray('│'));
+    });
+    console.log(chalk.gray('└─' + '─'.repeat(20) + '┴─' + '─'.repeat(8) + '┴─' + '─'.repeat(15) + '┴─' + '─'.repeat(5) + '┴─' + '─'.repeat(8) + '┘'));
+}
+async function showTableOptimizations(table, db) {
+    try {
+        console.log(chalk.blue('\n🔧 Optimization Analysis for ' + table.name + ':'));
+        // Check for missing indexes
+        const indexRecs = await db.getSQLiteIndexRecommendations();
+        const tableRecommendations = indexRecs.recommendations.filter((rec) => rec.table === table.name);
+        if (tableRecommendations.length > 0) {
+            console.log(chalk.yellow(`💡 ${tableRecommendations.length} optimization recommendations:`));
+            tableRecommendations.forEach((rec, index) => {
+                console.log(chalk.gray(`  ${index + 1}. ${rec.column}: ${rec.reason} (${rec.impact} impact)`));
+            });
+        }
+        else {
+            console.log(chalk.green('✅ No optimization recommendations for this table'));
+        }
+        // Check for foreign key constraints
+        if (table.foreignKeys.length === 0 && table.columns.some(col => col.name.includes('_id'))) {
+            console.log(chalk.yellow('💡 Consider adding foreign key constraints for data integrity'));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('❌ Failed to get optimization analysis:'), error instanceof Error ? error.message : error);
+    }
+}
+async function showTableIndexAnalysis(table, db) {
+    try {
+        console.log(chalk.blue('\n📊 Index Analysis for ' + table.name + ':'));
+        // Show current indexes
+        if (table.indexes.length > 0) {
+            console.log(chalk.green(`✅ ${table.indexes.length} indexes found:`));
+            table.indexes.forEach((index, i) => {
+                const type = index.unique ? 'UNIQUE' : 'INDEX';
+                console.log(chalk.gray(`  ${i + 1}. ${index.name} (${type}): ${index.columns.join(', ')}`));
+            });
+        }
+        else {
+            console.log(chalk.yellow('⚠️ No indexes found - consider adding indexes for frequently queried columns'));
+        }
+        // Show index recommendations
+        const indexRecs = await db.getSQLiteIndexRecommendations();
+        const tableRecommendations = indexRecs.recommendations.filter((rec) => rec.table === table.name);
+        if (tableRecommendations.length > 0) {
+            console.log(chalk.blue(`\n💡 Index recommendations:`));
+            tableRecommendations.forEach((rec, index) => {
+                console.log(chalk.gray(`  ${index + 1}. CREATE INDEX idx_${rec.table}_${rec.column} ON ${rec.table}(${rec.column});`));
+                console.log(chalk.gray(`     Reason: ${rec.reason}`));
+            });
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('❌ Failed to get index analysis:'), error instanceof Error ? error.message : error);
+    }
+}
+async function showTablePerformanceMetrics(table, db) {
+    try {
+        console.log(chalk.blue('\n⚡ Performance Metrics for ' + table.name + ':'));
+        // Get performance metrics
+        const metrics = await db.getSQLitePerformanceMetrics();
+        console.log(chalk.gray(`  Table size: ${table.columns.length} columns`));
+        console.log(chalk.gray(`  Indexes: ${table.indexes.length}`));
+        console.log(chalk.gray(`  Foreign keys: ${table.foreignKeys.length}`));
+        console.log(chalk.gray(`  Cache hit rate: ${(metrics.cacheHitRate * 100).toFixed(1)}%`));
+        // Performance score for this table
+        let score = 0;
+        if (table.indexes.length > 0)
+            score += 25;
+        if (table.foreignKeys.length > 0)
+            score += 25;
+        if (table.primaryKey && table.primaryKey.length > 0)
+            score += 25;
+        if (table.columns.length <= 20)
+            score += 25; // Reasonable column count
+        const scoreColor = score >= 80 ? 'green' : score >= 60 ? 'yellow' : 'red';
+        console.log(chalk[scoreColor](`  Performance score: ${score}/100`));
+    }
+    catch (error) {
+        console.error(chalk.red('❌ Failed to get performance metrics:'), error instanceof Error ? error.message : error);
+    }
+}
+async function showOptimizationOverview(db) {
+    try {
+        const optimizations = await db.getSQLiteOptimizations();
+        console.log(chalk.green(`✅ Applied optimizations: ${optimizations.appliedOptimizations.length}`));
+        if (optimizations.appliedOptimizations.length > 0) {
+            optimizations.appliedOptimizations.forEach((opt, index) => {
+                console.log(chalk.gray(`  ${index + 1}. ${opt}`));
+            });
+        }
+        if (optimizations.warnings.length > 0) {
+            console.log(chalk.yellow(`\n⚠️ Warnings: ${optimizations.warnings.length}`));
+            optimizations.warnings.forEach((warning, index) => {
+                console.log(chalk.gray(`  ${index + 1}. ${warning}`));
+            });
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('❌ Failed to get optimization overview:'), error instanceof Error ? error.message : error);
+    }
+}
+async function showIndexAnalysis(db) {
+    try {
+        const indexRecs = await db.getSQLiteIndexRecommendations();
+        if (indexRecs.recommendations.length > 0) {
+            console.log(chalk.yellow(`💡 ${indexRecs.recommendations.length} index recommendations available:`));
+            indexRecs.recommendations.slice(0, 10).forEach((rec, index) => {
+                console.log(chalk.gray(`  ${index + 1}. ${rec.table}.${rec.column} - ${rec.reason}`));
+            });
+            if (indexRecs.recommendations.length > 10) {
+                console.log(chalk.gray(`  ... and ${indexRecs.recommendations.length - 10} more recommendations`));
+            }
+        }
+        else {
+            console.log(chalk.green('✅ No index recommendations at this time'));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('❌ Failed to get index analysis:'), error instanceof Error ? error.message : error);
+    }
+}
+async function showPerformanceOverview(db) {
+    try {
+        const metrics = await db.getSQLitePerformanceMetrics();
+        console.log(chalk.gray(`Cache hit rate: ${(metrics.cacheHitRate * 100).toFixed(1)}%`));
+        console.log(chalk.gray(`Average query time: ${metrics.averageQueryTime.toFixed(2)}ms`));
+        console.log(chalk.gray(`Database size: ${(metrics.databaseSize / 1024 / 1024).toFixed(2)}MB`));
+        console.log(chalk.gray(`Page count: ${metrics.pageCount.toLocaleString()}`));
+        console.log(chalk.gray(`WAL mode: ${metrics.walMode ? 'Enabled' : 'Disabled'}`));
+        console.log(chalk.gray(`Foreign keys: ${metrics.foreignKeys ? 'Enabled' : 'Disabled'}`));
+    }
+    catch (error) {
+        console.error(chalk.red('❌ Failed to get performance overview:'), error instanceof Error ? error.message : error);
+    }
+}
+async function showAutomationRecommendations(schemaInfo, db) {
+    try {
+        const recommendations = [];
+        // Check for tables without indexes
+        const tablesWithoutIndexes = schemaInfo.tables.filter((table) => table.indexes.length === 0 && table.columns.length > 1);
+        if (tablesWithoutIndexes.length > 0) {
+            recommendations.push(`Consider adding indexes to tables: ${tablesWithoutIndexes.map((t) => t.name).join(', ')}`);
+        }
+        // Check for missing foreign keys
+        const tablesWithIdColumns = schemaInfo.tables.filter((table) => table.columns.some((col) => col.name.includes('_id')) && table.foreignKeys.length === 0);
+        if (tablesWithIdColumns.length > 0) {
+            recommendations.push(`Add foreign key constraints to tables: ${tablesWithIdColumns.map((t) => t.name).join(', ')}`);
+        }
+        // Check performance metrics
+        const metrics = await db.getSQLitePerformanceMetrics();
+        if (metrics.cacheHitRate < 0.8) {
+            recommendations.push('Run optimization to improve cache hit rate');
+        }
+        if (metrics.averageQueryTime > 100) {
+            recommendations.push('Apply performance optimizations for faster queries');
+        }
+        if (!metrics.walMode) {
+            recommendations.push('Enable WAL mode for better concurrency');
+        }
+        // Check for index recommendations
+        const indexRecs = await db.getSQLiteIndexRecommendations();
+        if (indexRecs.recommendations.length > 0) {
+            recommendations.push(`Apply ${indexRecs.recommendations.length} index recommendations`);
+        }
+        if (recommendations.length > 0) {
+            recommendations.forEach((rec, index) => {
+                console.log(chalk.gray(`  ${index + 1}. ${rec}`));
+            });
+            console.log(chalk.blue('\n💡 To apply recommendations:'));
+            console.log(chalk.gray('• Run: npx noormme optimize'));
+            console.log(chalk.gray('• Run: npx noormme analyze --report'));
+            console.log(chalk.gray('• Use: npx noormme watch --auto-optimize'));
+        }
+        else {
+            console.log(chalk.green('✅ Your database is well-optimized!'));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('❌ Failed to get automation recommendations:'), error instanceof Error ? error.message : error);
+    }
+}
+function showTableDetails(table, relationships, db) {
+    console.log(chalk.green.bold(`Table: ${table.name}`));
+    if (table.schema) {
+        console.log(chalk.gray(`Schema: ${table.schema}`));
+    }
+    console.log();
+    // Columns
+    console.log(chalk.blue.bold('Columns:'));
+    console.log(chalk.gray('┌─' + '─'.repeat(25) + '┬─' + '─'.repeat(15) + '┬─' + '─'.repeat(8) + '┬─' + '─'.repeat(10) + '┐'));
+    console.log(chalk.gray('│ ') + chalk.bold('Name'.padEnd(24)) + chalk.gray('│ ') + chalk.bold('Type'.padEnd(14)) + chalk.gray('│ ') + chalk.bold('Nullable'.padEnd(7)) + chalk.gray('│ ') + chalk.bold('Default'.padEnd(9)) + chalk.gray('│'));
+    console.log(chalk.gray('├─' + '─'.repeat(25) + '┼─' + '─'.repeat(15) + '┼─' + '─'.repeat(8) + '┼─' + '─'.repeat(10) + '┤'));
+    table.columns.forEach(col => {
+        const name = col.isPrimaryKey ? chalk.yellow(`${col.name} (PK)`) : col.name;
+        const nullable = col.nullable ? chalk.green('YES') : chalk.red('NO');
+        const defaultValue = col.defaultValue ? String(col.defaultValue) : '';
+        console.log(chalk.gray('│ ') + name.padEnd(24) +
+            chalk.gray('│ ') + col.type.padEnd(14) +
+            chalk.gray('│ ') + nullable.padEnd(7) +
+            chalk.gray('│ ') + defaultValue.padEnd(9) +
+            chalk.gray('│'));
+    });
+    console.log(chalk.gray('└─' + '─'.repeat(25) + '┴─' + '─'.repeat(15) + '┴─' + '─'.repeat(8) + '┴─' + '─'.repeat(10) + '┘'));
+    // Primary Key
+    if (table.primaryKey && table.primaryKey.length > 0) {
+        console.log();
+        console.log(chalk.blue.bold('Primary Key:'));
+        console.log(chalk.gray(`  ${table.primaryKey.join(', ')}`));
+    }
+    // Foreign Keys
+    if (table.foreignKeys.length > 0) {
+        console.log();
+        console.log(chalk.blue.bold('Foreign Keys:'));
+        table.foreignKeys.forEach(fk => {
+            console.log(chalk.gray(`  ${fk.column} → ${fk.referencedTable}.${fk.referencedColumn}`));
+            if (fk.onDelete)
+                console.log(chalk.gray(`    ON DELETE ${fk.onDelete}`));
+            if (fk.onUpdate)
+                console.log(chalk.gray(`    ON UPDATE ${fk.onUpdate}`));
+        });
+    }
+    // Indexes
+    if (table.indexes.length > 0) {
+        console.log();
+        console.log(chalk.blue.bold('Indexes:'));
+        table.indexes.forEach(idx => {
+            const type = idx.unique ? chalk.yellow('UNIQUE') : 'INDEX';
+            console.log(chalk.gray(`  ${idx.name} (${type}): ${idx.columns.join(', ')}`));
+        });
+    }
+    // Relationships for this table
+    const tableRelationships = relationships.filter(r => r.fromTable === table.name || r.toTable === table.name);
+    if (tableRelationships.length > 0) {
+        console.log();
+        console.log(chalk.blue.bold('Relationships:'));
+        tableRelationships.forEach(rel => {
+            const direction = rel.fromTable === table.name ? '→' : '←';
+            const otherTable = rel.fromTable === table.name ? rel.toTable : rel.fromTable;
+            const type = rel.type.toUpperCase().replace('-', ' ');
+            console.log(chalk.gray(`  ${rel.name} (${type}) ${direction} ${otherTable}`));
+        });
+    }
+    // Usage example
+    console.log();
+    console.log(chalk.blue.bold('Usage Example:'));
+    console.log(chalk.gray('```typescript'));
+    console.log(chalk.gray(`const ${table.name}Repo = db.getRepository('${table.name}')`));
+    console.log(chalk.gray(`const records = await ${table.name}Repo.findAll()`));
+    console.log(chalk.gray(`const record = await ${table.name}Repo.findById(1)`));
+    if (tableRelationships.length > 0) {
+        const relationshipNames = tableRelationships.map(r => `'${r.name}'`).join(', ');
+        console.log(chalk.gray(`const withRelations = await ${table.name}Repo.findWithRelations(1, [${relationshipNames}])`));
+    }
+    console.log(chalk.gray('```'));
+}
+function showRelationships(relationships) {
+    if (relationships.length === 0) {
+        console.log(chalk.gray('No relationships found.'));
+        return;
+    }
+    relationships.forEach(rel => {
+        const type = rel.type.toUpperCase().replace('-', ' ');
+        console.log(chalk.cyan(`${rel.name} (${type})`));
+        console.log(chalk.gray(`  ${rel.fromTable}.${rel.fromColumn} → ${rel.toTable}.${rel.toColumn}`));
+        if (rel.throughTable) {
+            console.log(chalk.gray(`  Through: ${rel.throughTable}`));
+        }
+        console.log();
+    });
+}

package/dist/esm/cli/commands/migrate.d.ts

@@ -0,0 +1,8 @@
+export declare function migrate(options: {
+    database?: string;
+    to?: string;
+    latest?: boolean;
+    rollback?: boolean;
+    status?: boolean;
+    generate?: string;
+}): Promise<void>;

package/dist/esm/cli/commands/migrate.js

@@ -0,0 +1,216 @@
+/// <reference types="./migrate.d.ts" />
+import chalk from 'chalk';
+import { NOORMME } from '../../noormme.js';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+export async function migrate(options) {
+    console.log(chalk.blue.bold('\n🔄 NOORMME Migration Management - Automated Schema Evolution\n'));
+    try {
+        // Initialize NOORMME with database path
+        const databasePath = options.database || process.env.DATABASE_PATH || './database.sqlite';
+        const db = new NOORMME({
+            dialect: 'sqlite',
+            connection: {
+                database: databasePath,
+                host: 'localhost',
+                port: 0,
+                username: '',
+                password: ''
+            }
+        });
+        await db.initialize();
+        console.log(chalk.gray(`📁 Database: ${databasePath}\n`));
+        // Migration manager placeholder - would need implementation
+        const migrationManager = {
+            generateMigration: async (name) => {
+                throw new Error('Migration generation not yet implemented');
+            },
+            getMigrationStatus: async () => {
+                return {
+                    currentVersion: null,
+                    availableMigrations: [],
+                    pendingMigrations: [],
+                    appliedMigrations: []
+                };
+            },
+            migrateToLatest: async () => {
+                return {
+                    migrationsApplied: [],
+                    warnings: [],
+                    currentVersion: null
+                };
+            },
+            migrateToVersion: async (version) => {
+                return {
+                    migrationsApplied: [],
+                    migrationsRolledBack: [],
+                    currentVersion: version
+                };
+            },
+            rollbackLastMigration: async () => {
+                return {
+                    success: false,
+                    migration: { version: '', name: '' },
+                    currentVersion: null
+                };
+            }
+        };
+        // Generate new migration
+        if (options.generate) {
+            console.log(chalk.blue(`📝 Generating migration: ${options.generate}`));
+            try {
+                const migration = await migrationManager.generateMigration(options.generate);
+                console.log(chalk.green(`✅ Migration generated: ${migration.fileName}`));
+                console.log(chalk.gray(`📁 Location: ${migration.filePath}`));
+                console.log(chalk.gray(`📋 Description: ${migration.description}`));
+                // Show migration content
+                if (migration.content) {
+                    console.log(chalk.blue('\n📄 Migration Content:'));
+                    console.log(chalk.gray(migration.content));
+                }
+                console.log(chalk.blue('\n💡 Next steps:'));
+                console.log(chalk.gray('• Review and modify the generated migration if needed'));
+                console.log(chalk.gray('• Run "npx noormme migrate --latest" to apply the migration'));
+            }
+            catch (error) {
+                console.error(chalk.red('❌ Migration generation failed:'), error instanceof Error ? error.message : error);
+            }
+            await db.close();
+            return;
+        }
+        // Show migration status
+        if (options.status || (!options.to && !options.latest && !options.rollback)) {
+            console.log(chalk.blue('📊 Migration Status:'));
+            try {
+                const status = await migrationManager.getMigrationStatus();
+                console.log(chalk.green(`\n📈 Migration Summary:`));
+                console.log(chalk.gray(`  Current version: ${status.currentVersion || 'None'}`));
+                console.log(chalk.gray(`  Available migrations: ${status.availableMigrations.length}`));
+                console.log(chalk.gray(`  Pending migrations: ${status.pendingMigrations.length}`));
+                console.log(chalk.gray(`  Applied migrations: ${status.appliedMigrations.length}`));
+                if (status.appliedMigrations.length > 0) {
+                    console.log(chalk.green(`\n✅ Applied Migrations:`));
+                    status.appliedMigrations.forEach((migration, index) => {
+                        console.log(chalk.gray(`  ${index + 1}. ${migration.version} - ${migration.name} (${migration.appliedAt})`));
+                    });
+                }
+                if (status.pendingMigrations.length > 0) {
+                    console.log(chalk.yellow(`\n⏳ Pending Migrations:`));
+                    status.pendingMigrations.forEach((migration, index) => {
+                        console.log(chalk.gray(`  ${index + 1}. ${migration.version} - ${migration.name}`));
+                    });
+                }
+                if (status.availableMigrations.length === 0) {
+                    console.log(chalk.gray('\n📝 No migrations found. Create your first migration with:'));
+                    console.log(chalk.gray('npx noormme migrate --generate "initial_schema"'));
+                }
+            }
+            catch (error) {
+                console.error(chalk.red('❌ Failed to get migration status:'), error instanceof Error ? error.message : error);
+            }
+        }
+        // Migrate to latest version
+        if (options.latest) {
+            console.log(chalk.blue('🚀 Migrating to latest version...'));
+            try {
+                const result = await migrationManager.migrateToLatest();
+                if (result.migrationsApplied.length > 0) {
+                    console.log(chalk.green(`\n✅ Applied ${result.migrationsApplied.length} migrations:`));
+                    result.migrationsApplied.forEach((migration, index) => {
+                        console.log(chalk.gray(`  ${index + 1}. ${migration.version} - ${migration.name}`));
+                    });
+                }
+                else {
+                    console.log(chalk.gray('No migrations to apply - database is up to date'));
+                }
+                if (result.warnings.length > 0) {
+                    console.log(chalk.yellow(`\n⚠️ ${result.warnings.length} warnings:`));
+                    result.warnings.forEach((warning) => {
+                        console.log(chalk.gray(`  • ${warning}`));
+                    });
+                }
+                console.log(chalk.green(`\n🎉 Migration completed successfully!`));
+                console.log(chalk.gray(`Current version: ${result.currentVersion}`));
+            }
+            catch (error) {
+                console.error(chalk.red('❌ Migration failed:'), error instanceof Error ? error.message : error);
+                console.log(chalk.yellow('\n💡 Troubleshooting:'));
+                console.log(chalk.gray('• Check the migration files for syntax errors'));
+                console.log(chalk.gray('• Ensure the database is not locked by another process'));
+                console.log(chalk.gray('• Use --rollback to undo the last migration if needed'));
+            }
+        }
+        // Migrate to specific version
+        if (options.to) {
+            console.log(chalk.blue(`🎯 Migrating to version: ${options.to}`));
+            try {
+                const result = await migrationManager.migrateToVersion(options.to);
+                console.log(chalk.green(`\n✅ Migration to version ${options.to} completed!`));
+                if (result.migrationsApplied.length > 0) {
+                    console.log(chalk.green(`Applied ${result.migrationsApplied.length} migrations:`));
+                    result.migrationsApplied.forEach((migration, index) => {
+                        console.log(chalk.gray(`  ${index + 1}. ${migration.version} - ${migration.name}`));
+                    });
+                }
+                if (result.migrationsRolledBack.length > 0) {
+                    console.log(chalk.yellow(`Rolled back ${result.migrationsRolledBack.length} migrations:`));
+                    result.migrationsRolledBack.forEach((migration, index) => {
+                        console.log(chalk.gray(`  ${index + 1}. ${migration.version} - ${migration.name}`));
+                    });
+                }
+            }
+            catch (error) {
+                console.error(chalk.red('❌ Migration to version failed:'), error instanceof Error ? error.message : error);
+            }
+        }
+        // Rollback last migration
+        if (options.rollback) {
+            console.log(chalk.blue('⏪ Rolling back last migration...'));
+            try {
+                const result = await migrationManager.rollbackLastMigration();
+                if (result.success) {
+                    console.log(chalk.green(`\n✅ Rollback completed successfully!`));
+                    console.log(chalk.gray(`Rolled back: ${result.migration.version} - ${result.migration.name}`));
+                    console.log(chalk.gray(`Current version: ${result.currentVersion}`));
+                }
+                else {
+                    console.log(chalk.yellow('No migrations to rollback'));
+                }
+            }
+            catch (error) {
+                console.error(chalk.red('❌ Rollback failed:'), error instanceof Error ? error.message : error);
+            }
+        }
+        // Show migration directory info
+        console.log(chalk.blue('\n📁 Migration Directory:'));
+        try {
+            const migrationsDir = path.join(process.cwd(), 'migrations');
+            const exists = await fs.access(migrationsDir).then(() => true).catch(() => false);
+            if (exists) {
+                const files = await fs.readdir(migrationsDir);
+                const migrationFiles = files.filter(f => f.endsWith('.ts') || f.endsWith('.js'));
+                console.log(chalk.gray(`  Location: ${migrationsDir}`));
+                console.log(chalk.gray(`  Files: ${migrationFiles.length} migration files`));
+            }
+            else {
+                console.log(chalk.gray(`  Location: ${migrationsDir} (will be created)`));
+                console.log(chalk.gray(`  Status: Directory does not exist yet`));
+            }
+        }
+        catch (error) {
+            console.error(chalk.red('❌ Failed to check migration directory:'), error instanceof Error ? error.message : error);
+        }
+        // Recommendations
+        console.log(chalk.blue('\n💡 Migration Tips:'));
+        console.log(chalk.gray('• Always backup your database before running migrations'));
+        console.log(chalk.gray('• Test migrations on a copy of production data first'));
+        console.log(chalk.gray('• Use descriptive migration names (e.g., "add_user_email_index")'));
+        console.log(chalk.gray('• Keep migrations small and focused on single changes'));
+        console.log(chalk.gray('• Use --dry-run to preview changes before applying'));
+        await db.close();
+    }
+    catch (error) {
+        console.error(chalk.red('❌ Migration command failed:'), error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}

package/dist/esm/cli/commands/optimize.d.ts

@@ -0,0 +1,8 @@
+export declare function optimize(options: {
+    database?: string;
+    pragma?: boolean;
+    indexes?: boolean;
+    analyze?: boolean;
+    wal?: boolean;
+    dryRun?: boolean;
+}): Promise<void>;