nuclie 1.0.0

package/dist/dev-server.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Simple Dev Server for HMR Testing
+ * Actually runs and serves files with HMR
+ */
+export declare class DevServer {
+    private port;
+    private root;
+    private server;
+    private clients;
+    private fileWatchers;
+    constructor(port?: number, root?: string);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Watch all files in a directory (for testing)
+     */
+    watchDirectory(dir: string): void;
+    private handleRequest;
+    private handleHMRConnection;
+    private watchFile;
+    private handleFileChange;
+    private injectHMRClient;
+    private getContentType;
+}
+export declare function startDevServer(port?: number, root?: string): Promise<DevServer>;

package/dist/dev-server.js

@@ -0,0 +1,255 @@
+/**
+ * Simple Dev Server for HMR Testing
+ * Actually runs and serves files with HMR
+ */
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { hmrClassifier } from './hmr/classifier.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export class DevServer {
+    constructor(port = 3000, root = process.cwd()) {
+        this.port = port;
+        this.root = root;
+        this.server = null;
+        this.clients = new Set();
+        this.fileWatchers = new Map();
+    }
+    start() {
+        return new Promise((resolve) => {
+            this.server = http.createServer((req, res) => {
+                this.handleRequest(req, res);
+            });
+            this.server.listen(this.port, () => {
+                console.log(`✅ Dev server running at http://localhost:${this.port}`);
+                resolve();
+            });
+        });
+    }
+    stop() {
+        return new Promise((resolve) => {
+            // Close all client connections
+            for (const client of this.clients) {
+                try {
+                    client.end();
+                }
+                catch (e) {
+                    // Ignore errors
+                }
+            }
+            this.clients.clear();
+            // Stop all file watchers
+            for (const watcher of this.fileWatchers.values()) {
+                watcher.close();
+            }
+            this.fileWatchers.clear();
+            if (this.server) {
+                this.server.close(() => {
+                    console.log('✅ Dev server stopped');
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    /**
+     * Watch all files in a directory (for testing)
+     */
+    watchDirectory(dir) {
+        if (!fs.existsSync(dir))
+            return;
+        const files = fs.readdirSync(dir);
+        for (const file of files) {
+            const filePath = path.join(dir, file);
+            const stat = fs.statSync(filePath);
+            if (stat.isFile() && !this.fileWatchers.has(filePath)) {
+                this.watchFile(filePath);
+                console.log(`👁️  Watching: ${filePath}`);
+            }
+        }
+    }
+    handleRequest(req, res) {
+        const url = req.url || '/';
+        // Strip query params for file lookup
+        const [pathname] = url.split('?');
+        // HMR WebSocket endpoint
+        if (pathname === '/__hmr') {
+            this.handleHMRConnection(req, res);
+            return;
+        }
+        // Serve files
+        let filePath = path.join(this.root, pathname === '/' ? 'index.html' : pathname);
+        // Check if file exists
+        if (!fs.existsSync(filePath)) {
+            res.writeHead(404);
+            res.end('Not Found');
+            return;
+        }
+        // Read and serve file
+        const ext = path.extname(filePath);
+        const contentType = this.getContentType(ext);
+        fs.readFile(filePath, (err, data) => {
+            if (err) {
+                res.writeHead(500);
+                res.end('Server Error');
+                return;
+            }
+            // Inject HMR client for HTML files
+            if (ext === '.html') {
+                const html = data.toString();
+                const injected = this.injectHMRClient(html);
+                res.writeHead(200, { 'Content-Type': contentType });
+                res.end(injected);
+            }
+            else {
+                res.writeHead(200, { 'Content-Type': contentType });
+                res.end(data);
+            }
+        });
+        // Watch this file for changes
+        if (!this.fileWatchers.has(filePath)) {
+            this.watchFile(filePath);
+        }
+    }
+    handleHMRConnection(req, res) {
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive'
+        });
+        // Send initial connection message
+        res.write('data: {"type":"connected"}\n\n');
+        // Store client
+        this.clients.add(res);
+        // Remove client on close
+        req.on('close', () => {
+            this.clients.delete(res);
+        });
+    }
+    watchFile(filePath) {
+        console.log(`👁️  Setting up watcher for: ${filePath}`);
+        const watcher = fs.watch(filePath, (eventType, filename) => {
+            console.log(`🔔 File event: ${eventType} on ${filename || filePath}`);
+            if (eventType === 'change') {
+                this.handleFileChange(filePath);
+            }
+        });
+        watcher.on('error', (error) => {
+            console.error(`❌ Watcher error for ${filePath}:`, error);
+        });
+        this.fileWatchers.set(filePath, watcher);
+    }
+    handleFileChange(filePath) {
+        console.log(`📝 File changed: ${filePath}`);
+        // Classify the change
+        const decision = hmrClassifier.classify({
+            path: filePath,
+            type: 'updated'
+        });
+        console.log(`🔥 HMR Decision: ${decision.level}`);
+        console.log(`   Reason: ${decision.reason}`);
+        // Send HMR update to all clients
+        const message = JSON.stringify({
+            type: 'hmr-update',
+            decision,
+            file: filePath,
+            timestamp: Date.now()
+        });
+        for (const client of this.clients) {
+            client.write(`data: ${message}\n\n`);
+        }
+    }
+    injectHMRClient(html) {
+        const hmrScript = `
+<script type="module">
+// HMR Client
+const eventSource = new EventSource('/__hmr');
+
+eventSource.onmessage = (event) => {
+    const data = JSON.parse(event.data);
+    
+    if (data.type === 'connected') {
+        console.log('✅ HMR connected');
+        return;
+    }
+    
+    if (data.type === 'hmr-update') {
+        console.log('🔥 HMR Update:', data.decision);
+        console.log('   Level:', data.decision.level);
+        console.log('   Reason:', data.decision.reason);
+        
+        // Handle different HMR levels
+        if (data.decision.level === 'HMR_SAFE') {
+            // Reload CSS with robust cloning strategy
+            console.log('🔄 Reloading CSS...');
+            const links = document.querySelectorAll('link[rel="stylesheet"]');
+            
+            links.forEach(link => {
+                const href = link.getAttribute('href');
+                if (href) {
+                    console.log('   Refreshing: ' + href);
+                    // Create new timestamp
+                    const newUrl = href.split('?')[0] + '?t=' + Date.now();
+                    
+                    // Clone and replace to force browser reload
+                    const newLink = link.cloneNode();
+                    newLink.setAttribute('href', newUrl);
+                    
+                    // When loaded, remove old link to prevent flash
+                    newLink.onload = () => {
+                        console.log('✅ CSS reloaded: ' + newUrl);
+                        // Small delay to ensure styles applied
+                        setTimeout(() => {
+                           if (link.parentNode) link.parentNode.removeChild(link);
+                        }, 50);
+                    };
+                    
+                    if (link.parentNode) {
+                        link.parentNode.insertBefore(newLink, link.nextSibling);
+                    }
+                }
+            });
+        } else if (data.decision.level === 'HMR_FULL_RELOAD') {
+            // Full page reload
+            setTimeout(() => location.reload(), 100);
+        } else {
+            // Partial HMR - let framework handle it
+            if (import.meta.hot) {
+                import.meta.hot.accept();
+            }
+        }
+    }
+};
+
+eventSource.onerror = () => {
+    console.error('❌ HMR connection lost');
+};
+</script>
+`;
+        // Inject before closing body tag
+        return html.replace('</body>', `${hmrScript}</body>`);
+    }
+    getContentType(ext) {
+        const types = {
+            '.html': 'text/html',
+            '.js': 'application/javascript',
+            '.mjs': 'application/javascript',
+            '.css': 'text/css',
+            '.json': 'application/json',
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.svg': 'image/svg+xml'
+        };
+        return types[ext] || 'text/plain';
+    }
+}
+// Export for testing
+export async function startDevServer(port = 3000, root = process.cwd()) {
+    const server = new DevServer(port, root);
+    await server.start();
+    return server;
+}

package/dist/env/api.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Nuclie Environment API
+ * Unified Runtime for Browser, Node, and Edge
+ * Day 26: Environment API Lock
+ */
+export interface EnvConfig {
+    mode: 'development' | 'production';
+    ssr: boolean;
+    base: string;
+}
+export declare class NuclieEnv {
+    private static instance;
+    config: EnvConfig;
+    private listeners;
+    private constructor();
+    static init(config: EnvConfig): NuclieEnv;
+    static get(): NuclieEnv;
+    /**
+     * Unified HMR Listener
+     * Works on Browser (WebSocket) or Server (EventBus/ProcessSignal)
+     */
+    onHMR(callback: (payload: any) => void): void;
+    /**
+     * Trigger HMR (Called by Dev Server or WebSocket Client)
+     */
+    triggerHMR(payload: any): void;
+}

package/dist/env/api.js

@@ -0,0 +1,36 @@
+/**
+ * Nuclie Environment API
+ * Unified Runtime for Browser, Node, and Edge
+ * Day 26: Environment API Lock
+ */
+export class NuclieEnv {
+    constructor(config) {
+        this.listeners = [];
+        this.config = config;
+    }
+    static init(config) {
+        if (!NuclieEnv.instance) {
+            NuclieEnv.instance = new NuclieEnv(config);
+        }
+        return NuclieEnv.instance;
+    }
+    static get() {
+        if (!NuclieEnv.instance) {
+            throw new Error('NuclieEnv not initialized');
+        }
+        return NuclieEnv.instance;
+    }
+    /**
+     * Unified HMR Listener
+     * Works on Browser (WebSocket) or Server (EventBus/ProcessSignal)
+     */
+    onHMR(callback) {
+        this.listeners.push(callback);
+    }
+    /**
+     * Trigger HMR (Called by Dev Server or WebSocket Client)
+     */
+    triggerHMR(payload) {
+        this.listeners.forEach(fn => fn(payload));
+    }
+}

package/dist/fix/ast-transforms.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Auto-Fix Engine
+ * Safe AST transforms for common build issues
+ */
+export interface FixResult {
+    success: boolean;
+    code?: string;
+    error?: string;
+    changes: FixChange[];
+}
+export interface FixChange {
+    type: 'remove-unused-import' | 'add-dynamic-import' | 'add-aria' | 'remove-unused-export' | 'tree-shake';
+    location: {
+        line: number;
+        column: number;
+    };
+    description: string;
+}
+export interface ModuleInfo {
+    path: string;
+    exports: Set<string>;
+    imports: Map<string, string[]>;
+}
+export declare class AutoFixEngine {
+    private transformHistory;
+    /**
+     * Save original code for potential rollback
+     */
+    saveSnapshot(filePath: string, code: string): void;
+    /**
+     * Rollback to previous version
+     */
+    rollback(filePath: string, steps?: number): string | null;
+    /**
+     * Get rollback history for a file
+     */
+    getHistory(filePath: string): string[];
+    /**
+     * Clear history for a file
+     */
+    clearHistory(filePath: string): void;
+    /**
+     * Remove unused imports from code
+     */
+    removeUnusedImports(code: string, unusedImports: string[]): FixResult;
+    /**
+     * Add dynamic imports for large dependencies
+     */
+    addDynamicImport(code: string, moduleName: string, threshold?: number): FixResult;
+    /**
+     * Add ARIA attributes to improve accessibility
+     */
+    addAriaAttributes(html: string): FixResult;
+    /**
+     * Remove unused exports
+     */
+    removeUnusedExports(code: string, unusedExports: string[]): FixResult;
+    /**
+     * Validate that a transform is safe
+     */
+    validateTransform(originalCode: string, transformedCode: string): boolean;
+    /**
+     * Generate diff preview
+     */
+    generateDiff(original: string, modified: string): string;
+    /**
+     * Apply batch fixes
+     */
+    applyBatchFixes(code: string, fixes: Array<{
+        type: string;
+        data: any;
+    }>): FixResult;
+    /**
+     * Tree-shaking: Analyze module graph and remove unused exports
+     */
+    treeShake(modules: Map<string, string>): Map<string, FixResult>;
+    /**
+     * Track fix success rate
+     */
+    calculateSuccessRate(results: FixResult[]): number;
+}