nuclie 1.0.0

package/dist/commands/analyze.js

@@ -0,0 +1,295 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { log } from '../utils/logger.js';
+export async function generateAnalyzeReport(result, jsonOnly = false) {
+    const analysisData = {
+        totalSize: 0,
+        chunks: []
+    };
+    // Flatten results if multi-target
+    const targets = result.targets || [result];
+    for (const target of targets) {
+        if (!target.artifacts)
+            continue;
+        const targetName = target.target || 'default';
+        // Process Artifacts (Sizes)
+        for (const artifact of target.artifacts) {
+            if (artifact.type === 'map')
+                continue;
+            const artifactSize = artifact.source ? Buffer.byteLength(artifact.source) : 0;
+            analysisData.totalSize += artifactSize;
+            analysisData.chunks.push({
+                target: targetName,
+                fileName: artifact.fileName,
+                size: artifactSize,
+                modules: artifact.modules || []
+            });
+        }
+    }
+    // Process Events (Bottlenecks & Cache)
+    const events = result.events || [];
+    const moduleTimings = new Map();
+    const cacheStats = { hits: 0, misses: 0 };
+    events.forEach((e) => {
+        if (e.decision === 'cache_hit')
+            cacheStats.hits++;
+        if (e.decision === 'cache_miss' || e.name === 'transform:start')
+            cacheStats.misses++;
+    });
+    analysisData.cache = {
+        ...cacheStats,
+        ratio: cacheStats.hits + cacheStats.misses > 0
+            ? ((cacheStats.hits / (cacheStats.hits + cacheStats.misses)) * 100).toFixed(1)
+            : '0'
+    };
+    const transformEvents = events.filter((e) => e.name === 'transform:start' || e.name === 'transform:end');
+    const transformStarts = new Map();
+    transformEvents.forEach((e) => {
+        if (e.name === 'transform:start') {
+            transformStarts.set(e.id, e.timestamp);
+        }
+        else {
+            const start = transformStarts.get(e.id);
+            if (start) {
+                const duration = e.timestamp - start;
+                moduleTimings.set(e.id, (moduleTimings.get(e.id) || 0) + duration);
+            }
+        }
+    });
+    analysisData.bottlenecks = Array.from(moduleTimings.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10)
+        .map(([id, duration]) => ({ id, duration }));
+    if (jsonOnly) {
+        console.log(JSON.stringify(analysisData, null, 2));
+        return;
+    }
+    // Console Report
+    console.log('\n📊 Bundle Composition Analysis');
+    console.log('='.repeat(40));
+    for (const chunk of analysisData.chunks) {
+        console.log(`\n📦 Chunk: ${chunk.fileName} (${(chunk.size / 1024).toFixed(2)} KB) [${chunk.target}]`);
+        // Sort modules by size
+        const sortedModules = [...chunk.modules].sort((a, b) => b.size - a.size);
+        const topModules = sortedModules.slice(0, 10);
+        const tableData = topModules.map(m => ({
+            Module: m.id.length > 50 ? '...' + m.id.slice(-47) : m.id,
+            'Size (KB)': (m.size / 1024).toFixed(2),
+            '%': ((m.size / chunk.size) * 100).toFixed(1) + '%'
+        }));
+        if (tableData.length > 0) {
+            console.table(tableData);
+        }
+        else {
+            console.log('  (No module breakdown available)');
+        }
+        if (sortedModules.length > 10) {
+            console.log(`  ... and ${sortedModules.length - 10} more modules`);
+        }
+    }
+    console.log('\n' + '='.repeat(40));
+    console.log(`Total Bundle Size: ${(analysisData.totalSize / 1024).toFixed(2)} KB`);
+    if (analysisData.bottlenecks && analysisData.bottlenecks.length > 0) {
+        console.log('\n🐢 Top Transformation Bottlenecks');
+        console.log('='.repeat(40));
+        const bottleneckTable = analysisData.bottlenecks.map((b) => ({
+            Module: b.id.length > 60 ? '...' + b.id.slice(-57) : b.id,
+            'Time (ms)': b.duration.toFixed(2)
+        }));
+        console.table(bottleneckTable);
+    }
+    // Generate HTML Report
+    await generateHtmlReport(analysisData);
+    // Generate Chrome Trace for Flamegraphs (Phase 4.1)
+    await generateChromeTrace(events);
+}
+async function generateChromeTrace(events) {
+    const traceEvents = events
+        .filter(e => e.timestamp)
+        .map(e => ({
+        name: e.name || e.reason,
+        cat: e.stage,
+        ph: e.name?.endsWith(':start') ? 'B' : e.name?.endsWith(':end') ? 'E' : 'i',
+        ts: e.timestamp * 1000, // Chrome expects microseconds
+        pid: 1,
+        tid: 1,
+        args: e.data || {}
+    }));
+    const tracePath = path.join(process.cwd(), 'nuclie-trace.json');
+    await fs.writeFile(tracePath, JSON.stringify(traceEvents));
+    log.success(`Chrome Trace generated at: ${tracePath} (Open in Chrome DevTools -> Performance)`);
+}
+async function generateHtmlReport(data) {
+    const html = `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Nuclie Premium Bundle Analyzer</title>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=JetBrains+Mono&display=swap" rel="stylesheet">
+    <style>
+        :root {
+            --bg: #0b0f1a;
+            --card-bg: rgba(30, 41, 59, 0.7);
+            --border: rgba(51, 65, 85, 0.5);
+            --primary: #38bdf8;
+            --secondary: #818cf8;
+            --text: #f8fafc;
+            --text-dim: #94a3b8;
+            --success: #10b981;
+            --warning: #fbbf24;
+        }
+        * { box-sizing: border-box; margin: 0; padding: 0; }
+        body { 
+            font-family: 'Inter', sans-serif; 
+            background: var(--bg); 
+            color: var(--text); 
+            padding: 3rem;
+            line-height: 1.5;
+            background-image: 
+                radial-gradient(at 0% 0%, rgba(56, 189, 248, 0.05) 0px, transparent 50%),
+                radial-gradient(at 100% 100%, rgba(129, 140, 248, 0.05) 0px, transparent 50%);
+        }
+        .container { max-width: 1100px; margin: 0 auto; }
+        .header { 
+            display: flex; 
+            justify-content: space-between; 
+            align-items: flex-end; 
+            margin-bottom: 3rem; 
+            padding-bottom: 2rem;
+            border-bottom: 1px solid var(--border);
+        }
+        h1 { font-size: 2.5rem; font-weight: 700; letter-spacing: -0.025em; background: linear-gradient(to right, var(--primary), var(--secondary)); -webkit-background-clip: text; -webkit-text-fill-color: transparent; }
+        .stats { display: flex; gap: 2rem; text-align: right; }
+        .stat-label { font-size: 0.75rem; text-transform: uppercase; color: var(--text-dim); font-weight: 600; margin-bottom: 0.25rem; }
+        .stat-value { font-size: 1.25rem; font-weight: 700; color: var(--text); }
+        .card { 
+            background: var(--card-bg); 
+            backdrop-filter: blur(12px);
+            border: 1px solid var(--border);
+            border-radius: 16px; 
+            padding: 2rem; 
+            margin-bottom: 2rem; 
+            box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1); 
+        }
+        .card-title { 
+            display: flex; 
+            justify-content: space-between; 
+            align-items: center;
+            margin-bottom: 1.5rem; 
+            font-weight: 700; 
+            font-size: 1.125rem; 
+        }
+        .table-wrapper { overflow-x: auto; }
+        table { width: 100%; border-collapse: collapse; }
+        th { text-align: left; padding: 1rem 0.5rem; border-bottom: 1px solid var(--border); color: var(--text-dim); font-size: 0.8rem; text-transform: uppercase; font-weight: 600; }
+        td { padding: 1rem 0.5rem; border-bottom: 1px solid var(--border); font-family: 'JetBrains Mono', monospace; font-size: 0.8rem; }
+        .module-name { color: var(--text); font-weight: 500; }
+        .module-path { color: var(--text-dim); font-size: 0.75rem; }
+        .size-bar-container { width: 100%; height: 6px; background: rgba(51, 65, 85, 0.3); border-radius: 3px; overflow: hidden; margin-top: 4px; }
+        .size-bar { height: 100%; background: linear-gradient(90deg, var(--primary), var(--secondary)); border-radius: 3px; }
+        .badge { background: rgba(56, 189, 248, 0.1); color: var(--primary); padding: 4px 10px; border-radius: 6px; font-size: 0.7rem; font-weight: 600; border: 1px solid rgba(56, 189, 248, 0.2); }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <div>
+                <div class="stat-label">Project Report</div>
+                <h1>Nuclie Analyze</h1>
+            </div>
+            <div class="stats">
+                <div>
+                    <div class="stat-label">Total Size</div>
+                    <div class="stat-value">${(data.totalSize / 1024).toFixed(2)} KB</div>
+                </div>
+                <div>
+                    <div class="stat-label">Cache Hit Rate</div>
+                    <div class="stat-value" style="color: var(--success)">${data.cache?.ratio}%</div>
+                </div>
+            </div>
+        </div>
+
+        ${data.bottlenecks && data.bottlenecks.length > 0 ? `
+            <div class="card">
+                <div class="card-title" style="color: var(--warning)">
+                    <span>🐢 Performance Bottlenecks</span>
+                    <span class="badge" style="background: rgba(251, 191, 36, 0.1); color: var(--warning); border-color: rgba(251, 191, 36, 0.2)">High Latency</span>
+                </div>
+                <div class="table-wrapper">
+                    <table>
+                        <thead>
+                            <tr>
+                                <th>Transformation Module</th>
+                                <th style="width: 150px">Duration</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            ${data.bottlenecks.map((b) => `
+                                <tr>
+                                    <td title="${b.id}">
+                                        <div class="module-name">${b.id.split('/').pop()}</div>
+                                        <div class="module-path">${b.id.length > 60 ? '...' + b.id.slice(-57) : b.id}</div>
+                                    </td>
+                                    <td style="color: var(--warning)">${b.duration.toFixed(2)} ms</td>
+                                </tr>
+                            `).join('')}
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+        ` : ''}
+
+        ${data.chunks.map((chunk) => `
+            <div class="card">
+                <div class="card-title">
+                    <span>📦 ${chunk.fileName}</span>
+                    <div style="display: flex; gap: 0.5rem; align-items: center">
+                        <span class="badge" style="text-transform: capitalize">${chunk.target}</span>
+                        <span style="font-size: 0.875rem; color: var(--text-dim)">${(chunk.size / 1024).toFixed(2)} KB</span>
+                    </div>
+                </div>
+                <div class="table-wrapper">
+                    <table>
+                        <thead>
+                            <tr>
+                                <th>Module Dependency</th>
+                                <th style="width: 120px">Size</th>
+                                <th style="width: 200px">Share</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            ${chunk.modules.sort((a, b) => b.size - a.size).map((m) => {
+        const relPath = m.id.includes('node_modules') ? m.id.split('node_modules/')[1] : (m.id.startsWith('/') ? m.id.split('/').pop() : m.id);
+        return `
+                                <tr>
+                                    <td title="${m.id}">
+                                        <div class="module-name">${relPath}</div>
+                                        <div class="module-path">${m.id.length > 70 ? '...' + m.id.slice(-67) : m.id}</div>
+                                    </td>
+                                    <td>${(m.size / 1024).toFixed(2)} KB</td>
+                                    <td>
+                                        <div style="display: flex; align-items: center; gap: 10px">
+                                            <div class="size-bar-container">
+                                                <div class="size-bar" style="width: ${(m.size / chunk.size * 100).toFixed(1)}%"></div>
+                                            </div>
+                                            <span style="font-size: 0.7rem; color: var(--text-dim); min-width: 40px">${(m.size / chunk.size * 100).toFixed(1)}%</span>
+                                        </div>
+                                    </td>
+                                </tr>
+                                `;
+    }).join('')}
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+        `).join('')}
+    </div>
+</body>
+</html>
+    `;
+    const reportPath = path.join(process.cwd(), 'nuclie-report.html');
+    await fs.writeFile(reportPath, html);
+    log.success(`Premium Report generated at: ${reportPath}`);
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1,21 @@
+export declare class NuclieDoctor {
+    private cwd;
+    private checks;
+    constructor(cwd: string);
+    diagnose(): Promise<void>;
+    private checkNodeVersion;
+    private checkPackageJson;
+    private checkNuclieConfig;
+    private checkDependencies;
+    private checkGitIgnore;
+    private checkEnvironment;
+    private checkDiskSpace;
+    private checkPortAvailability;
+    private checkCacheHealth;
+    private getDirectorySize;
+    private checkPerformance;
+    private findFiles;
+    private addCheck;
+    private printReport;
+}
+export declare function runDoctor(cwd?: string): Promise<void>;

package/dist/commands/doctor.js

@@ -0,0 +1,364 @@
+import fs from 'fs';
+import path from 'path';
+import { loadConfig } from '../config/index.js';
+import os from 'os';
+export class NuclieDoctor {
+    constructor(cwd) {
+        this.checks = [];
+        this.cwd = cwd;
+    }
+    async diagnose() {
+        console.log('\n🩺 Nuclie Doctor - Running Diagnostics...\n');
+        await this.checkNodeVersion();
+        await this.checkPackageJson();
+        await this.checkNuclieConfig();
+        await this.checkDependencies();
+        await this.checkGitIgnore();
+        await this.checkEnvironment();
+        await this.checkDiskSpace();
+        await this.checkPortAvailability();
+        await this.checkCacheHealth();
+        await this.checkPerformance(); // Day 56: Performance diagnostics
+        this.printReport();
+    }
+    async checkNodeVersion() {
+        const nodeVersion = process.version;
+        const major = parseInt(nodeVersion.slice(1).split('.')[0]);
+        if (major >= 20) {
+            this.addCheck('Node.js Version', 'pass', `${nodeVersion} (recommended)`);
+        }
+        else if (major >= 18) {
+            this.addCheck('Node.js Version', 'warn', `${nodeVersion} (works, but v20+ recommended)`);
+        }
+        else {
+            this.addCheck('Node.js Version', 'fail', `${nodeVersion} (unsupported, v18+ required)`, 'Upgrade to Node.js v20+');
+        }
+    }
+    async checkPackageJson() {
+        const pkgPath = path.join(this.cwd, 'package.json');
+        if (!fs.existsSync(pkgPath)) {
+            this.addCheck('package.json', 'fail', 'Not found', 'Run `npm init` to create package.json');
+            return;
+        }
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            // Check for nuclie in dependencies
+            const hasNuclie = pkg.dependencies?.nuclie || pkg.devDependencies?.nuclie;
+            if (hasNuclie) {
+                this.addCheck('package.json', 'pass', `Nuclie ${hasNuclie} configured`);
+            }
+            else {
+                this.addCheck('package.json', 'warn', 'Nuclie not in dependencies', 'Run `npm install nuclie`');
+            }
+            // Check for scripts
+            if (pkg.scripts?.dev || pkg.scripts?.build) {
+                this.addCheck('npm scripts', 'pass', 'Build scripts configured');
+            }
+            else {
+                this.addCheck('npm scripts', 'warn', 'No dev/build scripts', 'Add "dev": "nuclie dev" and "build": "nuclie build"');
+            }
+        }
+        catch (e) {
+            this.addCheck('package.json', 'fail', 'Invalid JSON', 'Fix JSON syntax errors');
+        }
+    }
+    async checkNuclieConfig() {
+        const configPaths = [
+            'nuclie.config.ts',
+            'nuclie.config.js',
+            'nuclie.config.mjs'
+        ];
+        const configFile = configPaths.find(p => fs.existsSync(path.join(this.cwd, p)));
+        if (configFile) {
+            try {
+                const config = await loadConfig(this.cwd);
+                this.addCheck('Nuclie Config', 'pass', `Found ${configFile}`);
+                // Validate config
+                if (!config.entry || config.entry.length === 0) {
+                    this.addCheck('Config Validation', 'warn', 'No entry points defined');
+                }
+                else {
+                    this.addCheck('Config Validation', 'pass', `${config.entry.length} entry point(s)`);
+                }
+            }
+            catch (e) {
+                this.addCheck('Nuclie Config', 'fail', `Error loading config: ${e.message}`, 'Check config syntax');
+            }
+        }
+        else {
+            this.addCheck('Nuclie Config', 'warn', 'No config file found', 'Run `nuclie init` to create one');
+        }
+    }
+    async checkDependencies() {
+        const nodeModules = path.join(this.cwd, 'node_modules');
+        if (!fs.existsSync(nodeModules)) {
+            this.addCheck('Dependencies', 'fail', 'node_modules not found', 'Run `npm install`');
+            return;
+        }
+        // Check for common issues
+        const lockFiles = ['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'bun.lockb'];
+        const foundLocks = lockFiles.filter(f => fs.existsSync(path.join(this.cwd, f)));
+        if (foundLocks.length > 1) {
+            this.addCheck('Lock Files', 'warn', `Multiple lock files found: ${foundLocks.join(', ')}`, 'Use only one package manager');
+        }
+        else if (foundLocks.length === 1) {
+            this.addCheck('Lock Files', 'pass', `Using ${foundLocks[0]}`);
+        }
+        else {
+            this.addCheck('Lock Files', 'warn', 'No lock file found', 'Commit your lock file to version control');
+        }
+    }
+    async checkGitIgnore() {
+        const gitignorePath = path.join(this.cwd, '.gitignore');
+        if (!fs.existsSync(gitignorePath)) {
+            this.addCheck('.gitignore', 'warn', 'Not found', 'Create .gitignore to exclude node_modules, dist, etc.');
+            return;
+        }
+        const gitignore = fs.readFileSync(gitignorePath, 'utf-8');
+        const requiredEntries = ['node_modules', 'dist', '.env'];
+        const missing = requiredEntries.filter(entry => !gitignore.includes(entry));
+        if (missing.length === 0) {
+            this.addCheck('.gitignore', 'pass', 'All essential entries present');
+        }
+        else {
+            this.addCheck('.gitignore', 'warn', `Missing: ${missing.join(', ')}`, `Add ${missing.join(', ')} to .gitignore`);
+        }
+    }
+    async checkEnvironment() {
+        const envPath = path.join(this.cwd, '.env');
+        const envExamplePath = path.join(this.cwd, '.env.example');
+        if (fs.existsSync(envPath)) {
+            this.addCheck('Environment', 'pass', '.env file found');
+            if (!fs.existsSync(envExamplePath)) {
+                this.addCheck('Environment Template', 'warn', '.env.example not found', 'Create .env.example for documentation');
+            }
+            else {
+                this.addCheck('Environment Template', 'pass', '.env.example found');
+            }
+        }
+        else {
+            this.addCheck('Environment', 'pass', 'No .env file (optional)');
+        }
+    }
+    async checkDiskSpace() {
+        try {
+            const stats = fs.statfsSync ? fs.statfsSync(this.cwd) : null;
+            if (stats) {
+                const freeGB = (stats.bavail * stats.bsize) / (1024 ** 3);
+                if (freeGB > 10) {
+                    this.addCheck('Disk Space', 'pass', `${freeGB.toFixed(1)} GB available`);
+                }
+                else if (freeGB > 1) {
+                    this.addCheck('Disk Space', 'warn', `${freeGB.toFixed(1)} GB available (low)`, 'Free up disk space');
+                }
+                else {
+                    this.addCheck('Disk Space', 'fail', `${freeGB.toFixed(1)} GB available (critical)`, 'Free up disk space immediately');
+                }
+            }
+            else {
+                this.addCheck('Disk Space', 'pass', 'Unable to check (platform limitation)');
+            }
+        }
+        catch (e) {
+            this.addCheck('Disk Space', 'pass', 'Unable to check');
+        }
+    }
+    async checkPortAvailability() {
+        const defaultPort = 5173;
+        try {
+            const config = await loadConfig(this.cwd);
+            const port = config.port || defaultPort;
+            // Simple check - try to see if something is listening
+            try {
+                const net = await import('net');
+                const server = net.createServer();
+                await new Promise((resolve, reject) => {
+                    server.once('error', (err) => {
+                        if (err.code === 'EADDRINUSE') {
+                            reject(new Error('Port in use'));
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                    server.once('listening', () => {
+                        server.close();
+                        resolve();
+                    });
+                    server.listen(port);
+                });
+                this.addCheck('Port Availability', 'pass', `Port ${port} is available`);
+            }
+            catch (e) {
+                if (e.message === 'Port in use') {
+                    this.addCheck('Port Availability', 'warn', `Port ${port} is in use`, `Stop the process using port ${port} or use --port flag`);
+                }
+                else {
+                    this.addCheck('Port Availability', 'pass', 'Unable to check');
+                }
+            }
+        }
+        catch (e) {
+            this.addCheck('Port Availability', 'pass', 'Config not loaded, skipping');
+        }
+    }
+    async checkCacheHealth() {
+        const cacheDir = path.join(this.cwd, 'node_modules', '.nuclie');
+        if (!fs.existsSync(cacheDir)) {
+            this.addCheck('Build Cache', 'pass', 'No cache yet (will be created on first build)');
+            return;
+        }
+        try {
+            const stats = fs.statSync(cacheDir);
+            const sizeBytes = this.getDirectorySize(cacheDir);
+            const sizeMB = sizeBytes / (1024 ** 2);
+            if (sizeMB > 1000) {
+                this.addCheck('Build Cache', 'warn', `${sizeMB.toFixed(0)} MB (large)`, 'Consider clearing cache with `rm -rf node_modules/.nuclie`');
+            }
+            else {
+                this.addCheck('Build Cache', 'pass', `${sizeMB.toFixed(0)} MB`);
+            }
+        }
+        catch (e) {
+            this.addCheck('Build Cache', 'pass', 'Unable to check cache size');
+        }
+    }
+    getDirectorySize(dirPath) {
+        let size = 0;
+        try {
+            const files = fs.readdirSync(dirPath);
+            for (const file of files) {
+                const filePath = path.join(dirPath, file);
+                const stats = fs.statSync(filePath);
+                if (stats.isDirectory()) {
+                    size += this.getDirectorySize(filePath);
+                }
+                else {
+                    size += stats.size;
+                }
+            }
+        }
+        catch (e) {
+            // Ignore errors
+        }
+        return size;
+    }
+    async checkPerformance() {
+        // Check if build output exists
+        const buildDir = path.join(this.cwd, 'build_output');
+        const distDir = path.join(this.cwd, 'dist');
+        const outputDir = fs.existsSync(buildDir) ? buildDir : fs.existsSync(distDir) ? distDir : null;
+        if (!outputDir) {
+            this.addCheck('Performance', 'pass', 'No build output yet (run `nuclie build` first)');
+            return;
+        }
+        try {
+            // Analyze bundle sizes
+            const jsFiles = this.findFiles(outputDir, '.js');
+            const totalSize = jsFiles.reduce((sum, file) => sum + fs.statSync(file).size, 0);
+            const totalKB = totalSize / 1024;
+            if (totalKB < 100) {
+                this.addCheck('Bundle Size', 'pass', `${totalKB.toFixed(1)} KB (excellent)`);
+            }
+            else if (totalKB < 300) {
+                this.addCheck('Bundle Size', 'pass', `${totalKB.toFixed(1)} KB (good)`);
+            }
+            else if (totalKB < 500) {
+                this.addCheck('Bundle Size', 'warn', `${totalKB.toFixed(1)} KB (consider optimization)`, 'Enable tree-shaking and minification');
+            }
+            else {
+                this.addCheck('Bundle Size', 'warn', `${totalKB.toFixed(1)} KB (large)`, 'Review dependencies and enable aggressive optimization');
+            }
+            // Check for source maps
+            const mapFiles = this.findFiles(outputDir, '.map');
+            if (mapFiles.length > 0) {
+                this.addCheck('Source Maps', 'pass', `${mapFiles.length} source map(s) generated`);
+            }
+            // Check for compression
+            const gzFiles = this.findFiles(outputDir, '.gz');
+            const brFiles = this.findFiles(outputDir, '.br');
+            if (gzFiles.length > 0 || brFiles.length > 0) {
+                this.addCheck('Compression', 'pass', `Gzip: ${gzFiles.length}, Brotli: ${brFiles.length}`);
+            }
+            else {
+                this.addCheck('Compression', 'warn', 'No compressed assets', 'Enable gzip/brotli compression for production');
+            }
+        }
+        catch (e) {
+            this.addCheck('Performance', 'pass', 'Unable to analyze build output');
+        }
+    }
+    findFiles(dir, ext) {
+        const files = [];
+        try {
+            const items = fs.readdirSync(dir);
+            for (const item of items) {
+                const fullPath = path.join(dir, item);
+                const stats = fs.statSync(fullPath);
+                if (stats.isDirectory()) {
+                    files.push(...this.findFiles(fullPath, ext));
+                }
+                else if (item.endsWith(ext)) {
+                    files.push(fullPath);
+                }
+            }
+        }
+        catch (e) {
+            // Ignore errors
+        }
+        return files;
+    }
+    addCheck(name, status, message, fix) {
+        this.checks.push({ name, status, message, fix });
+    }
+    printReport() {
+        console.log('\n📋 Diagnostic Report\n');
+        console.log('='.repeat(80));
+        const passed = this.checks.filter(c => c.status === 'pass').length;
+        const warnings = this.checks.filter(c => c.status === 'warn').length;
+        const failures = this.checks.filter(c => c.status === 'fail').length;
+        for (const check of this.checks) {
+            const icon = check.status === 'pass' ? '✅' : check.status === 'warn' ? '⚠️ ' : '❌';
+            const color = check.status === 'pass' ? '\x1b[32m' : check.status === 'warn' ? '\x1b[33m' : '\x1b[31m';
+            const reset = '\x1b[0m';
+            console.log(`${icon} ${color}${check.name}${reset}: ${check.message}`);
+            if (check.fix) {
+                console.log(`   💡 Fix: ${check.fix}`);
+            }
+        }
+        console.log('\n' + '='.repeat(80));
+        console.log(`\n📊 Summary: ${passed} passed, ${warnings} warnings, ${failures} failures\n`);
+        // System info
+        console.log('💻 System Information:');
+        console.log(`   OS: ${os.platform()} ${os.release()}`);
+        console.log(`   Node: ${process.version}`);
+        console.log(`   CPU: ${os.cpus()[0].model} (${os.cpus().length} cores)`);
+        console.log(`   Memory: ${(os.totalmem() / (1024 ** 3)).toFixed(1)} GB total, ${(os.freemem() / (1024 ** 3)).toFixed(1)} GB free`);
+        // Try to get Nuclie version
+        try {
+            const pkgPath = path.join(this.cwd, 'node_modules', 'nuclie', 'package.json');
+            if (fs.existsSync(pkgPath)) {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                console.log(`   Nuclie: v${pkg.version}`);
+            }
+        }
+        catch (e) {
+            // Ignore
+        }
+        console.log('');
+        if (failures > 0) {
+            console.log('❌ Critical issues found. Please address the failures above.\n');
+            process.exit(1);
+        }
+        else if (warnings > 0) {
+            console.log('⚠️  Some warnings detected. Consider addressing them for optimal performance.\n');
+        }
+        else {
+            console.log('✅ All checks passed! Your Nuclie project is healthy.\n');
+        }
+    }
+}
+export async function runDoctor(cwd = process.cwd()) {
+    const doctor = new NuclieDoctor(cwd);
+    await doctor.diagnose();
+}