noormme 1.1.0 → 1.2.0

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

@@ -18,11 +18,11 @@ async function optimize(options) {
                 host: 'localhost',
                 port: 0,
                 username: '',
-                password: ''
+                password: '',
             },
             performance: {
-                enableQueryOptimization: true
-            }
+                enableQueryOptimization: true,
+            },
         });
         await db.initialize();
         console.log(chalk_1.default.gray(`📁 Database: ${databasePath}`));
@@ -106,7 +106,7 @@ async function optimize(options) {
                     console.log(chalk_1.default.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/cjs/cli/commands/status.js

@@ -54,11 +54,11 @@ async function status(options) {
                 host: 'localhost',
                 port: 0,
                 username: '',
-                password: ''
+                password: '',
             },
             performance: {
-                enableQueryOptimization: true
-            }
+                enableQueryOptimization: true,
+            },
         });
         await db.initialize();
         console.log(chalk_1.default.gray(`📁 Database: ${databasePath}\n`));
@@ -113,7 +113,7 @@ async function status(options) {
                 console.log(chalk_1.default.gray(`  Free pages: ${metrics.freePages.toLocaleString()}`));
                 if (scoreFactors.length > 0) {
                     console.log(chalk_1.default.green(`\n  ✅ Performance factors:`));
-                    scoreFactors.forEach(factor => {
+                    scoreFactors.forEach((factor) => {
                         console.log(chalk_1.default.gray(`    • ${factor}`));
                     });
                 }
@@ -175,7 +175,9 @@ async function status(options) {
             const indexRecs = await db.getSQLiteIndexRecommendations();
             if (indexRecs.recommendations.length > 0) {
                 console.log(chalk_1.default.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_1.default.gray(`    ${index + 1}. ${rec.table}.${rec.column} - ${rec.reason}`));
                 });
                 if (indexRecs.recommendations.length > 5) {
@@ -264,7 +266,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 {
@@ -272,7 +274,7 @@ async function getAutomationStatus(db) {
             autoOptimization: true,
             queryAnalysis: true,
             autoIndexing: true,
-            schemaMonitoring: false
+            schemaMonitoring: false,
         };
     }
 }

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

@@ -53,11 +53,11 @@ 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');
@@ -76,7 +76,7 @@ async function watch(options) {
         db.onSchemaChange(async (changes) => {
             console.log(chalk_1.default.blue(`\n🔄 Schema changes detected at ${new Date().toLocaleTimeString()}`));
             console.log(chalk_1.default.yellow('📊 Changes detected:'));
-            changes.forEach(change => {
+            changes.forEach((change) => {
                 let msg = `  • ${change.type}: ${change.table}`;
                 if (change.column)
                     msg += `.${change.column}`;
@@ -120,12 +120,13 @@ 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_1.default.blue(`\n🔄 Periodic optimization check at ${new Date().toLocaleTimeString()}`));
                 try {
                     const metrics = await db.getSQLitePerformanceMetrics();

package/dist/cjs/cli/index.js

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

package/dist/cjs/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/cjs/cli/ui/spinner.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgenticSpinner = exports.AGENTIC_LOADING_MESSAGES = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+exports.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...'
+];
+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() * exports.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) % exports.AGENTIC_LOADING_MESSAGES.length;
+            }
+            const frame = chalk_1.default.cyan(this.frames[this.currentFrame]);
+            const agenticTone = chalk_1.default.gray(exports.AGENTIC_LOADING_MESSAGES[this.currentMessageIdx]);
+            const primaryText = this.baseMessage ? chalk_1.default.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_1.default.green(message)} `);
+    }
+    fail(message) {
+        this.stop();
+        console.log(`❌ ${chalk_1.default.red(message)} `);
+    }
+    info(message) {
+        this.stop();
+        console.log(`ℹ️  ${chalk_1.default.blue(message)} `);
+    }
+}
+exports.AgenticSpinner = AgenticSpinner;

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

@@ -42,7 +42,9 @@ 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/cjs/dialect/postgresql/postgresql-driver.js

@@ -114,7 +114,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/cjs/dialect/postgresql/postgresql-features.js

@@ -25,7 +25,9 @@ exports.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 (0, sql_js_1.sql) `ARRAY[${sql_js_1.sql.raw(literalValues)}]`;
     },
     /**
@@ -86,7 +88,9 @@ exports.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 (0, sql_js_1.sql) `array_append(${sql_js_1.sql.ref(column)}, ${sql_js_1.sql.raw(literal)})`;
     },
     /**
@@ -99,7 +103,9 @@ exports.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 (0, sql_js_1.sql) `array_remove(${sql_js_1.sql.ref(column)}, ${sql_js_1.sql.raw(literal)})`;
     },
     /**
@@ -178,7 +184,7 @@ exports.PostgresJSONHelpers = {
      * ```
      */
     hasAnyKey(column, keys) {
-        return (0, sql_js_1.sql) `${sql_js_1.sql.ref(column)} ?| ARRAY[${keys.map(k => `'${k}'`).join(', ')}]`;
+        return (0, sql_js_1.sql) `${sql_js_1.sql.ref(column)} ?| ARRAY[${keys.map((k) => `'${k}'`).join(', ')}]`;
     },
     /**
      * Check if JSON contains all keys
@@ -190,7 +196,7 @@ exports.PostgresJSONHelpers = {
      * ```
      */
     hasAllKeys(column, keys) {
-        return (0, sql_js_1.sql) `${sql_js_1.sql.ref(column)} ?& ARRAY[${keys.map(k => `'${k}'`).join(', ')}]`;
+        return (0, sql_js_1.sql) `${sql_js_1.sql.ref(column)} ?& ARRAY[${keys.map((k) => `'${k}'`).join(', ')}]`;
     },
     /**
      * Check if JSONB contains value
@@ -347,7 +353,9 @@ exports.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 (0, sql_js_1.sql) `
       ALTER TABLE ${sql_js_1.sql.table(table)}
       ADD COLUMN IF NOT EXISTS ${sql_js_1.sql.ref(columnName)} tsvector
@@ -373,7 +381,9 @@ exports.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 (0, sql_js_1.sql) `
       CREATE MATERIALIZED VIEW IF NOT EXISTS ${sql_js_1.sql.ref(viewName)}
       ${sql_js_1.sql.raw(tablespace)}
@@ -426,7 +436,7 @@ exports.PostgresMaterializedViewHelpers = {
      */
     async createUniqueIndex(db, viewName, columns, indexName) {
         const name = indexName || `${viewName}_${columns.join('_')}_idx`;
-        const columnList = columns.map(c => sql_js_1.sql.ref(c)).join(', ');
+        const columnList = columns.map((c) => sql_js_1.sql.ref(c)).join(', ');
         await (0, sql_js_1.sql) `
       CREATE UNIQUE INDEX IF NOT EXISTS ${sql_js_1.sql.ref(name)}
       ON ${sql_js_1.sql.ref(viewName)} (${sql_js_1.sql.raw(columnList)})

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

@@ -235,7 +235,7 @@ class PostgresIntrospector extends database_introspector_js_1.DatabaseIntrospect
             // 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',
@@ -253,7 +253,7 @@ class PostgresIntrospector extends database_introspector_js_1.DatabaseIntrospect
         // 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/cjs/dialect/sqlite/sqlite-auto-indexer.js

@@ -32,7 +32,9 @@ 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
@@ -44,7 +46,7 @@ class SQLiteAutoIndexer {
                 orderByColumns: this.extractOrderByColumns(query),
                 joinColumns: this.extractJoinColumns(query),
                 lastExecuted: new Date(),
-                averageExecutionTime: executionTime
+                averageExecutionTime: executionTime,
             };
             this.queryPatterns.set(normalizedQuery, newPattern);
         }
@@ -53,13 +55,13 @@ 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
@@ -78,7 +80,7 @@ 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);
@@ -126,7 +128,9 @@ 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);
@@ -138,7 +142,7 @@ 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
@@ -156,7 +160,9 @@ 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({
@@ -166,7 +172,7 @@ 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;
@@ -177,7 +183,9 @@ 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({
@@ -187,7 +195,7 @@ 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;
@@ -207,7 +215,7 @@ 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),
         };
     }
     /**
@@ -271,12 +279,14 @@ 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) {
@@ -301,8 +311,7 @@ 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;
                 }
             }
@@ -345,7 +354,7 @@ 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');
@@ -365,14 +374,15 @@ 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)
@@ -383,8 +393,8 @@ 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) {
@@ -403,7 +413,7 @@ 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;
@@ -427,8 +437,9 @@ 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
@@ -440,8 +451,11 @@ 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
@@ -455,7 +469,7 @@ 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;
@@ -470,8 +484,8 @@ 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 [];
     }
@@ -529,12 +543,12 @@ 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,
         };
     }
 }

package/dist/cjs/dialect/sqlite/sqlite-auto-optimizer.js

@@ -33,7 +33,7 @@ class SQLiteAutoOptimizer {
             journalMode: 'WAL',
             synchronous: 'NORMAL',
             cacheSize: -64000, // 64MB cache
-            tempStore: 'MEMORY'
+            tempStore: 'MEMORY',
         };
     }
     /**
@@ -41,7 +41,7 @@ class SQLiteAutoOptimizer {
      */
     async analyzeDatabase(db) {
         try {
-            const [pageCount, pageSize, freelistCount, schemaVersion, userVersion, applicationId, cacheSize, synchronous, journalMode, autoVacuum, tempStore, foreignKeys] = await Promise.all([
+            const [pageCount, pageSize, freelistCount, schemaVersion, userVersion, applicationId, cacheSize, synchronous, journalMode, autoVacuum, tempStore, foreignKeys,] = await Promise.all([
                 this.getPragmaValue(db, 'page_count'),
                 this.getPragmaValue(db, 'page_size'),
                 this.getPragmaValue(db, 'freelist_count'),
@@ -53,7 +53,7 @@ class SQLiteAutoOptimizer {
                 this.getPragmaValue(db, 'journal_mode'),
                 this.getPragmaValue(db, 'auto_vacuum'),
                 this.getPragmaValue(db, 'temp_store'),
-                this.getPragmaValue(db, 'foreign_keys')
+                this.getPragmaValue(db, 'foreign_keys'),
             ]);
             // Run integrity check
             const integrityResult = await (0, sql_js_1.sql) `PRAGMA integrity_check`.execute(db);
@@ -72,7 +72,7 @@ class SQLiteAutoOptimizer {
                 autoVacuum: Number(autoVacuum),
                 tempStore: Number(tempStore),
                 foreignKeys: Number(foreignKeys),
-                integrityCheck
+                integrityCheck,
             };
         }
         catch (error) {
@@ -88,7 +88,7 @@ class SQLiteAutoOptimizer {
             appliedOptimizations: [],
             recommendations: [],
             performanceImpact: 'low',
-            warnings: []
+            warnings: [],
         };
         try {
             // Analyze current state
@@ -288,7 +288,7 @@ class SQLiteAutoOptimizer {
                 .where('type', '=', 'table')
                 .where('name', 'not like', 'sqlite_%')
                 .execute();
-            return result.map(row => row.name);
+            return result.map((row) => row.name);
         }
         catch (error) {
             this.logger.debug('Failed to get table list:', error);
@@ -334,7 +334,8 @@ class SQLiteAutoOptimizer {
         }
         // Check database size
         const dbSize = metrics.pageCount * metrics.pageSize;
-        if (dbSize > 100 * 1024 * 1024) { // 100MB
+        if (dbSize > 100 * 1024 * 1024) {
+            // 100MB
             recommendations.push('For large databases, consider using SQLite backup API or .backup command for efficient backups.');
         }
         // Check for active transactions