nuclie 1.0.0

package/dist/core/sandbox.js

@@ -0,0 +1,79 @@
+import vm from 'vm';
+import fs from 'fs';
+import path from 'path';
+function normalizePathForPermission(filePath) {
+    if (typeof filePath === 'string')
+        return filePath;
+    if (filePath instanceof URL)
+        return filePath.pathname;
+    if (Buffer.isBuffer(filePath))
+        return filePath.toString();
+    throw new Error('File descriptor access is not allowed in sandbox.');
+}
+export class PluginSandbox {
+    constructor(permissionManager) {
+        this.permissionManager = permissionManager;
+        this.context = this.createContext();
+    }
+    createContext() {
+        const sandbox = {
+            console: {
+                log: (...args) => console.log('[Plugin]', ...args),
+                error: (...args) => console.error('[Plugin Error]', ...args),
+                warn: (...args) => console.warn('[Plugin Warn]', ...args),
+                info: (...args) => console.info('[Plugin Info]', ...args),
+            },
+            process: {
+                env: new Proxy({}, {
+                    get: (target, prop) => {
+                        const key = String(prop);
+                        if (this.permissionManager.canAccessEnv(key)) {
+                            return process.env[key];
+                        }
+                        return undefined;
+                    }
+                }),
+                cwd: () => process.cwd(),
+            },
+            require: (moduleName) => {
+                if (moduleName === 'fs') {
+                    return this.createFsProxy();
+                }
+                if (moduleName === 'path') {
+                    return path;
+                }
+                // Block other modules for now
+                throw new Error(`Access to module '${moduleName}' is denied.`);
+            },
+            module: { exports: {} },
+            exports: {},
+        };
+        return vm.createContext(sandbox);
+    }
+    createFsProxy() {
+        return {
+            readFileSync: (...args) => {
+                const [filePath] = args;
+                const normalizedPath = normalizePathForPermission(filePath);
+                if (!this.permissionManager.canRead(normalizedPath)) {
+                    throw new Error(`Read access denied: ${normalizedPath}`);
+                }
+                return fs.readFileSync(...args);
+            },
+            writeFileSync: (...args) => {
+                const [filePath] = args;
+                const normalizedPath = normalizePathForPermission(filePath);
+                if (!this.permissionManager.canWrite(normalizedPath)) {
+                    throw new Error(`Write access denied: ${normalizedPath}`);
+                }
+                return fs.writeFileSync(...args);
+            },
+            // Add other fs methods as needed
+        };
+    }
+    run(code, filename = 'plugin.js') {
+        const script = new vm.Script(code, { filename });
+        script.runInContext(this.context);
+        return this.context.module.exports;
+    }
+}

package/dist/core/steps/css-optimization.d.ts

@@ -0,0 +1,65 @@
+export interface CSSOptimizationConfig {
+    purge?: boolean;
+    critical?: boolean;
+    minify?: boolean;
+    safelist?: string[];
+    content?: string[];
+}
+/**
+ * Production-grade CSS Optimization
+ * - Removes unused CSS
+ * - Extracts critical CSS
+ * - Minifies CSS
+ */
+export declare class CSSOptimizer {
+    private config;
+    private root;
+    constructor(root: string, config?: CSSOptimizationConfig);
+    /**
+     * Optimize all CSS files in output directory
+     */
+    optimize(outDir: string): Promise<void>;
+    /**
+     * Optimize a single CSS file
+     */
+    private optimizeFile;
+    /**
+     * Remove unused CSS using simple regex-based purging
+     * (Production version would use PurgeCSS library, but we're zero-dependency)
+     */
+    private removeUnusedCSS;
+    /**
+     * Check if a CSS selector is used in the content
+     */
+    private isSelectorUsed;
+    /**
+     * Minify CSS (simple version)
+     */
+    private minifyCSS;
+    /**
+     * Extract critical CSS (above-the-fold styles)
+     */
+    private extractCriticalCSS;
+    /**
+     * Inject critical CSS inline into HTML
+     */
+    private injectCriticalCSS;
+    /**
+     * Find all CSS files in directory
+     */
+    private findCSSFiles;
+    /**
+     * Find all HTML files in directory
+     */
+    private findHTMLFiles;
+    /**
+     * Get content files for purging
+     */
+    private getContentFiles;
+}
+/**
+ * Pipeline Step for CSS Optimization
+ */
+export declare class CSSOptimizationStep {
+    run(ctx: any): Promise<void>;
+}

package/dist/core/steps/css-optimization.js

@@ -0,0 +1,318 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { log } from '../../utils/logger.js';
+/**
+ * Production-grade CSS Optimization
+ * - Removes unused CSS
+ * - Extracts critical CSS
+ * - Minifies CSS
+ */
+export class CSSOptimizer {
+    constructor(root, config = {}) {
+        this.root = root;
+        this.config = {
+            purge: config.purge ?? true,
+            critical: config.critical ?? true,
+            minify: config.minify ?? true,
+            safelist: config.safelist || [],
+            content: config.content || ['**/*.html', '**/*.jsx', '**/*.tsx', '**/*.vue', '**/*.svelte']
+        };
+    }
+    /**
+     * Optimize all CSS files in output directory
+     */
+    async optimize(outDir) {
+        const cssFiles = await this.findCSSFiles(outDir);
+        if (cssFiles.length === 0) {
+            log.debug('No CSS files found to optimize', { category: 'css' });
+            return;
+        }
+        log.info(`Optimizing ${cssFiles.length} CSS files...`, { category: 'css' });
+        for (const cssFile of cssFiles) {
+            await this.optimizeFile(cssFile, outDir);
+        }
+        log.success(`CSS optimization complete`, { category: 'css' });
+    }
+    /**
+     * Optimize a single CSS file
+     */
+    async optimizeFile(cssFile, outDir) {
+        let css = await fs.readFile(cssFile, 'utf-8');
+        const originalSize = css.length;
+        // 1. Remove unused CSS
+        if (this.config.purge) {
+            css = await this.removeUnusedCSS(css, outDir);
+        }
+        // 2. Minify CSS
+        if (this.config.minify) {
+            css = this.minifyCSS(css);
+        }
+        // 3. Extract critical CSS
+        if (this.config.critical) {
+            await this.extractCriticalCSS(cssFile, css, outDir);
+        }
+        // Write optimized CSS
+        await fs.writeFile(cssFile, css);
+        const newSize = css.length;
+        const reduction = ((1 - newSize / originalSize) * 100).toFixed(1);
+        log.info(`${path.basename(cssFile)}: ${originalSize}B → ${newSize}B (${reduction}% reduction)`, {
+            category: 'css'
+        });
+    }
+    /**
+     * Remove unused CSS using simple regex-based purging
+     * (Production version would use PurgeCSS library, but we're zero-dependency)
+     */
+    async removeUnusedCSS(css, outDir) {
+        // Get all content files
+        const contentFiles = await this.getContentFiles(outDir);
+        const usedClasses = new Set();
+        const usedIds = new Set();
+        // Extract all class names and IDs from content
+        for (const file of contentFiles) {
+            try {
+                const content = await fs.readFile(file, 'utf-8');
+                // Extract class names
+                const classMatches = content.matchAll(/class(?:Name)?=["']([^"']+)["']/g);
+                for (const match of classMatches) {
+                    match[1].split(/\s+/).forEach(cls => usedClasses.add(cls));
+                }
+                // Extract IDs
+                const idMatches = content.matchAll(/id=["']([^"']+)["']/g);
+                for (const match of idMatches) {
+                    usedIds.add(match[1]);
+                }
+            }
+            catch (e) {
+                // Skip files that can't be read
+            }
+        }
+        // Add safelist
+        this.config.safelist?.forEach(cls => usedClasses.add(cls));
+        // Remove unused selectors
+        const lines = css.split('\n');
+        const optimizedLines = [];
+        let inRule = false;
+        let currentRule = '';
+        let keepRule = false;
+        log.info('Purging CSS...', {
+            classes: Array.from(usedClasses),
+            ids: Array.from(usedIds)
+        });
+        for (const line of lines) {
+            // Check if this is a selector line
+            if (line.trim().endsWith('{')) {
+                inRule = true;
+                currentRule = line;
+                // Check if selector is used
+                const selector = line.substring(0, line.lastIndexOf('{')).trim();
+                keepRule = this.isSelectorUsed(selector, usedClasses, usedIds);
+                log.debug(`Selector: "${selector}" -> Keep: ${keepRule}`);
+                if (keepRule) {
+                    optimizedLines.push(line);
+                }
+            }
+            else if (line.trim() === '}') {
+                if (keepRule) {
+                    optimizedLines.push(line);
+                }
+                inRule = false;
+                currentRule = '';
+            }
+            else if (inRule && keepRule) {
+                optimizedLines.push(line);
+            }
+            else if (!inRule) {
+                // Keep comments, @rules, etc.
+                optimizedLines.push(line);
+            }
+        }
+        return optimizedLines.join('\n');
+    }
+    /**
+     * Check if a CSS selector is used in the content
+     */
+    isSelectorUsed(selector, usedClasses, usedIds) {
+        // Always keep @rules, keyframes, etc.
+        if (selector.startsWith('@') || selector.startsWith(':root')) {
+            return true;
+        }
+        // Check class selectors
+        const classMatch = selector.match(/\.([a-zA-Z0-9_-]+)/);
+        if (classMatch && usedClasses.has(classMatch[1])) {
+            return true;
+        }
+        // Check ID selectors
+        const idMatch = selector.match(/#([a-zA-Z0-9_-]+)/);
+        if (idMatch && usedIds.has(idMatch[1])) {
+            return true;
+        }
+        // Keep element selectors, pseudo-classes, etc.
+        if (!selector.includes('.') && !selector.includes('#')) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Minify CSS (simple version)
+     */
+    minifyCSS(css) {
+        return css
+            // Remove comments
+            .replace(/\/\*[\s\S]*?\*\//g, '')
+            // Remove whitespace
+            .replace(/\s+/g, ' ')
+            // Remove space around special characters
+            .replace(/\s*([{}:;,])\s*/g, '$1')
+            // Remove trailing semicolons
+            .replace(/;}/g, '}')
+            .trim();
+    }
+    /**
+     * Extract critical CSS (above-the-fold styles)
+     */
+    async extractCriticalCSS(cssFile, css, outDir) {
+        // Find HTML files
+        const htmlFiles = await this.findHTMLFiles(outDir);
+        if (htmlFiles.length === 0)
+            return;
+        // Extract selectors that are likely critical (simple heuristic)
+        const criticalSelectors = [
+            'html', 'body', 'header', 'nav', 'main', 'footer',
+            'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+            'p', 'a', 'button', 'input', 'form'
+        ];
+        const criticalCSS = [];
+        const lines = css.split('\n');
+        let inCriticalRule = false;
+        let currentRule = '';
+        for (const line of lines) {
+            if (line.trim().endsWith('{')) {
+                const selector = line.substring(0, line.lastIndexOf('{')).trim();
+                inCriticalRule = criticalSelectors.some(crit => selector.includes(crit));
+                currentRule = line;
+                if (inCriticalRule) {
+                    criticalCSS.push(line);
+                }
+            }
+            else if (line.trim() === '}') {
+                if (inCriticalRule) {
+                    criticalCSS.push(line);
+                }
+                inCriticalRule = false;
+            }
+            else if (inCriticalRule) {
+                criticalCSS.push(line);
+            }
+        }
+        // Write critical CSS file
+        const criticalCSSPath = cssFile.replace('.css', '.critical.css');
+        await fs.writeFile(criticalCSSPath, criticalCSS.join('\n'));
+        log.info(`Extracted critical CSS: ${path.basename(criticalCSSPath)}`, { category: 'css' });
+        // Inject critical CSS into HTML files
+        for (const htmlFile of htmlFiles) {
+            await this.injectCriticalCSS(htmlFile, criticalCSS.join('\n'));
+        }
+    }
+    /**
+     * Inject critical CSS inline into HTML
+     */
+    async injectCriticalCSS(htmlFile, criticalCSS) {
+        let html = await fs.readFile(htmlFile, 'utf-8');
+        // Check if already has critical CSS
+        if (html.includes('<style data-critical>')) {
+            return;
+        }
+        // Inject before closing </head>
+        const criticalTag = `<style data-critical>${this.minifyCSS(criticalCSS)}</style>`;
+        html = html.replace('</head>', `${criticalTag}\n</head>`);
+        await fs.writeFile(htmlFile, html);
+        log.debug(`Injected critical CSS into ${path.basename(htmlFile)}`, { category: 'css' });
+    }
+    /**
+     * Find all CSS files in directory
+     */
+    async findCSSFiles(dir) {
+        const files = [];
+        async function scan(currentDir) {
+            const entries = await fs.readdir(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(currentDir, entry.name);
+                if (entry.isDirectory()) {
+                    await scan(fullPath);
+                }
+                else if (entry.isFile() && entry.name.endsWith('.css') && !entry.name.includes('.critical.')) {
+                    files.push(fullPath);
+                }
+            }
+        }
+        await scan(dir);
+        return files;
+    }
+    /**
+     * Find all HTML files in directory
+     */
+    async findHTMLFiles(dir) {
+        const files = [];
+        async function scan(currentDir) {
+            const entries = await fs.readdir(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(currentDir, entry.name);
+                if (entry.isDirectory()) {
+                    await scan(fullPath);
+                }
+                else if (entry.isFile() && entry.name.endsWith('.html')) {
+                    files.push(fullPath);
+                }
+            }
+        }
+        await scan(dir);
+        return files;
+    }
+    /**
+     * Get content files for purging
+     */
+    async getContentFiles(outDir) {
+        const files = [];
+        const extensions = ['.html', '.js', '.mjs', '.jsx', '.tsx'];
+        async function scan(currentDir) {
+            const entries = await fs.readdir(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(currentDir, entry.name);
+                if (entry.isDirectory()) {
+                    await scan(fullPath);
+                }
+                else if (entry.isFile()) {
+                    const ext = path.extname(entry.name);
+                    if (extensions.includes(ext)) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+        }
+        await scan(outDir);
+        return files;
+    }
+}
+/**
+ * Pipeline Step for CSS Optimization
+ */
+export class CSSOptimizationStep {
+    async run(ctx) {
+        // Only run optimization if enabled in config
+        if (ctx.config.build?.css?.minimize === false && !ctx.config.build?.css?.modules) {
+            return;
+        }
+        const outDir = ctx.config.outDir || 'dist';
+        const absOutDir = path.isAbsolute(outDir)
+            ? outDir
+            : path.resolve(ctx.config.root || process.cwd(), outDir);
+        // Optimize output directory
+        const optimizer = new CSSOptimizer(ctx.config.root, {
+            minify: ctx.config.build?.minify !== false,
+            purge: ctx.config.build?.css?.purge !== false,
+            critical: ctx.config.build?.css?.critical !== false
+        });
+        await optimizer.optimize(absOutDir);
+    }
+}

package/dist/core/steps.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Build Steps - Bundler Step Implementation
+ * This file provides the BundlerStep class for production builds
+ */
+export declare class BundlerStep {
+    run(ctx: any): Promise<void>;
+}

package/dist/core/steps.js

@@ -0,0 +1,17 @@
+/**
+ * Build Steps - Bundler Step Implementation
+ * This file provides the BundlerStep class for production builds
+ */
+import { CoreBuildEngine } from './engine/index.js';
+export class BundlerStep {
+    async run(ctx) {
+        const engine = new CoreBuildEngine();
+        // Run the build using the core engine
+        const result = await engine.run(ctx.config, 'build', ctx.config.root);
+        if (!result.success) {
+            throw new Error(`Build failed: ${result.error?.message || 'Unknown error'}`);
+        }
+        // Store results in context
+        ctx.buildResult = result;
+    }
+}

package/dist/core/transform/batchTransformer.d.ts

@@ -0,0 +1,12 @@
+import { BuildContext } from '../engine/types.js';
+export declare class BatchTransformer {
+    private transformer;
+    constructor();
+    /**
+     * Parallel batch transformation using Native Workers (SWC)
+     */
+    transformBatch(modules: {
+        id: string;
+        content: string;
+    }[], ctx: BuildContext): Promise<any[]>;
+}

package/dist/core/transform/batchTransformer.js

@@ -0,0 +1,24 @@
+import { Transformer } from './transformer.js';
+import { explainReporter } from '../engine/events.js';
+export class BatchTransformer {
+    constructor() {
+        this.transformer = new Transformer();
+    }
+    /**
+     * Parallel batch transformation using Native Workers (SWC)
+     */
+    async transformBatch(modules, ctx) {
+        explainReporter.report('transform', 'batch_start', `Transforming ${modules.length} modules`);
+        // 1. Prepare items for native worker
+        const items = modules.map(m => ({
+            id: m.id,
+            path: m.id,
+            content: m.content,
+            loader: 'typescript' // Or detect from extension
+        }));
+        // 2. Execute batch transformation
+        const results = await this.transformer.batchTransform(items, ctx);
+        explainReporter.report('transform', 'batch_complete', `Transformed ${results.length} modules`);
+        return results;
+    }
+}

package/dist/core/transform/transformer.d.ts

@@ -0,0 +1,9 @@
+import { BuildContext } from '../engine/types.js';
+export declare class Transformer {
+    private nativeWorker;
+    private available;
+    constructor();
+    static minifySync(code: string): string;
+    batchTransform(modules: any[], ctx: BuildContext): Promise<any[]>;
+    static removeEsbuildWrappers(code: string): string;
+}