noormme 1.1.0 → 1.2.0

package/dist/esm/agentic/improvement/StrategicPlanner.js

@@ -27,9 +27,9 @@ export class StrategicPlanner {
         const mutations = [];
         // 0. Pre-Flight System Health Check (Phase 4)
         const tests = await this.cortex.tests.runAllProbes();
-        const failedTests = tests.filter(t => !t.success);
+        const failedTests = tests.filter((t) => !t.success);
         if (failedTests.length > 0) {
-            console.warn(`[StrategicPlanner] Mutation cycle aborted. System health probes failed: ${failedTests.map(t => t.name).join(', ')}`);
+            console.warn(`[StrategicPlanner] Mutation cycle aborted. System health probes failed: ${failedTests.map((t) => t.name).join(', ')}`);
             return [];
         }
         const personas = await this.typedDb
@@ -50,12 +50,20 @@ export class StrategicPlanner {
             const report = await this.analyzePersona(persona.id);
             // 3. Blacklist Check (Local & Global Phase 5)
             const lastMutation = persona.metadata?.last_failed_mutation;
-            const allPersonas = await this.typedDb.selectFrom(this.personasTable).selectAll().execute();
-            const isGloballyBlacklisted = allPersonas.some(p => {
+            const allPersonas = await this.typedDb
+                .selectFrom(this.personasTable)
+                .selectAll()
+                .execute();
+            const isGloballyBlacklisted = allPersonas.some((p) => {
                 const mp = this.parsePersona(p);
-                return mp.metadata?.last_failed_mutation?.type === report.recommendation && (Date.now() - (mp.metadata?.last_failed_mutation?.timestamp || 0) < 3600000);
+                return (mp.metadata?.last_failed_mutation?.type === report.recommendation &&
+                    Date.now() - (mp.metadata?.last_failed_mutation?.timestamp || 0) <
+                        3600000);
             });
-            if (isGloballyBlacklisted || (lastMutation && report.recommendation === lastMutation.type && (Date.now() - lastMutation.timestamp < 86400000))) {
+            if (isGloballyBlacklisted ||
+                (lastMutation &&
+                    report.recommendation === lastMutation.type &&
+                    Date.now() - lastMutation.timestamp < 86400000)) {
                 console.log(`[StrategicPlanner] Skipping blacklisted mutation ${report.recommendation} for persona ${persona.id} (Global=${isGloballyBlacklisted})`);
                 continue;
             }
@@ -74,22 +82,33 @@ export class StrategicPlanner {
      */
     async applyDirectMutation(persona, report, failures = []) {
         return await this.db.transaction().execute(async (trx) => {
-            const reason = failures.length > 0 ? `Failure Patterns: ${failures.join(', ')}` : report.recommendation;
+            const reason = failures.length > 0
+                ? `Failure Patterns: ${failures.join(', ')}`
+                : report.recommendation;
             console.log(`[StrategicPlanner] Applying direct mutation to persona ${persona.id} (Reason: ${reason})`);
             let updates = {};
             let mutationType = 'role_update';
             if (failures.length > 0) {
                 // Lesson-Driven Synthesis: Pull categories of lessons
                 const lessons = await this.cortex.reasoner.synthesizeLessons();
-                const relevantLessons = updates.role ? [] : (lessons['general'] || []).slice(0, 2);
-                updates = { role: `${persona.role || ''} (Optimized for: ${failures.join(', ')}. Patterns: ${relevantLessons.join('; ')})`.trim() };
+                const relevantLessons = updates.role
+                    ? []
+                    : (lessons['general'] || []).slice(0, 2);
+                updates = {
+                    role: `${persona.role || ''} (Optimized for: ${failures.join(', ')}. Patterns: ${relevantLessons.join('; ')})`.trim(),
+                };
             }
             else {
                 // Evolutionary Cross-Pollination (Phase 5)
-                const allPersonas = await this.typedDb.selectFrom(this.personasTable).selectAll().execute();
+                const allPersonas = await trx
+                    .selectFrom(this.personasTable)
+                    .selectAll()
+                    .execute();
                 const winningMutations = allPersonas
-                    .map(p => this.parsePersona(p))
-                    .filter(p => (p.metadata?.evolution_status === 'stable' || !p.metadata?.evolution_status) && p.metadata?.mutation_reason?.includes(report.recommendation));
+                    .map((p) => this.parsePersona(p))
+                    .filter((p) => (p.metadata?.evolution_status === 'stable' ||
+                    !p.metadata?.evolution_status) &&
+                    p.metadata?.mutation_reason?.includes(report.recommendation));
                 if (winningMutations.length > 0 && Math.random() > 0.5) {
                     console.log(`[StrategicPlanner] Cross-Pollinating success from Persona ${winningMutations[0].id}`);
                     updates = { role: winningMutations[0].role || persona.role };
@@ -97,10 +116,18 @@ export class StrategicPlanner {
                 else {
                     switch (report.recommendation) {
                         case 'optimize_accuracy':
-                            updates = { role: `${persona.role || ''} (Focus strictly on accuracy and detailed verification)`.trim() };
+                            updates = {
+                                role: `${persona.role || ''} (Focus strictly on accuracy and detailed verification)`.trim(),
+                            };
                             break;
                         case 'optimize_efficiency':
-                            updates = { policies: [...(persona.policies || []), 'timeout_reduction', 'concise_output'] };
+                            updates = {
+                                policies: [
+                                    ...(persona.policies || []),
+                                    'timeout_reduction',
+                                    'concise_output',
+                                ],
+                            };
                             mutationType = 'policy_update';
                             break;
                         case 'critical_intervention':
@@ -128,10 +155,10 @@ export class StrategicPlanner {
                 previousState: {
                     role: persona.role,
                     policies: persona.policies,
-                    capabilities: persona.capabilities
+                    capabilities: persona.capabilities,
                 },
                 newState: { ...updates },
-                reason: `Auto-mutation triggered by ${report.recommendation}`
+                reason: `Auto-mutation triggered by ${report.recommendation}`,
             };
             const history = [...(persona.metadata?.mutationHistory || []), mutation];
             if (history.length > 5)
@@ -144,17 +171,21 @@ export class StrategicPlanner {
                 verification_started_at: Date.now(),
                 verification_baseline: {
                     successRate: report.successRate,
-                    averageLatency: report.averageLatency
-                }
+                    averageLatency: report.averageLatency,
+                },
             };
             await trx
                 .updateTable(this.personasTable)
                 .set({
                 role: updates.role || persona.role,
-                policies: updates.policies ? JSON.stringify(updates.policies) : undefined,
-                capabilities: updates.capabilities ? JSON.stringify(updates.capabilities) : undefined,
+                policies: updates.policies
+                    ? JSON.stringify(updates.policies)
+                    : undefined,
+                capabilities: updates.capabilities
+                    ? JSON.stringify(updates.capabilities)
+                    : undefined,
                 metadata: JSON.stringify(newMetadata),
-                updated_at: new Date()
+                updated_at: new Date(),
             })
                 .where('id', '=', persona.id)
                 .execute();
@@ -169,15 +200,23 @@ export class StrategicPlanner {
         const report = await this.analyzePersona(persona.id);
         // Adaptive Meta-Tuning: Increase window based on rollback history (Phase 4)
         const rollbackHistory = persona.metadata?.rollbackHistory || [];
-        const recentRollbacks = rollbackHistory.filter(ts => (Date.now() - ts < 604800000)).length;
+        const recentRollbacks = rollbackHistory.filter((ts) => Date.now() - ts < 604800000).length;
         // Hive-Mind Verification Speedups (Phase 5)
-        const allPersonas = await this.typedDb.selectFrom(this.personasTable).selectAll().execute();
-        const hiveTrusted = allPersonas.map(p => this.parsePersona(p)).filter(p => p.metadata?.evolution_status === 'stable' && p.metadata?.mutation_reason === (persona.metadata?.mutation_reason)).length;
-        let sampleSizeThreshold = 10 + (recentRollbacks * 10);
+        const allPersonas = await this.typedDb
+            .selectFrom(this.personasTable)
+            .selectAll()
+            .execute();
+        const hiveTrusted = allPersonas
+            .map((p) => this.parsePersona(p))
+            .filter((p) => p.metadata?.evolution_status === 'stable' &&
+            p.metadata?.mutation_reason === persona.metadata?.mutation_reason).length;
+        let sampleSizeThreshold = 10 + recentRollbacks * 10;
         // Pass 5: Adaptive Verification Windows
         // If a mutation is performing exceptionally well early on (Z-score check), accelerate stabilization.
         const earlyStats = await this.analyzePersona(persona.id);
-        const earlyBaseline = persona.metadata?.verification_baseline || { successRate: 0.8 };
+        const earlyBaseline = persona.metadata?.verification_baseline || {
+            successRate: 0.8,
+        };
         const earlyZ = (earlyStats.successRate - earlyBaseline.successRate) / 0.1; // Use nominal stdDev for early check
         if (earlyZ > 3.0 && earlyStats.sampleSize >= 5) {
             console.log(`[StrategicPlanner] High Performance Detected (Z=${earlyZ.toFixed(2)}). Accelerating stabilization threshold.`);
@@ -189,14 +228,18 @@ export class StrategicPlanner {
         }
         if (report.sampleSize < sampleSizeThreshold)
             return null;
-        const baseline = persona.metadata?.verification_baseline || { successRate: 0.8, averageLatency: 500 };
+        const baseline = persona.metadata?.verification_baseline || {
+            successRate: 0.8,
+            averageLatency: 500,
+        };
         // Dynamic Variance Calculation (Intelligence Refinement)
         const recentMetrics = await this.cortex.metrics.getRecentMetrics(100);
         const values = recentMetrics
-            .filter(m => m.metricName === 'success_rate')
-            .map(m => Number(m.metricValue));
+            .filter((m) => m.metricName === 'success_rate')
+            .map((m) => Number(m.metricValue));
         const mean = values.reduce((a, b) => a + b, 0) / (values.length || 1);
-        const variance = values.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / (values.length || 1);
+        const variance = values.reduce((a, b) => a + Math.pow(b - mean, 2), 0) /
+            (values.length || 1);
         const stdDev = Math.sqrt(variance) || 0.1;
         const zScore = (report.successRate - baseline.successRate) / (stdDev || 1);
         console.log(`[StrategicPlanner] Verifying persona ${persona.id}: Success=${report.successRate.toFixed(2)} (Baseline=${baseline.successRate.toFixed(2)}, σ=${stdDev.toFixed(3)}, Z-Score=${zScore.toFixed(2)}, Threshold=${sampleSizeThreshold})`);
@@ -206,18 +249,26 @@ export class StrategicPlanner {
             return await this.rollbackPersona(persona.id);
         }
         // 2. Stabilization (Proven improvement or stability)
-        if (report.sampleSize >= (sampleSizeThreshold * 2) && zScore >= -0.5) {
+        if (report.sampleSize >= sampleSizeThreshold * 2 && zScore >= -0.5) {
             console.log(`[StrategicPlanner] Evolution for persona ${persona.id} STABILIZED.`);
             // Cognitive Rule Distillation (Phase 4)
             if (persona.metadata?.mutation_reason?.includes('optimize_efficiency')) {
                 await this.cortex.rules.defineRule('all', 'all', 'audit', {
                     condition: 'latency > 500',
                     priority: 10,
-                    metadata: { reason: `Distilled from successful persona ${persona.id} optimization` }
+                    metadata: {
+                        reason: `Distilled from successful persona ${persona.id} optimization`,
+                    },
                 });
             }
-            await this.db.updateTable(this.personasTable)
-                .set({ metadata: JSON.stringify({ ...persona.metadata, evolution_status: 'stable' }) })
+            await this.db
+                .updateTable(this.personasTable)
+                .set({
+                metadata: JSON.stringify({
+                    ...persona.metadata,
+                    evolution_status: 'stable',
+                }),
+            })
                 .where('id', '=', persona.id)
                 .execute();
             return `Evolution stabilized for persona ${persona.id}`;
@@ -239,7 +290,7 @@ export class StrategicPlanner {
         try {
             const failureReport = await this.cortex.actions.getFailureReport();
             // Only consider tools that failed more than once
-            const frequentFailures = failureReport.filter(f => f.failureCount > 1);
+            const frequentFailures = failureReport.filter((f) => f.failureCount > 1);
             for (const fail of frequentFailures) {
                 patterns.push(`tool_failure_${fail.toolName}`);
             }
@@ -259,7 +310,7 @@ export class StrategicPlanner {
             .selectAll()
             .where((eb) => eb.or([
             eb(sql `json_extract(metadata, '$.persona_id')`, '=', id),
-            eb(sql `metadata->>'persona_id'`, '=', String(id))
+            eb(sql `metadata->>'persona_id'`, '=', String(id)),
         ]))
             .orderBy('created_at', 'desc')
             .limit(50)
@@ -267,7 +318,9 @@ export class StrategicPlanner {
         // 1. Fetch Global Baseline for Dynamic Thresholds
         const globalMetrics = await this.cortex.metrics.getRecentMetrics(200);
         const calcStats = (metricName) => {
-            const vals = globalMetrics.filter(m => m.metricName === metricName).map(m => Number(m.metricValue));
+            const vals = globalMetrics
+                .filter((m) => m.metricName === metricName)
+                .map((m) => Number(m.metricValue));
             if (vals.length < 10)
                 return { mean: metricName === 'query_latency' ? 500 : 0.9, stdDev: 0.1 };
             const mean = vals.reduce((a, b) => a + b, 0) / vals.length;
@@ -282,25 +335,27 @@ export class StrategicPlanner {
                 successRate: successStats.mean,
                 averageLatency: latencyStats.mean,
                 sampleSize: 0,
-                recommendation: 'maintain'
+                recommendation: 'maintain',
             };
         }
-        const successMetrics = recentMetrics.filter(m => m.metric_name === 'task_success_rate');
-        const latencyMetrics = recentMetrics.filter(m => m.metric_name === 'query_latency');
+        const successMetrics = recentMetrics.filter((m) => m.metric_name === 'task_success_rate');
+        const latencyMetrics = recentMetrics.filter((m) => m.metric_name === 'query_latency');
         const avgSuccess = successMetrics.length > 0
-            ? successMetrics.reduce((sum, m) => sum + Number(m.metric_value), 0) / successMetrics.length
+            ? successMetrics.reduce((sum, m) => sum + Number(m.metric_value), 0) /
+                successMetrics.length
             : successStats.mean;
         const avgLatency = latencyMetrics.length > 0
-            ? latencyMetrics.reduce((sum, m) => sum + Number(m.metric_value), 0) / latencyMetrics.length
+            ? latencyMetrics.reduce((sum, m) => sum + Number(m.metric_value), 0) /
+                latencyMetrics.length
             : latencyStats.mean;
         let recommendation = 'maintain';
         // 2. Map Dynamic Thresholds to Recommendations
         // Critical: Worse than 2.5 standard deviations from mean
-        const criticalThreshold = successStats.mean - (2.5 * successStats.stdDev);
+        const criticalThreshold = successStats.mean - 2.5 * successStats.stdDev;
         // Optimize: Worse than 1.0 standard deviations from mean
-        const accuracyThreshold = successStats.mean - (1.0 * successStats.stdDev);
+        const accuracyThreshold = successStats.mean - 1.0 * successStats.stdDev;
         // Efficiency: Latency > 2 standard deviations above mean
-        const efficiencyThreshold = latencyStats.mean + (2.0 * latencyStats.stdDev);
+        const efficiencyThreshold = latencyStats.mean + 2.0 * latencyStats.stdDev;
         if (avgSuccess < criticalThreshold) {
             recommendation = 'critical_intervention';
         }
@@ -316,7 +371,7 @@ export class StrategicPlanner {
             successRate: avgSuccess,
             averageLatency: avgLatency,
             sampleSize: recentMetrics.length,
-            recommendation
+            recommendation,
         };
     }
     /**
@@ -352,19 +407,23 @@ export class StrategicPlanner {
                 rollbackHistory: rollbackHistory,
                 last_failed_mutation: {
                     type: lastMutation.type,
-                    timestamp: Date.now()
+                    timestamp: Date.now(),
                 },
                 evolution_status: 'stable',
-                lastRollback: Date.now()
+                lastRollback: Date.now(),
             };
             await trx
                 .updateTable(this.personasTable)
                 .set({
                 role: previous.role,
-                policies: previous.policies ? JSON.stringify(previous.policies) : undefined,
-                capabilities: previous.capabilities ? JSON.stringify(previous.capabilities) : undefined,
+                policies: previous.policies
+                    ? JSON.stringify(previous.policies)
+                    : undefined,
+                capabilities: previous.capabilities
+                    ? JSON.stringify(previous.capabilities)
+                    : undefined,
                 metadata: JSON.stringify(newMetadata),
-                updated_at: new Date()
+                updated_at: new Date(),
             })
                 .where('id', '=', id)
                 .execute();
@@ -376,11 +435,17 @@ export class StrategicPlanner {
             id: p.id,
             name: p.name,
             role: p.role,
-            capabilities: typeof p.capabilities === 'string' ? JSON.parse(p.capabilities) : (p.capabilities || []),
-            policies: typeof p.policies === 'string' ? JSON.parse(p.policies) : (p.policies || []),
-            metadata: typeof p.metadata === 'string' ? JSON.parse(p.metadata) : (p.metadata || {}),
+            capabilities: typeof p.capabilities === 'string'
+                ? JSON.parse(p.capabilities)
+                : p.capabilities || [],
+            policies: typeof p.policies === 'string'
+                ? JSON.parse(p.policies)
+                : p.policies || [],
+            metadata: typeof p.metadata === 'string'
+                ? JSON.parse(p.metadata)
+                : p.metadata || {},
             createdAt: new Date(p.created_at),
-            updatedAt: new Date(p.updated_at)
+            updatedAt: new Date(p.updated_at),
         };
     }
 }

package/dist/esm/agentic/telemetry/CognitiveSynthesizer.js

@@ -11,7 +11,8 @@ export class CognitiveSynthesizer {
     constructor(db, config = {}) {
         this.db = db;
         this.config = config;
-        this.evolutionTable = config.sessionEvolutionTable || 'agent_session_evolution';
+        this.evolutionTable =
+            config.sessionEvolutionTable || 'agent_session_evolution';
     }
     /**
      * Infer goals and update session evolution with production-grade persistence.
@@ -31,12 +32,13 @@ export class CognitiveSynthesizer {
                 if (existing) {
                     const currentPath = this.parsePath(existing.evolution_path);
                     // Only append to path if goal or strategy shifted significantly
-                    if (existing.inferred_goal !== goalInferred || existing.strategy !== strategy) {
+                    if (existing.inferred_goal !== goalInferred ||
+                        existing.strategy !== strategy) {
                         currentPath.push({
                             timestamp: new Date().toISOString(),
                             previousGoal: existing.inferred_goal,
                             newGoal: goalInferred,
-                            strategyShift: strategy
+                            strategyShift: strategy,
                         });
                     }
                     await trx
@@ -47,7 +49,7 @@ export class CognitiveSynthesizer {
                         evolution_path: JSON.stringify(currentPath),
                         status: 'active',
                         autonomy_level: this.calculateAutonomy(currentPath.length, existing.autonomy_level || 1),
-                        updated_at: new Date()
+                        updated_at: new Date(),
                     })
                         .where('session_id', '=', sessionId)
                         .execute();
@@ -59,14 +61,16 @@ export class CognitiveSynthesizer {
                         session_id: sessionId,
                         inferred_goal: goalInferred,
                         strategy,
-                        evolution_path: JSON.stringify([{
+                        evolution_path: JSON.stringify([
+                            {
                                 timestamp: new Date().toISOString(),
                                 event: 'session_start',
-                                initialGoal: goalInferred
-                            }]),
+                                initialGoal: goalInferred,
+                            },
+                        ]),
                         status: 'active',
                         autonomy_level: 1,
-                        updated_at: new Date()
+                        updated_at: new Date(),
                     })
                         .execute();
                 }
@@ -95,7 +99,9 @@ export class CognitiveSynthesizer {
                     timestamp: new Date().toISOString(),
                     type: 'shift',
                     shift: shiftType,
-                    reason: shiftType === 'abandonment' ? 'User manual termination or lack of progress' : 'Strategic goal shift'
+                    reason: shiftType === 'abandonment'
+                        ? 'User manual termination or lack of progress'
+                        : 'Strategic goal shift',
                 });
                 await trx
                     .updateTable(this.evolutionTable)
@@ -103,7 +109,7 @@ export class CognitiveSynthesizer {
                     status: shiftType === 'pivot' ? 'pivoted' : 'abandoned',
                     strategy: shiftType === 'pivot' ? 'Strategic Pivot' : 'Terminated',
                     evolution_path: JSON.stringify(currentPath),
-                    updated_at: new Date()
+                    updated_at: new Date(),
                 })
                     .where('session_id', '=', sessionId)
                     .execute();
@@ -119,7 +125,15 @@ export class CognitiveSynthesizer {
         if (clean.length < 100)
             return clean;
         // Simple heuristic: look for "need", "want", "please", "can you"
-        const keywords = ['need', 'want', 'please', 'can you', 'implement', 'fix', 'add'];
+        const keywords = [
+            'need',
+            'want',
+            'please',
+            'can you',
+            'implement',
+            'fix',
+            'add',
+        ];
         for (const kw of keywords) {
             const index = clean.toLowerCase().indexOf(kw);
             if (index !== -1) {
@@ -139,7 +153,7 @@ export class CognitiveSynthesizer {
         return 'Adaptive Exploration';
     }
     calculateAutonomy(pivots, currentLevel) {
-        // Logic: frequent pivots without completion decrease autonomy. 
+        // Logic: frequent pivots without completion decrease autonomy.
         // Consistent execution increases it.
         if (pivots > 5)
             return Math.min(4, currentLevel + 1);

package/dist/esm/agentic/telemetry/EventHarvester.js

@@ -6,7 +6,8 @@ export class EventHarvester {
     constructor(db, config = {}) {
         this.db = db;
         this.config = config;
-        this.telemetryTable = config.telemetryEventsTable || 'agent_telemetry_events';
+        this.telemetryTable =
+            config.telemetryEventsTable || 'agent_telemetry_events';
     }
     /**
      * Persist a raw telemetry event
@@ -20,7 +21,7 @@ export class EventHarvester {
                 type,
                 content,
                 metadata: metadata ? JSON.stringify(metadata) : null,
-                created_at: new Date()
+                created_at: new Date(),
             })
                 .execute();
         }

package/dist/esm/agentic/telemetry/ResearchAlchemist.js

@@ -20,7 +20,7 @@ export class ResearchAlchemist {
                 metric_name: metricName,
                 value: value,
                 metadata: metadata ? JSON.stringify(metadata) : null,
-                created_at: new Date()
+                created_at: new Date(),
             })
                 .execute();
         }
@@ -40,7 +40,10 @@ export class ResearchAlchemist {
             .where('metadata', 'like', `%${taskType}%`)
             .executeTakeFirst();
         const discoveryValue = existing ? 0.1 : 1.0; // 1.0 for first-time discovery, 0.1 for repeat
-        await this.transmute(sessionId, 'discovery_index', discoveryValue, { taskType, firstDiscovery: !existing });
+        await this.transmute(sessionId, 'discovery_index', discoveryValue, {
+            taskType,
+            firstDiscovery: !existing,
+        });
     }
     /**
      * Record a "Magic" moment

package/dist/esm/cache/cache-manager.js

@@ -38,7 +38,7 @@ export class CacheManager {
         const item = {
             value,
             timestamp: Date.now(),
-            ttl: ttl || this.config.ttl || 300000 // 5 minutes default
+            ttl: ttl || this.config.ttl || 300000, // 5 minutes default
         };
         // Refresh LRU position if exists
         if (this.cache.has(key)) {
@@ -74,7 +74,7 @@ export class CacheManager {
             size: this.cache.size,
             hits: this.hits,
             misses: this.misses,
-            hitRate: total > 0 ? this.hits / total : 0
+            hitRate: total > 0 ? this.hits / total : 0,
         };
     }
     /**
@@ -157,12 +157,15 @@ export class CacheManager {
      * Get all cache values
      */
     values() {
-        return Array.from(this.cache.values()).map(item => item.value);
+        return Array.from(this.cache.values()).map((item) => item.value);
     }
     /**
      * Get all cache entries
      */
     entries() {
-        return Array.from(this.cache.entries()).map(([key, item]) => [key, item.value]);
+        return Array.from(this.cache.entries()).map(([key, item]) => [
+            key,
+            item.value,
+        ]);
     }
 }

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

@@ -13,11 +13,11 @@ export async function analyze(options) {
                 host: 'localhost',
                 port: 0,
                 username: '',
-                password: ''
+                password: '',
             },
             performance: {
-                enableQueryOptimization: true
-            }
+                enableQueryOptimization: true,
+            },
         });
         await db.initialize();
         console.log(chalk.gray(`📁 Database: ${databasePath}\n`));
@@ -106,7 +106,8 @@ export async function analyze(options) {
                 console.log(chalk.gray(`  Average query time: ${sqliteMetrics.averageQueryTime.toFixed(2)}ms`));
                 console.log(chalk.gray(`  Total queries executed: ${sqliteMetrics.totalQueries}`));
                 console.log(chalk.gray(`  Slow queries (>1000ms): ${sqliteMetrics.slowQueries}`));
-                if (metrics.warningCount && Object.keys(metrics.warningCount).length > 0) {
+                if (metrics.warningCount &&
+                    Object.keys(metrics.warningCount).length > 0) {
                     console.log(chalk.yellow('\n⚠️ Warnings:'));
                     Object.entries(metrics.warningCount).forEach(([type, count]) => {
                         console.log(chalk.gray(`  ${type}: ${count}`));