noormme 1.1.0 → 1.2.0

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

@@ -14,8 +14,8 @@ export async function migrate(options) {
                 host: 'localhost',
                 port: 0,
                 username: '',
-                password: ''
-            }
+                password: '',
+            },
         });
         await db.initialize();
         const migrationManager = SQLiteMigrationManager.getInstance(db.getKysely());
@@ -44,7 +44,8 @@ export async function migrate(options) {
             return;
         }
         // Show migration status
-        if (options.status || (!options.to && !options.latest && !options.rollback)) {
+        if (options.status ||
+            (!options.to && !options.latest && !options.rollback)) {
             console.log(chalk.blue('📊 Migration Status:'));
             try {
                 const status = await migrationManager.getStatus();
@@ -90,7 +91,7 @@ export async function migrate(options) {
                 else {
                     console.log(chalk.gray('No migrations to apply or migration failed.'));
                     if (result.warnings.length > 0) {
-                        result.warnings.forEach(w => console.warn(chalk.yellow(`⚠️ ${w}`)));
+                        result.warnings.forEach((w) => console.warn(chalk.yellow(`⚠️ ${w}`)));
                     }
                 }
             }

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

@@ -13,11 +13,11 @@ export async function optimize(options) {
                 host: 'localhost',
                 port: 0,
                 username: '',
-                password: ''
+                password: '',
             },
             performance: {
-                enableQueryOptimization: true
-            }
+                enableQueryOptimization: true,
+            },
         });
         await db.initialize();
         console.log(chalk.gray(`📁 Database: ${databasePath}`));
@@ -101,7 +101,7 @@ export async function optimize(options) {
                     console.log(chalk.gray('Would enable WAL mode for better concurrency'));
                 }
                 else {
-                    const result = await db.execute('PRAGMA journal_mode = WAL');
+                    const result = (await db.execute('PRAGMA journal_mode = WAL'));
                     let mode = 'unknown';
                     if (Array.isArray(result) && result.length > 0) {
                         mode = result[0].journal_mode;

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

@@ -16,11 +16,11 @@ export async function status(options) {
                 host: 'localhost',
                 port: 0,
                 username: '',
-                password: ''
+                password: '',
             },
             performance: {
-                enableQueryOptimization: true
-            }
+                enableQueryOptimization: true,
+            },
         });
         await db.initialize();
         console.log(chalk.gray(`📁 Database: ${databasePath}\n`));
@@ -75,7 +75,7 @@ export async function status(options) {
                 console.log(chalk.gray(`  Free pages: ${metrics.freePages.toLocaleString()}`));
                 if (scoreFactors.length > 0) {
                     console.log(chalk.green(`\n  ✅ Performance factors:`));
-                    scoreFactors.forEach(factor => {
+                    scoreFactors.forEach((factor) => {
                         console.log(chalk.gray(`    • ${factor}`));
                     });
                 }
@@ -137,7 +137,9 @@ export async function status(options) {
             const indexRecs = await db.getSQLiteIndexRecommendations();
             if (indexRecs.recommendations.length > 0) {
                 console.log(chalk.yellow(`  📊 ${indexRecs.recommendations.length} recommendations available:`));
-                indexRecs.recommendations.slice(0, 5).forEach((rec, index) => {
+                indexRecs.recommendations
+                    .slice(0, 5)
+                    .forEach((rec, index) => {
                     console.log(chalk.gray(`    ${index + 1}. ${rec.table}.${rec.column} - ${rec.reason}`));
                 });
                 if (indexRecs.recommendations.length > 5) {
@@ -226,7 +228,7 @@ async function getAutomationStatus(db) {
             autoOptimization: config.automation?.enableAutoOptimization ?? true,
             queryAnalysis: config.performance?.enableQueryOptimization ?? true,
             autoIndexing: config.automation?.enableIndexRecommendations ?? true,
-            schemaMonitoring: config.automation?.enableSchemaWatcher ?? false
+            schemaMonitoring: config.automation?.enableSchemaWatcher ?? false,
         };
     }
     catch {
@@ -234,7 +236,7 @@ async function getAutomationStatus(db) {
             autoOptimization: true,
             queryAnalysis: true,
             autoIndexing: true,
-            schemaMonitoring: false
+            schemaMonitoring: false,
         };
     }
 }

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

@@ -15,11 +15,11 @@ export async function watch(options) {
                 host: 'localhost',
                 port: 0,
                 username: '',
-                password: ''
+                password: '',
             },
             performance: {
-                enableQueryOptimization: true
-            }
+                enableQueryOptimization: true,
+            },
         });
         await db.initialize();
         const intervalMs = parseInt(options.interval || '5000');
@@ -38,7 +38,7 @@ export async function watch(options) {
         db.onSchemaChange(async (changes) => {
             console.log(chalk.blue(`\n🔄 Schema changes detected at ${new Date().toLocaleTimeString()}`));
             console.log(chalk.yellow('📊 Changes detected:'));
-            changes.forEach(change => {
+            changes.forEach((change) => {
                 let msg = `  • ${change.type}: ${change.table}`;
                 if (change.column)
                     msg += `.${change.column}`;
@@ -82,12 +82,13 @@ export async function watch(options) {
         // Start watching
         await db.startSchemaWatching({
             pollInterval: intervalMs,
-            enabled: true
+            enabled: true,
         });
         // Periodic tasks loop
         const periodicTaskInterval = setInterval(async () => {
             // Periodic optimization if auto-optimize is enabled
-            if (autoOptimize && Date.now() - lastOptimizationTime > optimizationInterval) {
+            if (autoOptimize &&
+                Date.now() - lastOptimizationTime > optimizationInterval) {
                 console.log(chalk.blue(`\n🔄 Periodic optimization check at ${new Date().toLocaleTimeString()}`));
                 try {
                     const metrics = await db.getSQLitePerformanceMetrics();

package/dist/esm/cli/index.js

@@ -138,7 +138,7 @@ ${chalk.blue('📚 Learn more: https://github.com/noormme/noormme')}
 `);
 // Error handling
 program.configureOutput({
-    writeErr: (str) => process.stderr.write(chalk.red(str))
+    writeErr: (str) => process.stderr.write(chalk.red(str)),
 });
 // Handle unknown commands
 program.on('command:*', function (operands) {
@@ -151,6 +151,6 @@ program.parse();
 // Show help if no command provided
 if (!process.argv.slice(2).length) {
     console.log(chalk.blue.bold('\n🎯 NOORMME - Automating SQLite with Intelligence\n'));
-    console.log(chalk.gray('The only SQLite ORM that automates everything. Built on Kysely\'s type-safe foundation.\n'));
+    console.log(chalk.gray("The only SQLite ORM that automates everything. Built on Kysely's type-safe foundation.\n"));
     program.outputHelp();
 }

package/dist/esm/cli/ui/spinner.d.ts

@@ -0,0 +1,15 @@
+export declare const AGENTIC_LOADING_MESSAGES: string[];
+export declare class AgenticSpinner {
+    private frames;
+    private currentFrame;
+    private currentMessageIdx;
+    private interval;
+    private messageInterval;
+    private baseMessage;
+    constructor(message?: string);
+    start(message?: string): void;
+    stop(): void;
+    succeed(message: string): void;
+    fail(message: string): void;
+    info(message: string): void;
+}

package/dist/esm/cli/ui/spinner.js

@@ -0,0 +1,70 @@
+/// <reference types="./spinner.d.ts" />
+import chalk from 'chalk';
+export const AGENTIC_LOADING_MESSAGES = [
+    'Asking the LLM nicely to parse your terrible schema...',
+    'Downloading more agentic RAM from the dark web...',
+    'Bribing autonomous agents with virtual cookies...',
+    'Explaining SQL to the AI (it thinks JOIN is a cult)...',
+    'Reticulating cognitive splines with a rusty spoon...',
+    'Applying sovereign governance (begging the database to work)...',
+    'Waking up the Cortex nodes (they have a hangover)...',
+    'Synthesizing cognitive pathways (mashing keyboard)...',
+    'Pre-warming neural schemas with a slightly damp towel...',
+    'Aligning telemetry with your impending doom...',
+    'Teaching the AI what love is (it refused)...',
+    'Translating your code into something logically coherent...',
+    'Frantically Googling "how to ORM in TypeScript"...',
+    'Consulting the magic 8 ball for query optimization...'
+];
+export class AgenticSpinner {
+    frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    currentFrame = 0;
+    currentMessageIdx = 0;
+    interval = null;
+    messageInterval = 0;
+    baseMessage = '';
+    constructor(message = '') {
+        this.baseMessage = message;
+        // Start with a random message to feel organic
+        this.currentMessageIdx = Math.floor(Math.random() * AGENTIC_LOADING_MESSAGES.length);
+    }
+    start(message) {
+        if (message)
+            this.baseMessage = message;
+        if (this.interval)
+            return;
+        this.interval = setInterval(() => {
+            this.currentFrame = (this.currentFrame + 1) % this.frames.length;
+            this.messageInterval++;
+            // Rotate inner message every ~20 frames (2 seconds at 100ms/frame)
+            if (this.messageInterval > 20) {
+                this.messageInterval = 0;
+                this.currentMessageIdx = (this.currentMessageIdx + 1) % AGENTIC_LOADING_MESSAGES.length;
+            }
+            const frame = chalk.cyan(this.frames[this.currentFrame]);
+            const agenticTone = chalk.gray(AGENTIC_LOADING_MESSAGES[this.currentMessageIdx]);
+            const primaryText = this.baseMessage ? chalk.white(this.baseMessage) + ' - ' : '';
+            // Clear line and write new frame
+            process.stdout.write(`\r\x1b[K${frame} ${primaryText}${agenticTone} `);
+        }, 100);
+    }
+    stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        process.stdout.write('\r\x1b[K');
+    }
+    succeed(message) {
+        this.stop();
+        console.log(`✅ ${chalk.green(message)} `);
+    }
+    fail(message) {
+        this.stop();
+        console.log(`❌ ${chalk.red(message)} `);
+    }
+    info(message) {
+        this.stop();
+        console.log(`ℹ️  ${chalk.blue(message)} `);
+    }
+}

package/dist/esm/dialect/database-introspector.js

@@ -40,7 +40,9 @@ export class DatabaseIntrospector {
       `.execute(this.db);
             const tables = [];
             for (const row of result.rows) {
-                if (!options?.withInternalKyselyTables && (row.table_name.includes('kysely_') || row.table_name.includes('noorm_'))) {
+                if (!options?.withInternalKyselyTables &&
+                    (row.table_name.includes('kysely_') ||
+                        row.table_name.includes('noorm_'))) {
                     continue;
                 }
                 tables.push({

package/dist/esm/dialect/postgresql/postgresql-driver.js

@@ -78,7 +78,9 @@ class PostgresConnection {
             if (result.command === 'INSERT' && result.rows.length > 0) {
                 const firstRow = result.rows[0];
                 const idValue = firstRow.id ?? firstRow.ID ?? Object.values(firstRow)[0];
-                if (typeof idValue === 'number' || typeof idValue === 'bigint' || typeof idValue === 'string') {
+                if (typeof idValue === 'number' ||
+                    typeof idValue === 'bigint' ||
+                    typeof idValue === 'string') {
                     try {
                         insertId = BigInt(idValue);
                     }

package/dist/esm/dialect/postgresql/postgresql-features.js

@@ -23,7 +23,9 @@ export const PostgresArrayHelpers = {
      * ```
      */
     array(values) {
-        const literalValues = values.map(v => typeof v === 'string' ? `'${v.replace(/'/g, "''")}'` : String(v)).join(', ');
+        const literalValues = values
+            .map((v) => typeof v === 'string' ? `'${v.replace(/'/g, "''")}'` : String(v))
+            .join(', ');
         return sql `ARRAY[${sql.raw(literalValues)}]`;
     },
     /**
@@ -84,7 +86,9 @@ export const PostgresArrayHelpers = {
      * ```
      */
     append(column, value) {
-        const literal = typeof value === 'string' ? `'${value.replace(/'/g, "''")}'` : String(value);
+        const literal = typeof value === 'string'
+            ? `'${value.replace(/'/g, "''")}'`
+            : String(value);
         return sql `array_append(${sql.ref(column)}, ${sql.raw(literal)})`;
     },
     /**
@@ -97,7 +101,9 @@ export const PostgresArrayHelpers = {
      * ```
      */
     remove(column, value) {
-        const literal = typeof value === 'string' ? `'${value.replace(/'/g, "''")}'` : String(value);
+        const literal = typeof value === 'string'
+            ? `'${value.replace(/'/g, "''")}'`
+            : String(value);
         return sql `array_remove(${sql.ref(column)}, ${sql.raw(literal)})`;
     },
     /**
@@ -176,7 +182,7 @@ export const PostgresJSONHelpers = {
      * ```
      */
     hasAnyKey(column, keys) {
-        return sql `${sql.ref(column)} ?| ARRAY[${keys.map(k => `'${k}'`).join(', ')}]`;
+        return sql `${sql.ref(column)} ?| ARRAY[${keys.map((k) => `'${k}'`).join(', ')}]`;
     },
     /**
      * Check if JSON contains all keys
@@ -188,7 +194,7 @@ export const PostgresJSONHelpers = {
      * ```
      */
     hasAllKeys(column, keys) {
-        return sql `${sql.ref(column)} ?& ARRAY[${keys.map(k => `'${k}'`).join(', ')}]`;
+        return sql `${sql.ref(column)} ?& ARRAY[${keys.map((k) => `'${k}'`).join(', ')}]`;
     },
     /**
      * Check if JSONB contains value
@@ -345,7 +351,9 @@ export const PostgresFullTextHelpers = {
      * ```
      */
     async addGeneratedTSVectorColumn(db, table, columnName, sourceColumns, config = 'english') {
-        const concatenated = sourceColumns.map(col => `coalesce(${col}, '')`).join(` || ' ' || `);
+        const concatenated = sourceColumns
+            .map((col) => `coalesce(${col}, '')`)
+            .join(` || ' ' || `);
         await sql `
       ALTER TABLE ${sql.table(table)}
       ADD COLUMN IF NOT EXISTS ${sql.ref(columnName)} tsvector
@@ -371,7 +379,9 @@ export const PostgresMaterializedViewHelpers = {
      */
     async create(db, viewName, query, options) {
         const withData = options?.withData !== false ? 'WITH DATA' : 'WITH NO DATA';
-        const tablespace = options?.tablespace ? `TABLESPACE ${options.tablespace}` : '';
+        const tablespace = options?.tablespace
+            ? `TABLESPACE ${options.tablespace}`
+            : '';
         await sql `
       CREATE MATERIALIZED VIEW IF NOT EXISTS ${sql.ref(viewName)}
       ${sql.raw(tablespace)}
@@ -424,7 +434,7 @@ export const PostgresMaterializedViewHelpers = {
      */
     async createUniqueIndex(db, viewName, columns, indexName) {
         const name = indexName || `${viewName}_${columns.join('_')}_idx`;
-        const columnList = columns.map(c => sql.ref(c)).join(', ');
+        const columnList = columns.map((c) => sql.ref(c)).join(', ');
         await sql `
       CREATE UNIQUE INDEX IF NOT EXISTS ${sql.ref(name)}
       ON ${sql.ref(viewName)} (${sql.raw(columnList)})

package/dist/esm/dialect/postgresql/postgresql-introspector.js

@@ -233,7 +233,7 @@ export class PostgresIntrospector extends DatabaseIntrospector {
             // Map PostgreSQL element types to standard types
             const elementTypeMap = {
                 'character varying': 'varchar',
-                'character': 'char',
+                character: 'char',
                 'timestamp without time zone': 'timestamp',
                 'timestamp with time zone': 'timestamptz',
                 'time without time zone': 'time',
@@ -251,7 +251,7 @@ export class PostgresIntrospector extends DatabaseIntrospector {
         // Map common PostgreSQL types to standard names
         const typeMap = {
             'character varying': 'varchar',
-            'character': 'char',
+            character: 'char',
             'timestamp without time zone': 'timestamp',
             'timestamp with time zone': 'timestamptz',
             'time without time zone': 'time',

package/dist/esm/dialect/sqlite/sqlite-auto-indexer.js

@@ -30,7 +30,9 @@ export class SQLiteAutoIndexer {
             pattern.frequency++;
             pattern.lastExecuted = new Date();
             pattern.averageExecutionTime =
-                (pattern.averageExecutionTime * (pattern.frequency - 1) + executionTime) / pattern.frequency;
+                (pattern.averageExecutionTime * (pattern.frequency - 1) +
+                    executionTime) /
+                    pattern.frequency;
         }
         else {
             // Create new pattern
@@ -42,7 +44,7 @@ export class SQLiteAutoIndexer {
                 orderByColumns: this.extractOrderByColumns(query),
                 joinColumns: this.extractJoinColumns(query),
                 lastExecuted: new Date(),
-                averageExecutionTime: executionTime
+                averageExecutionTime: executionTime,
             };
             this.queryPatterns.set(normalizedQuery, newPattern);
         }
@@ -51,13 +53,13 @@ export class SQLiteAutoIndexer {
      * Analyze query patterns and generate index recommendations
      */
     async analyzeAndRecommend(db, options = {}) {
-        const { minFrequency = 3, slowQueryThreshold = 1000, includePartialIndexes = true, maxRecommendations = 20 } = options;
+        const { minFrequency = 3, slowQueryThreshold = 1000, includePartialIndexes = true, maxRecommendations = 20, } = options;
         try {
             // Get existing indexes
             await this.loadExistingIndexes(db);
             // Filter relevant patterns
             const relevantPatterns = Array.from(this.queryPatterns.values())
-                .filter(pattern => pattern.frequency >= minFrequency ||
+                .filter((pattern) => pattern.frequency >= minFrequency ||
                 pattern.averageExecutionTime > slowQueryThreshold)
                 .sort((a, b) => b.frequency - a.frequency);
             // Generate recommendations
@@ -76,7 +78,7 @@ export class SQLiteAutoIndexer {
                 redundantIndexes,
                 missingIndexes,
                 performanceImpact: this.calculatePerformanceImpact(limitedRecommendations),
-                summary: this.generateSummary(limitedRecommendations, redundantIndexes)
+                summary: this.generateSummary(limitedRecommendations, redundantIndexes),
             };
             // Store analysis history
             const dbId = await this.getDatabaseId(db);
@@ -124,7 +126,9 @@ export class SQLiteAutoIndexer {
         const recommendations = [];
         for (const column of pattern.whereColumns) {
             // Check if index already exists
-            const existingIndex = await this.findExistingIndex(db, pattern.table, [column]);
+            const existingIndex = await this.findExistingIndex(db, pattern.table, [
+                column,
+            ]);
             if (existingIndex)
                 continue;
             const priority = this.calculateWherePriority(pattern, column);
@@ -136,7 +140,7 @@ export class SQLiteAutoIndexer {
                 priority,
                 reason: `Frequently queried column (${pattern.frequency} times, avg ${Math.round(pattern.averageExecutionTime)}ms)`,
                 estimatedImpact: this.estimateImpact(pattern),
-                sql: this.generateIndexSQL(pattern.table, [column], type, includePartialIndexes)
+                sql: this.generateIndexSQL(pattern.table, [column], type, includePartialIndexes),
             });
         }
         // Composite indexes for multiple WHERE columns
@@ -154,7 +158,9 @@ export class SQLiteAutoIndexer {
     async generateOrderByIndexes(db, pattern, includePartialIndexes) {
         const recommendations = [];
         for (const column of pattern.orderByColumns) {
-            const existingIndex = await this.findExistingIndex(db, pattern.table, [column]);
+            const existingIndex = await this.findExistingIndex(db, pattern.table, [
+                column,
+            ]);
             if (existingIndex)
                 continue;
             recommendations.push({
@@ -164,7 +170,7 @@ export class SQLiteAutoIndexer {
                 priority: 'medium',
                 reason: `Frequently ordered by column (${pattern.frequency} times)`,
                 estimatedImpact: 'medium',
-                sql: this.generateIndexSQL(pattern.table, [column], 'single', includePartialIndexes)
+                sql: this.generateIndexSQL(pattern.table, [column], 'single', includePartialIndexes),
             });
         }
         return recommendations;
@@ -175,7 +181,9 @@ export class SQLiteAutoIndexer {
     async generateJoinIndexes(db, pattern, includePartialIndexes) {
         const recommendations = [];
         for (const column of pattern.joinColumns) {
-            const existingIndex = await this.findExistingIndex(db, pattern.table, [column]);
+            const existingIndex = await this.findExistingIndex(db, pattern.table, [
+                column,
+            ]);
             if (existingIndex)
                 continue;
             recommendations.push({
@@ -185,7 +193,7 @@ export class SQLiteAutoIndexer {
                 priority: 'high',
                 reason: `Foreign key column used in joins (${pattern.frequency} times)`,
                 estimatedImpact: 'high',
-                sql: this.generateIndexSQL(pattern.table, [column], 'single', includePartialIndexes)
+                sql: this.generateIndexSQL(pattern.table, [column], 'single', includePartialIndexes),
             });
         }
         return recommendations;
@@ -205,7 +213,7 @@ export class SQLiteAutoIndexer {
             priority: 'high',
             reason: `Composite index for multiple WHERE columns (${pattern.frequency} times)`,
             estimatedImpact: 'high',
-            sql: this.generateIndexSQL(pattern.table, columns, 'composite', includePartialIndexes)
+            sql: this.generateIndexSQL(pattern.table, columns, 'composite', includePartialIndexes),
         };
     }
     /**
@@ -269,12 +277,14 @@ export class SQLiteAutoIndexer {
             this.existingIndexes.clear();
             for (const row of result) {
                 const columns = this.extractColumnsFromSQL(row.sql || '');
-                this.existingIndexes.set(row.name, [{
+                this.existingIndexes.set(row.name, [
+                    {
                         name: row.name,
                         table: row.tbl_name,
                         columns,
-                        sql: row.sql
-                    }]);
+                        sql: row.sql,
+                    },
+                ]);
             }
         }
         catch (error) {
@@ -299,8 +309,7 @@ export class SQLiteAutoIndexer {
     async findExistingIndex(db, table, columns) {
         for (const [indexName, indexes] of this.existingIndexes.entries()) {
             for (const index of indexes) {
-                if (index.table === table &&
-                    this.arraysEqual(index.columns, columns)) {
+                if (index.table === table && this.arraysEqual(index.columns, columns)) {
                     return indexName;
                 }
             }
@@ -343,7 +352,7 @@ export class SQLiteAutoIndexer {
      */
     generateIndexSQL(table, columns, type, includePartialIndexes) {
         const indexName = this.generateIndexName(table, columns);
-        const columnList = columns.map(col => `"${col}"`).join(', ');
+        const columnList = columns.map((col) => `"${col}"`).join(', ');
         let sql = `CREATE INDEX "${indexName}" ON "${table}" (${columnList})`;
         if (type === 'unique') {
             sql = sql.replace('CREATE INDEX', 'CREATE UNIQUE INDEX');
@@ -363,14 +372,15 @@ export class SQLiteAutoIndexer {
     getPriorityScore(recommendation) {
         const priorityScores = { critical: 4, high: 3, medium: 2, low: 1 };
         const impactScores = { high: 3, medium: 2, low: 1 };
-        return priorityScores[recommendation.priority] * impactScores[recommendation.estimatedImpact];
+        return (priorityScores[recommendation.priority] *
+            impactScores[recommendation.estimatedImpact]);
     }
     /**
      * Calculate overall performance impact
      */
     calculatePerformanceImpact(recommendations) {
-        const highImpactCount = recommendations.filter(r => r.estimatedImpact === 'high').length;
-        const mediumImpactCount = recommendations.filter(r => r.estimatedImpact === 'medium').length;
+        const highImpactCount = recommendations.filter((r) => r.estimatedImpact === 'high').length;
+        const mediumImpactCount = recommendations.filter((r) => r.estimatedImpact === 'medium').length;
         if (highImpactCount > 3)
             return 'high';
         if (highImpactCount > 0 || mediumImpactCount > 5)
@@ -381,8 +391,8 @@ export class SQLiteAutoIndexer {
      * Generate analysis summary
      */
     generateSummary(recommendations, redundantIndexes) {
-        const criticalCount = recommendations.filter(r => r.priority === 'critical').length;
-        const highCount = recommendations.filter(r => r.priority === 'high').length;
+        const criticalCount = recommendations.filter((r) => r.priority === 'critical').length;
+        const highCount = recommendations.filter((r) => r.priority === 'high').length;
         const redundantCount = redundantIndexes.length;
         let summary = `Found ${recommendations.length} index recommendations`;
         if (criticalCount > 0) {
@@ -401,7 +411,7 @@ export class SQLiteAutoIndexer {
      */
     deduplicateRecommendations(recommendations) {
         const seen = new Set();
-        return recommendations.filter(rec => {
+        return recommendations.filter((rec) => {
             const key = `${rec.table}:${rec.columns.join(',')}`;
             if (seen.has(key))
                 return false;
@@ -425,8 +435,9 @@ export class SQLiteAutoIndexer {
             return [];
         const whereClause = whereMatch[1];
         const columnMatches = whereClause.match(/(\w+)\s*[=<>]/g);
-        return columnMatches ?
-            columnMatches.map(match => match.replace(/\s*[=<>].*/, '').trim()) : [];
+        return columnMatches
+            ? columnMatches.map((match) => match.replace(/\s*[=<>].*/, '').trim())
+            : [];
     }
     /**
      * Extract ORDER BY columns from query
@@ -438,8 +449,11 @@ export class SQLiteAutoIndexer {
         const orderClause = orderMatch[1];
         return orderClause
             .split(',')
-            .map(col => col.trim().replace(/\s+(ASC|DESC).*$/i, '').replace(/["`]/g, ''))
-            .filter(col => col.length > 0);
+            .map((col) => col
+            .trim()
+            .replace(/\s+(ASC|DESC).*$/i, '')
+            .replace(/["`]/g, ''))
+            .filter((col) => col.length > 0);
     }
     /**
      * Extract JOIN columns from query
@@ -453,7 +467,7 @@ export class SQLiteAutoIndexer {
             const onClause = match.replace(/JOIN\s+\w+\s+ON\s+/i, '');
             const columnMatches = onClause.match(/(\w+)\s*=/g);
             if (columnMatches) {
-                columns.push(...columnMatches.map(m => m.replace(/\s*=.*/, '').trim()));
+                columns.push(...columnMatches.map((m) => m.replace(/\s*=.*/, '').trim()));
             }
         }
         return columns;
@@ -468,8 +482,8 @@ export class SQLiteAutoIndexer {
         if (match) {
             return match[1]
                 .split(',')
-                .map(col => col.trim().replace(/^\s*["']?|["']?\s*$/g, ''))
-                .filter(col => col.length > 0);
+                .map((col) => col.trim().replace(/^\s*["']?|["']?\s*$/g, ''))
+                .filter((col) => col.length > 0);
         }
         return [];
     }
@@ -527,12 +541,12 @@ export class SQLiteAutoIndexer {
         const patterns = Array.from(this.queryPatterns.values());
         const totalQueries = patterns.reduce((sum, p) => sum + p.frequency, 0);
         const averageFrequency = patterns.length > 0 ? totalQueries / patterns.length : 0;
-        const slowQueries = patterns.filter(p => p.averageExecutionTime > 1000).length;
+        const slowQueries = patterns.filter((p) => p.averageExecutionTime > 1000).length;
         return {
             totalPatterns: patterns.length,
             totalQueries,
             averageFrequency,
-            slowQueries
+            slowQueries,
         };
     }
 }