fscr 6.2.3 → 7.3.0

package/dist/lib/cache/monitor.js

@@ -0,0 +1,224 @@
+/**
+ * Cache monitoring and statistics
+ * @module cache/monitor
+ */
+
+import chalk from 'chalk';
+
+/**
+ * CacheMonitor - Collects and displays cache performance metrics
+ * @class
+ */
+class CacheMonitor {
+    /**
+     * Create a cache monitor
+     * @param {CacheManager} cacheManager - Cache manager instance
+     * @param {FileWatcher} [fileWatcher] - Optional file watcher instance
+     */
+    constructor(cacheManager, fileWatcher = null) {
+        this.cacheManager = cacheManager;
+        this.fileWatcher = fileWatcher;
+
+        // Performance tracking
+        this.metrics = {
+            coldCacheTime: [],
+            warmCacheTime: [],
+            avgColdTime: 0,
+            avgWarmTime: 0,
+            speedup: 0
+        };
+
+        // Listen to cache events
+        this._attachListeners();
+    }
+
+    /**
+     * Attach event listeners to cache manager
+     * @private
+     */
+    _attachListeners() {
+        this.cacheManager.on('hit', () => {
+            // Cache hit event
+        });
+
+        this.cacheManager.on('miss', () => {
+            // Cache miss event
+        });
+
+        this.cacheManager.on('invalidate', ({ key }) => {
+            // Invalidation event
+        });
+
+        this.cacheManager.on('evict', ({ key }) => {
+            // Eviction event
+        });
+
+        this.cacheManager.on('cleanup', ({ count }) => {
+            // Cleanup event
+        });
+    }
+
+    /**
+     * Record a cold cache operation time
+     * @param {number} timeMs - Time in milliseconds
+     */
+    recordColdCache(timeMs) {
+        this.metrics.coldCacheTime.push(timeMs);
+        this._updateAverages();
+    }
+
+    /**
+     * Record a warm cache operation time
+     * @param {number} timeMs - Time in milliseconds
+     */
+    recordWarmCache(timeMs) {
+        this.metrics.warmCacheTime.push(timeMs);
+        this._updateAverages();
+    }
+
+    /**
+     * Update average times and speedup
+     * @private
+     */
+    _updateAverages() {
+        if (this.metrics.coldCacheTime.length > 0) {
+            const sum = this.metrics.coldCacheTime.reduce((a, b) => a + b, 0);
+            this.metrics.avgColdTime = sum / this.metrics.coldCacheTime.length;
+        }
+
+        if (this.metrics.warmCacheTime.length > 0) {
+            const sum = this.metrics.warmCacheTime.reduce((a, b) => a + b, 0);
+            this.metrics.avgWarmTime = sum / this.metrics.warmCacheTime.length;
+        }
+
+        if (this.metrics.avgWarmTime > 0 && this.metrics.avgColdTime > 0) {
+            this.metrics.speedup = this.metrics.avgColdTime / this.metrics.avgWarmTime;
+        }
+    }
+
+    /**
+     * Get comprehensive statistics
+     * @returns {Object} Statistics object
+     */
+    getStats() {
+        const cacheStats = this.cacheManager.getStats();
+        const watcherStats = this.fileWatcher ? this.fileWatcher.getStats() : null;
+
+        return {
+            cache: cacheStats,
+            watcher: watcherStats,
+            performance: {
+                avgColdTime: Math.round(this.metrics.avgColdTime),
+                avgWarmTime: Math.round(this.metrics.avgWarmTime),
+                speedup: this.metrics.speedup.toFixed(2) + 'x',
+                coldCacheSamples: this.metrics.coldCacheTime.length,
+                warmCacheSamples: this.metrics.warmCacheTime.length
+            }
+        };
+    }
+
+    /**
+     * Print statistics to console
+     * @param {Object} [options] - Display options
+     * @param {boolean} [options.verbose=false] - Show detailed stats
+     */
+    printStats(options = {}) {
+        const verbose = options.verbose || false;
+        const stats = this.getStats();
+
+        console.log('\n' + chalk.bold.cyan('=== Cache Statistics ==='));
+
+        // Cache stats
+        console.log(chalk.bold('\nCache:'));
+        console.log(`  Size: ${chalk.green(stats.cache.size)}/${stats.cache.maxSize}`);
+        console.log(`  Hits: ${chalk.green(stats.cache.hits)}`);
+        console.log(`  Misses: ${chalk.yellow(stats.cache.misses)}`);
+        console.log(`  Hit Rate: ${this._colorizeHitRate(stats.cache.hitRate)}%`);
+        console.log(`  Invalidations: ${chalk.yellow(stats.cache.invalidations)}`);
+        console.log(`  Evictions: ${chalk.yellow(stats.cache.evictions)}`);
+
+        // Performance stats
+        if (stats.performance.warmCacheSamples > 0) {
+            console.log(chalk.bold('\nPerformance:'));
+            console.log(`  Cold Cache: ${chalk.yellow(stats.performance.avgColdTime + 'ms')}`);
+            console.log(`  Warm Cache: ${chalk.green(stats.performance.avgWarmTime + 'ms')}`);
+            console.log(`  Speedup: ${chalk.bold.green(stats.performance.speedup)}`);
+        }
+
+        // File watcher stats
+        if (stats.watcher) {
+            console.log(chalk.bold('\nFile Watcher:'));
+            console.log(`  Files Watched: ${chalk.green(stats.watcher.filesWatched)}`);
+            console.log(`  Change Events: ${chalk.yellow(stats.watcher.changeEvents)}`);
+            console.log(`  Invalidations: ${chalk.yellow(stats.watcher.invalidations)}`);
+
+            if (verbose && stats.watcher.watchedFiles.length > 0) {
+                console.log(chalk.bold('\n  Watched Files:'));
+                stats.watcher.watchedFiles.forEach(file => {
+                    console.log(`    - ${chalk.gray(file)}`);
+                });
+            }
+        }
+
+        // Uptime
+        const uptimeMinutes = Math.floor(stats.cache.uptime / 60000);
+        console.log(chalk.bold('\nUptime:'), chalk.green(`${uptimeMinutes} minutes`));
+
+        console.log(chalk.bold.cyan('\n========================\n'));
+    }
+
+    /**
+     * Colorize hit rate based on percentage
+     * @private
+     * @param {string|number} hitRate - Hit rate percentage
+     * @returns {string} Colored hit rate
+     */
+    _colorizeHitRate(hitRate) {
+        const rate = parseFloat(hitRate);
+        if (rate >= 80) return chalk.green(hitRate);
+        if (rate >= 50) return chalk.yellow(hitRate);
+        return chalk.red(hitRate);
+    }
+
+    /**
+     * Get summary statistics as a single line
+     * @returns {string} Summary string
+     */
+    getSummary() {
+        const stats = this.getStats();
+        const parts = [
+            `${stats.cache.size} entries`,
+            `${stats.cache.hitRate}% hit rate`
+        ];
+
+        if (stats.performance.warmCacheSamples > 0) {
+            parts.push(`${stats.performance.speedup} speedup`);
+        }
+
+        return parts.join(', ');
+    }
+
+    /**
+     * Export statistics as JSON
+     * @returns {string} JSON string
+     */
+    toJSON() {
+        return JSON.stringify(this.getStats(), null, 2);
+    }
+
+    /**
+     * Reset all metrics
+     */
+    resetMetrics() {
+        this.metrics = {
+            coldCacheTime: [],
+            warmCacheTime: [],
+            avgColdTime: 0,
+            avgWarmTime: 0,
+            speedup: 0
+        };
+        this.cacheManager.resetStats();
+    }
+}
+
+export default CacheMonitor;

package/dist/lib/commands/doctor.js

@@ -0,0 +1,225 @@
+import chalk from 'chalk';
+import boxen from 'boxen';
+import { checkNodeVersion } from '../diagnostics/nodeVersion.js';
+import { checkPackageManager } from '../diagnostics/packageManager.js';
+import { checkGit } from '../diagnostics/gitCheck.js';
+import {
+    checkFScriptsFile,
+    checkPackageJson,
+    checkTypeScript,
+    checkFilePermissions
+} from '../diagnostics/fileSystem.js';
+import { checkCache } from '../diagnostics/cache.js';
+import { checkStartupTime, checkMemoryUsage } from '../diagnostics/performance.js';
+
+/**
+ * Run all diagnostic checks
+ * @param {Object} options - Command options
+ * @returns {Promise<Object>} Results object
+ */
+export async function runDiagnostics(options = {}) {
+    const { fix = false, json = false } = options;
+
+    console.log(chalk.cyan.bold('\n🔍 Running FSCR diagnostics...\n'));
+
+    const checks = [
+        { name: 'nodeVersion', fn: checkNodeVersion, critical: true },
+        { name: 'packageManager', fn: checkPackageManager, critical: true },
+        { name: 'git', fn: checkGit, critical: false },
+        { name: 'fscriptsFile', fn: checkFScriptsFile, critical: false },
+        { name: 'packageJson', fn: checkPackageJson, critical: true },
+        { name: 'typescript', fn: checkTypeScript, critical: false },
+        { name: 'filePermissions', fn: checkFilePermissions, critical: true },
+        { name: 'cache', fn: checkCache, critical: false },
+        { name: 'startupTime', fn: checkStartupTime, critical: false },
+        { name: 'memoryUsage', fn: checkMemoryUsage, critical: false }
+    ];
+
+    const results = [];
+    let passedCount = 0;
+    let warningCount = 0;
+    let errorCount = 0;
+    let fixedCount = 0;
+
+    for (const check of checks) {
+        try {
+            const result = await check.fn();
+            results.push({ ...result, critical: check.critical });
+
+            // Display result
+            displayCheckResult(result);
+
+            // Count results
+            if (result.passed && !result.warning) {
+                passedCount++;
+            } else if (result.warning) {
+                warningCount++;
+            } else {
+                errorCount++;
+            }
+
+            // Auto-fix if requested
+            if (fix && !result.passed && result.canFix && result.fix) {
+                try {
+                    console.log(chalk.yellow(`   Attempting to fix...`));
+                    const fixMessage = await result.fix();
+                    console.log(chalk.green(`   ✓ Fixed: ${fixMessage}\n`));
+                    fixedCount++;
+                } catch (fixError) {
+                    console.log(chalk.red(`   ✗ Fix failed: ${fixError.message}\n`));
+                }
+            } else if (!result.passed && result.fixInstructions) {
+                console.log(chalk.gray(`   ${result.fixInstructions}\n`));
+            }
+        } catch (error) {
+            console.log(
+                chalk.red(`❌ ${check.name}\n   Error: ${error.message}\n`)
+            );
+            errorCount++;
+            results.push({
+                name: check.name,
+                passed: false,
+                error: error.message,
+                critical: check.critical
+            });
+        }
+    }
+
+    // Display summary (skip if JSON mode)
+    if (!json) {
+        displaySummary(passedCount, warningCount, errorCount, fixedCount);
+    }
+
+    // Return results object
+    return {
+        passed: errorCount === 0,
+        summary: {
+            passed: passedCount,
+            warnings: warningCount,
+            errors: errorCount,
+            fixed: fixedCount,
+            total: checks.length
+        },
+        results
+    };
+}
+
+/**
+ * Display check result
+ * @param {Object} result - Check result
+ */
+function displayCheckResult(result) {
+    let icon = '✅';
+    let color = 'green';
+
+    if (!result.passed) {
+        icon = '❌';
+        color = 'red';
+    } else if (result.warning) {
+        icon = '⚠️ ';
+        color = 'yellow';
+    }
+
+    console.log(chalk[color](`${icon} ${result.name}`));
+    console.log(chalk.gray(`   ${result.message}\n`));
+}
+
+/**
+ * Display summary
+ * @param {number} passed - Number of passed checks
+ * @param {number} warnings - Number of warnings
+ * @param {number} errors - Number of errors
+ * @param {number} fixed - Number of fixed issues
+ */
+function displaySummary(passed, warnings, errors, fixed) {
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log(chalk.bold('Summary:'));
+
+    if (passed > 0) {
+        console.log(chalk.green(`  ✅ Passed: ${passed}`));
+    }
+
+    if (warnings > 0) {
+        console.log(chalk.yellow(`  ⚠️  Warnings: ${warnings}`));
+    }
+
+    if (errors > 0) {
+        console.log(chalk.red(`  ❌ Errors: ${errors}`));
+    }
+
+    if (fixed > 0) {
+        console.log(chalk.cyan(`  🔧 Fixed: ${fixed}`));
+    }
+
+    console.log(chalk.gray('─'.repeat(50)));
+
+    // Overall status
+    if (errors === 0 && warnings === 0) {
+        console.log(
+            boxen(chalk.green.bold('✓ All checks passed!'), {
+                padding: 1,
+                margin: 1,
+                borderStyle: 'round',
+                borderColor: 'green'
+            })
+        );
+    } else if (errors === 0) {
+        console.log(
+            boxen(chalk.yellow.bold('⚠ System operational with warnings'), {
+                padding: 1,
+                margin: 1,
+                borderStyle: 'round',
+                borderColor: 'yellow'
+            })
+        );
+    } else {
+        console.log(
+            boxen(chalk.red.bold('✗ Issues found - please review above'), {
+                padding: 1,
+                margin: 1,
+                borderStyle: 'round',
+                borderColor: 'red'
+            })
+        );
+        console.log(
+            chalk.gray(
+                '\nTip: Run "fsr doctor --fix" to automatically fix some issues\n'
+            )
+        );
+    }
+}
+
+/**
+ * Doctor command handler
+ * @param {Object} argv - Command arguments
+ */
+export default async function doctor(argv) {
+    try {
+        const options = {
+            fix: argv.fix || false,
+            json: argv.json || false
+        };
+
+        const result = await runDiagnostics(options);
+
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+
+        // Exit with error code if there are critical failures
+        if (!result.passed) {
+            const criticalFailures = result.results.filter(
+                (r) => !r.passed && r.critical
+            );
+            if (criticalFailures.length > 0) {
+                process.exit(1);
+            }
+        }
+    } catch (error) {
+        console.error(chalk.red.bold(`\n❌ Doctor command failed: ${error.message}\n`));
+        if (argv.verbose) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}