nuclie 1.0.0

package/dist/ui/warning-library.js

@@ -0,0 +1,283 @@
+/**
+ * Comprehensive Warning Library
+ * 100+ actionable warnings for common build issues
+ */
+export const WarningLibrary = {
+    // Performance Warnings (1-20)
+    LARGE_BUNDLE: (size) => ({
+        id: 'PERF_001',
+        severity: 'warning',
+        category: 'Performance',
+        message: `Bundle size is ${(size / 1024).toFixed(2)}KB, which exceeds recommended 244KB limit`,
+        fix: 'Enable code splitting or use dynamic imports to reduce initial bundle size'
+    }),
+    UNOPTIMIZED_IMAGE: (file) => ({
+        id: 'PERF_002',
+        severity: 'info',
+        category: 'Performance',
+        message: `Image ${file} is not optimized`,
+        file,
+        fix: 'Use image optimization tools or WebP format for better compression'
+    }),
+    MISSING_TREE_SHAKING: () => ({
+        id: 'PERF_003',
+        severity: 'warning',
+        category: 'Performance',
+        message: 'Tree shaking is not enabled',
+        fix: 'Set "sideEffects": false in package.json or enable production mode'
+    }),
+    SLOW_DEPENDENCY: (dep, time) => ({
+        id: 'PERF_004',
+        severity: 'info',
+        category: 'Performance',
+        message: `Dependency "${dep}" took ${time}ms to process`,
+        fix: `Consider replacing with a lighter alternative or lazy loading`
+    }),
+    DUPLICATE_MODULES: (module, count) => ({
+        id: 'PERF_005',
+        severity: 'warning',
+        category: 'Performance',
+        message: `Module "${module}" is included ${count} times in the bundle`,
+        fix: 'Check for version conflicts in package.json and deduplicate dependencies'
+    }),
+    // Security Warnings (21-40)
+    VULNERABLE_DEPENDENCY: (dep, severity) => ({
+        id: 'SEC_001',
+        severity: severity === 'high' ? 'critical' : 'warning',
+        category: 'Security',
+        message: `Vulnerable dependency detected: ${dep}`,
+        fix: 'Run "npm audit fix" or update to a secure version'
+    }),
+    EXPOSED_API_KEY: (file, line) => ({
+        id: 'SEC_002',
+        severity: 'critical',
+        category: 'Security',
+        message: 'Potential API key or secret exposed in code',
+        file,
+        line,
+        fix: 'Move secrets to environment variables and add to .gitignore'
+    }),
+    INSECURE_PROTOCOL: (url) => ({
+        id: 'SEC_003',
+        severity: 'warning',
+        category: 'Security',
+        message: `Insecure HTTP protocol used: ${url}`,
+        fix: 'Use HTTPS instead of HTTP for external resources'
+    }),
+    MISSING_CSP: () => ({
+        id: 'SEC_004',
+        severity: 'info',
+        category: 'Security',
+        message: 'Content Security Policy (CSP) headers not configured',
+        fix: 'Add CSP headers to prevent XSS attacks'
+    }),
+    // TypeScript/JavaScript Warnings (41-60)
+    IMPLICIT_ANY: (file, line) => ({
+        id: 'TS_001',
+        severity: 'warning',
+        category: 'TypeScript',
+        message: 'Implicit "any" type detected',
+        file,
+        line,
+        fix: 'Add explicit type annotations or enable "noImplicitAny" in tsconfig.json'
+    }),
+    UNUSED_IMPORT: (importName, file, line) => ({
+        id: 'TS_002',
+        severity: 'info',
+        category: 'TypeScript',
+        message: `Unused import "${importName}"`,
+        file,
+        line,
+        fix: 'Remove unused import to reduce bundle size'
+    }),
+    DEPRECATED_API: (api, replacement) => ({
+        id: 'TS_003',
+        severity: 'warning',
+        category: 'TypeScript',
+        message: `Using deprecated API: ${api}`,
+        fix: `Replace with ${replacement}`
+    }),
+    MISSING_RETURN_TYPE: (func, file, line) => ({
+        id: 'TS_004',
+        severity: 'info',
+        category: 'TypeScript',
+        message: `Function "${func}" is missing return type`,
+        file,
+        line,
+        fix: 'Add explicit return type for better type safety'
+    }),
+    // React Warnings (61-80)
+    MISSING_KEY_PROP: (file, line) => ({
+        id: 'REACT_001',
+        severity: 'warning',
+        category: 'React',
+        message: 'Missing "key" prop in list rendering',
+        file,
+        line,
+        fix: 'Add unique "key" prop to each element in the list'
+    }),
+    UNSAFE_LIFECYCLE: (method, file) => ({
+        id: 'REACT_002',
+        severity: 'warning',
+        category: 'React',
+        message: `Unsafe lifecycle method "${method}" used`,
+        file,
+        fix: 'Replace with modern lifecycle methods or hooks'
+    }),
+    MISSING_DEPENDENCY: (dep, hook) => ({
+        id: 'REACT_003',
+        severity: 'warning',
+        category: 'React',
+        message: `Missing dependency "${dep}" in ${hook} hook`,
+        fix: 'Add missing dependency to the dependency array'
+    }),
+    INLINE_FUNCTION_PROP: (file, line) => ({
+        id: 'REACT_004',
+        severity: 'info',
+        category: 'React',
+        message: 'Inline function in JSX prop may cause unnecessary re-renders',
+        file,
+        line,
+        fix: 'Use useCallback or define function outside render'
+    }),
+    // CSS/Styling Warnings (81-100)
+    UNUSED_CSS: (selector, file) => ({
+        id: 'CSS_001',
+        severity: 'info',
+        category: 'CSS',
+        message: `Unused CSS selector: ${selector}`,
+        file,
+        fix: 'Remove unused CSS to reduce bundle size'
+    }),
+    MISSING_VENDOR_PREFIX: (property, file) => ({
+        id: 'CSS_002',
+        severity: 'info',
+        category: 'CSS',
+        message: `CSS property "${property}" may need vendor prefixes`,
+        file,
+        fix: 'Use autoprefixer or add vendor prefixes manually'
+    }),
+    LARGE_CSS_FILE: (file, size) => ({
+        id: 'CSS_003',
+        severity: 'warning',
+        category: 'CSS',
+        message: `CSS file ${file} is ${(size / 1024).toFixed(2)}KB`,
+        file,
+        fix: 'Enable CSS minification and consider splitting styles'
+    }),
+    // Build Configuration Warnings (101-120)
+    MISSING_SOURCE_MAPS: () => ({
+        id: 'BUILD_001',
+        severity: 'info',
+        category: 'Build',
+        message: 'Source maps are disabled',
+        fix: 'Enable source maps for easier debugging: sourcemap: "external"'
+    }),
+    DEVELOPMENT_MODE_PROD: () => ({
+        id: 'BUILD_002',
+        severity: 'critical',
+        category: 'Build',
+        message: 'Running in development mode for production build',
+        fix: 'Set NODE_ENV=production or mode: "production"'
+    }),
+    MISSING_MINIFICATION: () => ({
+        id: 'BUILD_003',
+        severity: 'warning',
+        category: 'Build',
+        message: 'Code minification is disabled',
+        fix: 'Enable minification for production builds'
+    }),
+    OUTDATED_DEPENDENCIES: (count) => ({
+        id: 'BUILD_004',
+        severity: 'info',
+        category: 'Build',
+        message: `${count} dependencies are outdated`,
+        fix: 'Run "npm outdated" and update dependencies'
+    }),
+    MISSING_GITIGNORE: (file) => ({
+        id: 'BUILD_005',
+        severity: 'warning',
+        category: 'Build',
+        message: `Build artifact "${file}" not in .gitignore`,
+        fix: 'Add build outputs to .gitignore'
+    }),
+    // Accessibility Warnings (121-140)
+    MISSING_ALT_TEXT: (file, line) => ({
+        id: 'A11Y_001',
+        severity: 'warning',
+        category: 'Accessibility',
+        message: 'Image missing alt text',
+        file,
+        line,
+        fix: 'Add descriptive alt attribute for screen readers'
+    }),
+    MISSING_ARIA_LABEL: (element, file, line) => ({
+        id: 'A11Y_002',
+        severity: 'warning',
+        category: 'Accessibility',
+        message: `Interactive element "${element}" missing aria-label`,
+        file,
+        line,
+        fix: 'Add aria-label for better accessibility'
+    }),
+    LOW_CONTRAST: (file, line) => ({
+        id: 'A11Y_003',
+        severity: 'info',
+        category: 'Accessibility',
+        message: 'Color contrast ratio may not meet WCAG standards',
+        file,
+        line,
+        fix: 'Increase contrast ratio to at least 4.5:1 for normal text'
+    })
+};
+/**
+ * Framework-specific warnings
+ */
+export const FrameworkWarnings = {
+    Vue: {
+        MISSING_SCOPED: (file) => ({
+            id: 'VUE_001',
+            severity: 'info',
+            category: 'Vue',
+            message: 'Style tag without "scoped" attribute',
+            file,
+            fix: 'Add "scoped" attribute to prevent style leakage'
+        }),
+        V_FOR_WITHOUT_KEY: (file, line) => ({
+            id: 'VUE_002',
+            severity: 'warning',
+            category: 'Vue',
+            message: 'v-for directive without :key',
+            file,
+            line,
+            fix: 'Add :key binding with unique identifier'
+        })
+    },
+    Svelte: {
+        UNUSED_EXPORT: (exportName, file) => ({
+            id: 'SVELTE_001',
+            severity: 'info',
+            category: 'Svelte',
+            message: `Unused export "${exportName}"`,
+            file,
+            fix: 'Remove unused export or mark as intentional'
+        }),
+        MISSING_REACTIVE: (variable, file) => ({
+            id: 'SVELTE_002',
+            severity: 'warning',
+            category: 'Svelte',
+            message: `Variable "${variable}" may need reactive declaration`,
+            file,
+            fix: 'Use $: for reactive statements'
+        })
+    },
+    Angular: {
+        MISSING_CHANGE_DETECTION: (component) => ({
+            id: 'NG_001',
+            severity: 'info',
+            category: 'Angular',
+            message: `Component "${component}" using default change detection`,
+            fix: 'Consider OnPush strategy for better performance'
+        })
+    }
+};

package/dist/utils/interactive.d.ts

@@ -0,0 +1,2 @@
+export declare function promptSelect(question: string, options: string[]): Promise<string>;
+export declare function promptConfirm(question: string): Promise<boolean>;

package/dist/utils/interactive.js

@@ -0,0 +1,37 @@
+import readline from 'readline';
+export async function promptSelect(question, options) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve) => {
+        console.log(question);
+        options.forEach((opt, i) => {
+            console.log(`  [${i + 1}] ${opt}`);
+        });
+        rl.question('\nSelect an option (number): ', (answer) => {
+            const index = parseInt(answer) - 1;
+            if (index >= 0 && index < options.length) {
+                rl.close();
+                resolve(options[index]);
+            }
+            else {
+                console.log('Invalid selection. Please try again.');
+                rl.close();
+                resolve(promptSelect(question, options));
+            }
+        });
+    });
+}
+export async function promptConfirm(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve) => {
+        rl.question(`${question} (y/n): `, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase().startsWith('y'));
+        });
+    });
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,26 @@
+export type LogLevel = 'info' | 'success' | 'warn' | 'error' | 'debug';
+export type LogCategory = 'build' | 'hmr' | 'server' | 'cache' | 'audit' | 'general' | 'ai' | 'css';
+export interface LogContext {
+    timestamp?: boolean;
+    level?: LogLevel;
+    category?: LogCategory;
+    file?: string;
+    duration?: number;
+    [key: string]: any;
+}
+export declare const log: {
+    info: (msg: string, ctx?: LogContext) => void;
+    success: (msg: string, ctx?: LogContext) => void;
+    warn: (msg: string, ctx?: LogContext) => void;
+    error: (msg: string, ctx?: LogContext | any) => void;
+    debug: (msg: string, ctx?: LogContext) => void;
+    projectError: (error: {
+        file?: string;
+        message: string;
+        line?: number;
+        column?: number;
+        type?: string;
+        plugin?: string;
+    }) => void;
+    table: (rows: Record<string, string>) => void;
+};

package/dist/utils/logger.js

@@ -0,0 +1,130 @@
+import kleur from 'kleur';
+import fs from 'fs';
+import path from 'path';
+const time = () => {
+    const d = new Date();
+    return kleur.gray(`${d.getHours().toString().padStart(2, '0')}:${d.getMinutes().toString().padStart(2, '0')}:${d.getSeconds().toString().padStart(2, '0')}`);
+};
+const categoryColor = (cat) => {
+    switch (cat) {
+        case 'build': return kleur.cyan('BUILD');
+        case 'hmr': return kleur.magenta('HMR');
+        case 'server': return kleur.blue('SERVER');
+        case 'cache': return kleur.green('CACHE');
+        case 'audit': return kleur.yellow('AUDIT');
+        case 'css': return kleur.magenta('CSS');
+        case 'ai': return kleur.yellow('AI');
+        default: return kleur.gray('GEN');
+    }
+};
+const formatDuration = (ms) => {
+    return ms > 1000 ? `${(ms / 1000).toFixed(2)}s` : `${ms}ms`;
+};
+export const log = {
+    info: (msg, ctx = {}) => {
+        // In quiet mode, allow essential server messages through
+        if (process.env.NUCLIE_QUIET === 'true' && ctx.category !== 'server')
+            return;
+        // Aggressive Filtering: Filter out internal system logs to keep the banner clean
+        const isSystemLog = msg.startsWith('Pipeline:') ||
+            msg.startsWith('-->') ||
+            msg.startsWith('Using cached') ||
+            msg.startsWith('[Transformer]') ||
+            msg.includes('Warming up') ||
+            msg.includes('Pre-bundling') ||
+            msg.includes('RocksDB') ||
+            msg.includes('Copying public directory');
+        if (isSystemLog) {
+            if (process.env.DEBUG) {
+                const cat = ctx.category ? `[${categoryColor(ctx.category)}]` : '';
+                console.log(`${time()} ${kleur.magenta('⚙')} ${cat} ${msg}`);
+            }
+            return;
+        }
+        const cat = ctx.category ? `[${categoryColor(ctx.category)}]` : '';
+        const dur = ctx.duration ? kleur.yellow(`+${formatDuration(ctx.duration)}`) : '';
+        console.log(`${time()} ${kleur.blue('ℹ')} ${cat} ${msg} ${dur}`);
+    },
+    success: (msg, ctx = {}) => {
+        // Filter success logs if they are system noise
+        if (msg.includes('Cache ready') || msg.includes('Build Complete') || msg.includes('active at')) {
+            if (!process.env.DEBUG)
+                return;
+        }
+        const cat = ctx.category ? `[${categoryColor(ctx.category)}]` : '';
+        const dur = ctx.duration ? kleur.yellow(`+${formatDuration(ctx.duration)}`) : '';
+        console.log(`${time()} ${kleur.green('✔')} ${cat} ${msg} ${dur}`);
+    },
+    warn: (msg, ctx = {}) => {
+        // In quiet mode, keep server warnings visible
+        if (process.env.NUCLIE_QUIET === 'true' && ctx.category !== 'server')
+            return;
+        const cat = ctx.category ? `[${categoryColor(ctx.category)}]` : '';
+        console.log(`${time()} ${kleur.yellow('⚠')} ${cat} ${msg}`);
+    },
+    error: (msg, ctx = {}) => {
+        const cat = ctx.category ? `[${categoryColor(ctx.category)}]` : '';
+        console.error(`${time()} ${kleur.red('✖')} ${cat} ${msg}`);
+        if (ctx.stack) {
+            console.error(kleur.dim(ctx.stack));
+        }
+    },
+    debug: (msg, ctx = {}) => {
+        if (process.env.DEBUG && process.env.NUCLIE_QUIET !== 'true') {
+            const cat = ctx.category ? `[${categoryColor(ctx.category)}]` : '';
+            console.log(`${time()} ${kleur.magenta('⚙')} ${cat} ${msg}`);
+        }
+    },
+    projectError: (error) => {
+        console.error('');
+        // 1. Show code snippet first (Vite style)
+        try {
+            if (error.file && error.line) {
+                let fp = error.file;
+                if (!path.isAbsolute(fp))
+                    fp = path.resolve(process.cwd(), fp);
+                if (fs.existsSync(fp)) {
+                    const content = fs.readFileSync(fp, 'utf-8');
+                    const lines = content.split(/\r?\n/);
+                    const idx = Math.max(0, (error.line || 1) - 1);
+                    const start = Math.max(0, idx - 2);
+                    const end = Math.min(lines.length - 1, idx + 2);
+                    for (let i = start; i <= end; i++) {
+                        const num = String(i + 1).padStart(String(end + 1).length + 1, ' ');
+                        const isErrorLine = i === idx;
+                        const lineText = lines[i] ?? '';
+                        // Format:  34 | ...
+                        const prefix = isErrorLine ? kleur.red('>') : ' ';
+                        console.error(`${prefix} ${kleur.dim(num)} ${kleur.dim('|')} ${lineText}`);
+                        if (isErrorLine && error.column) {
+                            const indent = num.length + 3 + (error.column - 1);
+                            console.error(' '.repeat(indent + 2) + kleur.red('^'));
+                        }
+                    }
+                }
+            }
+        }
+        catch (e) { }
+        // 2. Error details below the snippet - cleaner format
+        console.error('');
+        console.error(kleur.red(`[${error.type || 'Error'}]`) + ' ' + error.message);
+        if (error.file) {
+            const location = `${error.file}:${error.line || 1}:${error.column || 1}`;
+            console.error(kleur.dim(location));
+        }
+        console.error('');
+    },
+    table: (rows) => {
+        console.log('');
+        console.log(kleur.bold('🚀 Nuclie Dev Server Ready'));
+        const keys = Object.keys(rows);
+        const maxKeyLen = Math.max(...keys.map(k => k.length));
+        keys.forEach((key, i) => {
+            const isLast = i === keys.length - 1;
+            const prefix = isLast ? '└' : '│';
+            const padding = ' '.repeat(maxKeyLen - key.length);
+            console.log(`${prefix} ${kleur.cyan(key)}${padding}  ${rows[key]}`);
+        });
+        console.log('');
+    }
+};

package/dist/utils/path-normalize.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Nuclie Path Normalization Utility
+ * Ensures consistent behavior across Windows (win32) and Unix (posix)
+ * Day 25: Legacy Polyfills & Windows Lock
+ */
+export declare class PathOps {
+    /**
+     * Normalize paths to POSIX style (forward slashes)
+     * Essential for Rollup plugin IDs and Manifest keys
+     */
+    static normalize(p: string): string;
+    /**
+     * Join paths and normalize result
+     */
+    static join(...paths: string[]): string;
+    /**
+     * Resolve path and normalize result
+     */
+    static resolve(...paths: string[]): string;
+    /**
+     * Check if path is absolute (Cross-platform)
+     */
+    static isAbsolute(p: string): boolean;
+}

package/dist/utils/path-normalize.js

@@ -0,0 +1,37 @@
+/**
+ * Nuclie Path Normalization Utility
+ * Ensures consistent behavior across Windows (win32) and Unix (posix)
+ * Day 25: Legacy Polyfills & Windows Lock
+ */
+import * as path from 'path';
+export class PathOps {
+    /**
+     * Normalize paths to POSIX style (forward slashes)
+     * Essential for Rollup plugin IDs and Manifest keys
+     */
+    static normalize(p) {
+        // Handle Windows backslashes
+        const normalized = p.replace(/\\/g, '/');
+        // Handle Driver letters (C:/...) -> /c:/... or similar if needed for URLs
+        // But mostly we just want forward slashes for internal IDs
+        return normalized;
+    }
+    /**
+     * Join paths and normalize result
+     */
+    static join(...paths) {
+        return this.normalize(path.join(...paths));
+    }
+    /**
+     * Resolve path and normalize result
+     */
+    static resolve(...paths) {
+        return this.normalize(path.resolve(...paths));
+    }
+    /**
+     * Check if path is absolute (Cross-platform)
+     */
+    static isAbsolute(p) {
+        return path.isAbsolute(p);
+    }
+}

package/dist/visual/chart-generator.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Comparison Chart Generator
+ * Generates ASCII charts to visualize performance metrics
+ */
+export declare class ChartGenerator {
+    /**
+     * Generate detailed comparison chart
+     */
+    generateComparison(metric: string, nuclieValue: number, rivals: Record<string, number>, unit?: string): string;
+    private createBar;
+}

package/dist/visual/chart-generator.js

@@ -0,0 +1,30 @@
+/**
+ * Comparison Chart Generator
+ * Generates ASCII charts to visualize performance metrics
+ */
+export class ChartGenerator {
+    /**
+     * Generate detailed comparison chart
+     */
+    generateComparison(metric, nuclieValue, rivals, unit = 'ms') {
+        const maxLabelLength = Math.max('Nuclie'.length, ...Object.keys(rivals).map(k => k.length));
+        const maxValue = Math.max(nuclieValue, ...Object.values(rivals));
+        const chartWidth = 40;
+        let output = `\n📊 ${metric} Comparison:\n`;
+        output += '─'.repeat(chartWidth + maxLabelLength + 15) + '\n';
+        // Add Nuclie
+        output += this.createBar('Nuclie', nuclieValue, maxValue, maxLabelLength, chartWidth, unit, true);
+        // Add Rivals
+        for (const [name, value] of Object.entries(rivals)) {
+            output += this.createBar(name, value, maxValue, maxLabelLength, chartWidth, unit, false);
+        }
+        output += '─'.repeat(chartWidth + maxLabelLength + 15) + '\n';
+        return output;
+    }
+    createBar(label, value, maxValue, labelWidth, chartWidth, unit, isHighlight) {
+        const barLength = Math.max(1, Math.round((value / maxValue) * chartWidth));
+        const barChar = isHighlight ? '█' : '░';
+        const paddedLabel = label.padEnd(labelWidth);
+        return `${isHighlight ? '🚀' : '  '} ${paddedLabel} │ ${barChar.repeat(barLength)} ${value}${unit}\n`;
+    }
+}

package/dist/visual/client/renderer.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Nuclie Dependency Graph Renderer
+ * Implementation: Three.js (WebGL/WebGPU)
+ * Day 16: WebGPU Visualizer v2 Lock
+ */
+export interface GraphData {
+    nodes: any[];
+    links: any[];
+}
+export declare class GraphRenderer {
+    private container;
+    private scene;
+    private camera;
+    private renderer;
+    private nodesMesh;
+    private NODE_SIZE;
+    private COLOR_HUB;
+    private COLOR_LEAF;
+    constructor(containerId: string);
+    private onWindowResize;
+    /**
+     * Load Graph Data and generate GPU Instanced Mesh
+     * This is highly optimized for 10k+ nodes (1 draw call)
+     */
+    loadData(data: GraphData): void;
+    /**
+     * Highlight optimization hints (e.g. pulse red nodes)
+     */
+    highlightHints(hints: any[]): void;
+    private animate;
+}