nuclie 1.0.0

package/dist/commands/ssr.d.ts

@@ -0,0 +1,12 @@
+/**
+ * SSR Server CLI Command Handler
+ */
+export interface SSRCommandArgs {
+    port: number;
+    framework: 'nextjs' | 'nuxt' | 'remix';
+    prod: boolean;
+}
+/**
+ * Handle SSR command from CLI
+ */
+export declare function handleSSRCommand(args: SSRCommandArgs): Promise<void>;

package/dist/commands/ssr.js

@@ -0,0 +1,30 @@
+/**
+ * SSR Server CLI Command Handler
+ */
+import { SSRServer } from '../meta-frameworks/ssr/server.js';
+import { loadConfig } from '../config/index.js';
+import { log } from '../utils/logger.js';
+/**
+ * Handle SSR command from CLI
+ */
+export async function handleSSRCommand(args) {
+    try {
+        log.info('🚀 Starting SSR Server...');
+        // Load config
+        const config = await loadConfig(process.cwd());
+        // Create SSR server
+        const server = new SSRServer({
+            root: config.root || process.cwd(),
+            framework: args.framework,
+            outDir: config.outDir || 'dist',
+            port: args.port,
+            production: args.prod || false,
+        });
+        // Start server
+        await server.start();
+    }
+    catch (error) {
+        log.error(`❌ SSR Server failed: ${error.message}`);
+        process.exit(1);
+    }
+}

package/dist/commands/verify.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Nuclie Verify CLI - Trust Anchor
+ *
+ * Comprehensive project verification with multiple modes:
+ * - nuclie verify (basic)
+ * - nuclie verify --ci (CI/CD mode)
+ * - nuclie verify --strict (strict validation)
+ * - nuclie verify --explain (detailed explanations)
+ */
+export interface VerifyOptions {
+    ci?: boolean;
+    strict?: boolean;
+    explain?: boolean;
+    fix?: boolean;
+}
+export interface VerifyResult {
+    passed: boolean;
+    checks: CheckResult[];
+    summary: {
+        total: number;
+        passed: number;
+        failed: number;
+        warnings: number;
+    };
+}
+export interface CheckResult {
+    name: string;
+    category: 'config' | 'graph' | 'adapter' | 'cache' | 'dependencies' | 'permissions';
+    status: 'pass' | 'fail' | 'warn';
+    message: string;
+    explanation?: string;
+    fix?: string;
+    details?: any;
+}
+/**
+ * Main verify function
+ */
+export declare function verify(options?: VerifyOptions): Promise<VerifyResult>;

package/dist/commands/verify.js

@@ -0,0 +1,459 @@
+/**
+ * Nuclie Verify CLI - Trust Anchor
+ *
+ * Comprehensive project verification with multiple modes:
+ * - nuclie verify (basic)
+ * - nuclie verify --ci (CI/CD mode)
+ * - nuclie verify --strict (strict validation)
+ * - nuclie verify --explain (detailed explanations)
+ */
+import fs from 'fs';
+import path from 'path';
+import kleur from 'kleur';
+/**
+ * Main verify function
+ */
+export async function verify(options = {}) {
+    const checks = [];
+    console.log(kleur.bold().cyan('\n⚡ Nuclie Verify - Project Health Check\n'));
+    // Run all checks
+    checks.push(...await checkConfig(options));
+    checks.push(...await checkGraph(options));
+    checks.push(...await checkAdapters(options));
+    checks.push(...await checkCache(options));
+    checks.push(...await checkDependencies(options));
+    checks.push(...await checkPermissions(options));
+    // Calculate summary
+    const summary = {
+        total: checks.length,
+        passed: checks.filter((c) => c.status === 'pass').length,
+        failed: checks.filter((c) => c.status === 'fail').length,
+        warnings: checks.filter((c) => c.status === 'warn').length
+    };
+    const passed = summary.failed === 0 && (!options.strict || summary.warnings === 0);
+    // Display results
+    displayResults(checks, summary, options);
+    return { passed, checks, summary };
+}
+/**
+ * 1. Config Validity Checks
+ */
+async function checkConfig(options) {
+    const checks = [];
+    const cwd = process.cwd();
+    console.log(kleur.bold('📋 Config Validation'));
+    // Check if config file exists
+    const configFiles = ['nuclie.config.ts', 'nuclie.config.js', 'nuclie.config.json'];
+    const configFile = configFiles.find(f => fs.existsSync(path.join(cwd, f)));
+    if (!configFile) {
+        checks.push({
+            name: 'Config File Exists',
+            category: 'config',
+            status: 'fail',
+            message: 'No nuclie.config file found',
+            explanation: options.explain ? 'Nuclie requires a configuration file to define build behavior' : undefined,
+            fix: 'Run: nuclie init to create a config file'
+        });
+        return checks;
+    }
+    checks.push({
+        name: 'Config File Exists',
+        category: 'config',
+        status: 'pass',
+        message: `Found ${configFile}`
+    });
+    // Try to load and validate config
+    try {
+        const { loadConfig } = await import('../config/index.js');
+        const config = await loadConfig(cwd);
+        checks.push({
+            name: 'Config Loads Successfully',
+            category: 'config',
+            status: 'pass',
+            message: 'Configuration loaded without errors'
+        });
+        // Validate config schema
+        if (config.plugins && config.plugins.length > 0) {
+            checks.push({
+                name: 'Plugins Configured',
+                category: 'config',
+                status: 'pass',
+                message: `${config.plugins.length} plugin(s) configured`
+            });
+        }
+        else {
+            checks.push({
+                name: 'Plugins Configured',
+                category: 'config',
+                status: options.strict ? 'fail' : 'warn',
+                message: 'No plugins configured',
+                explanation: options.explain ? 'Plugins enable framework-specific transformations and features' : undefined,
+                fix: 'Add plugins to nuclie.config'
+            });
+        }
+        // Check entry points
+        if (config.entry && config.entry.length > 0) {
+            const missingEntries = config.entry.filter((e) => !fs.existsSync(path.join(cwd, e)));
+            if (missingEntries.length > 0) {
+                checks.push({
+                    name: 'Entry Points Exist',
+                    category: 'config',
+                    status: 'fail',
+                    message: `Missing entry files: ${missingEntries.join(', ')}`,
+                    fix: 'Create the entry files or update config.entry'
+                });
+            }
+            else {
+                checks.push({
+                    name: 'Entry Points Exist',
+                    category: 'config',
+                    status: 'pass',
+                    message: `All ${config.entry.length} entry point(s) found`
+                });
+            }
+        }
+    }
+    catch (error) {
+        checks.push({
+            name: 'Config Loads Successfully',
+            category: 'config',
+            status: 'fail',
+            message: `Failed to load config: ${error.message}`,
+            explanation: options.explain ? 'Config file has syntax errors or invalid exports' : undefined,
+            fix: 'Check config file syntax and exports'
+        });
+    }
+    return checks;
+}
+/**
+ * 2. Graph Health Checks
+ */
+// Helper to scan imports
+// Helper to scan imports
+import { GraphAnalyzer } from '../native/index.js';
+async function checkGraph(options) {
+    const checks = [];
+    console.log(kleur.bold('\n🔍 Graph Health'));
+    try {
+        const { loadConfig } = await import('../config/index.js');
+        const config = await loadConfig(process.cwd());
+        const entryPoints = config.entry || [];
+        if (!entryPoints.length) {
+            checks.push({
+                name: 'Graph Analysis',
+                category: 'graph',
+                status: 'warn',
+                message: 'No entry points to analyze',
+            });
+            return checks;
+        }
+        const analyzer = new GraphAnalyzer();
+        const visited = new Set();
+        const queue = [];
+        const ids = [];
+        const edges = [];
+        // Initialize queue
+        for (const entry of entryPoints) {
+            const absEntry = path.resolve(process.cwd(), entry);
+            if (fs.existsSync(absEntry)) {
+                queue.push(absEntry);
+            }
+        }
+        // Basic DFS scanner
+        while (queue.length > 0) {
+            const current = queue.pop();
+            if (visited.has(current))
+                continue;
+            visited.add(current);
+            ids.push(current);
+            const currentEdges = [];
+            try {
+                const content = fs.readFileSync(current, 'utf-8');
+                // Regex for static imports
+                const importRegex = /import\s+(?:[\w\s{},*]+from\s+)?['"]([^'"]+)['"]/g;
+                let match;
+                while ((match = importRegex.exec(content)) !== null) {
+                    const importPath = match[1];
+                    // Very basic resolution (relative only for verify)
+                    if (importPath.startsWith('.')) {
+                        const dir = path.dirname(current);
+                        // Try extensions
+                        const extensions = ['.ts', '.tsx', '.js', '.jsx', '.css', '.scss'];
+                        let resolvedCall = path.resolve(dir, importPath);
+                        let matched = false;
+                        if (fs.existsSync(resolvedCall) && fs.statSync(resolvedCall).isFile()) {
+                            matched = true;
+                        }
+                        else {
+                            for (const ext of extensions) {
+                                if (fs.existsSync(resolvedCall + ext)) {
+                                    resolvedCall = resolvedCall + ext;
+                                    matched = true;
+                                    break;
+                                }
+                            }
+                        }
+                        if (matched) {
+                            currentEdges.push(resolvedCall);
+                            if (!visited.has(resolvedCall)) {
+                                queue.push(resolvedCall);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                // Ignore read errors
+            }
+            edges.push(currentEdges);
+        }
+        // Feed logic to Rust
+        analyzer.addBatch(ids, edges);
+        const cycles = analyzer.detectCycles();
+        if (cycles.length > 0) {
+            checks.push({
+                name: 'Circular Dependencies',
+                category: 'graph',
+                status: 'fail',
+                message: `Detected ${cycles.length} circular dependency chains`,
+                explanation: options.explain ? `Cycles: \n${cycles.map((c) => '   - ' + c.cycle.join(' -> ')).join('\n')}` : undefined,
+                fix: 'Refactor code to remove cycles'
+            });
+        }
+        else {
+            checks.push({
+                name: 'Circular Dependencies',
+                category: 'graph',
+                status: 'pass',
+                message: 'No circular dependencies detected',
+                details: { scanned: visited.size }
+            });
+        }
+        // Check for Orphans
+        // Orphans are tricky with basic scan, but we can verify reachability count
+        checks.push({
+            name: 'Graph Reachability',
+            category: 'graph',
+            status: 'pass',
+            message: `Scanned ${visited.size} files reachable from entry`
+        });
+    }
+    catch (e) {
+        checks.push({
+            name: 'Graph Analysis',
+            category: 'graph',
+            status: 'warn',
+            message: `Failed to analyze graph: ${e.message}`
+        });
+    }
+    return checks;
+}
+/**
+ * 3. Adapter Contract Checks
+ */
+async function checkAdapters(options) {
+    const checks = [];
+    console.log(kleur.bold('\n🔌 Adapter Contracts'));
+    try {
+        const { loadConfig } = await import('../config/index.js');
+        const config = await loadConfig(process.cwd());
+        if (config.plugins && config.plugins.length > 0) {
+            // Check if plugins have required properties
+            const pluginsWithIssues = config.plugins.filter((p) => !p || typeof p !== 'object');
+            if (pluginsWithIssues.length > 0) {
+                checks.push({
+                    name: 'Plugin Validity',
+                    category: 'adapter',
+                    status: 'warn',
+                    message: `${pluginsWithIssues.length} plugin(s) may have issues`,
+                    explanation: options.explain ? 'Plugins should be objects with proper configuration' : undefined
+                });
+            }
+            else {
+                checks.push({
+                    name: 'Plugin Validity',
+                    category: 'adapter',
+                    status: 'pass',
+                    message: 'All plugins appear valid'
+                });
+            }
+        }
+    }
+    catch (error) {
+        // Config already checked, skip adapter checks
+    }
+    return checks;
+}
+/**
+ * 4. Cache Integrity Checks
+ */
+async function checkCache(options) {
+    const checks = [];
+    console.log(kleur.bold('\n💾 Cache Integrity'));
+    const cacheDir = path.join(process.cwd(), '.nuclie_cache');
+    if (!fs.existsSync(cacheDir)) {
+        checks.push({
+            name: 'Cache Directory',
+            category: 'cache',
+            status: 'warn',
+            message: 'No cache directory found (will be created on first build)',
+            explanation: options.explain ? 'Cache improves rebuild performance' : undefined
+        });
+        return checks;
+    }
+    checks.push({
+        name: 'Cache Directory',
+        category: 'cache',
+        status: 'pass',
+        message: 'Cache directory exists'
+    });
+    // Check cache database
+    const dbPath = path.join(cacheDir, 'build.db');
+    if (fs.existsSync(dbPath)) {
+        try {
+            // Try to open the database
+            const Database = (await import('better-sqlite3')).default;
+            const db = new Database(dbPath, { readonly: true });
+            db.close();
+            checks.push({
+                name: 'Cache Database',
+                category: 'cache',
+                status: 'pass',
+                message: 'Cache database is valid'
+            });
+        }
+        catch (error) {
+            checks.push({
+                name: 'Cache Database',
+                category: 'cache',
+                status: 'fail',
+                message: 'Cache database is corrupted',
+                explanation: options.explain ? 'Corrupted cache can cause build failures' : undefined,
+                fix: `Delete cache: rm -rf ${cacheDir}`
+            });
+        }
+    }
+    return checks;
+}
+/**
+ * 5. Dependency Version Checks
+ */
+async function checkDependencies(options) {
+    const checks = [];
+    console.log(kleur.bold('\n📦 Dependencies'));
+    const pkgPath = path.join(process.cwd(), 'package.json');
+    if (!fs.existsSync(pkgPath)) {
+        checks.push({
+            name: 'package.json',
+            category: 'dependencies',
+            status: 'fail',
+            message: 'No package.json found',
+            fix: 'Run: npm init'
+        });
+        return checks;
+    }
+    checks.push({
+        name: 'package.json',
+        category: 'dependencies',
+        status: 'pass',
+        message: 'package.json exists'
+    });
+    // Check if node_modules exists
+    const nodeModulesPath = path.join(process.cwd(), 'node_modules');
+    if (!fs.existsSync(nodeModulesPath)) {
+        checks.push({
+            name: 'Dependencies Installed',
+            category: 'dependencies',
+            status: 'fail',
+            message: 'node_modules not found',
+            fix: 'Run: npm install'
+        });
+    }
+    else {
+        checks.push({
+            name: 'Dependencies Installed',
+            category: 'dependencies',
+            status: 'pass',
+            message: 'Dependencies installed'
+        });
+    }
+    return checks;
+}
+/**
+ * 6. File Permission Checks
+ */
+async function checkPermissions(options) {
+    const checks = [];
+    console.log(kleur.bold('\n🔐 Permissions'));
+    const cwd = process.cwd();
+    // Check write permissions
+    try {
+        const testFile = path.join(cwd, '.nuclie_verify_test');
+        fs.writeFileSync(testFile, 'test');
+        fs.unlinkSync(testFile);
+        checks.push({
+            name: 'Write Permissions',
+            category: 'permissions',
+            status: 'pass',
+            message: 'Directory is writable'
+        });
+    }
+    catch (error) {
+        checks.push({
+            name: 'Write Permissions',
+            category: 'permissions',
+            status: 'fail',
+            message: 'Cannot write to project directory',
+            fix: 'Check file permissions'
+        });
+    }
+    return checks;
+}
+/**
+ * Display verification results
+ */
+function displayResults(checks, summary, options) {
+    console.log(kleur.bold('\n' + '═'.repeat(80)));
+    console.log(kleur.bold('📊 Verification Summary'));
+    console.log(kleur.bold('═'.repeat(80) + '\n'));
+    // Group by category
+    const categories = ['config', 'graph', 'adapter', 'cache', 'dependencies', 'permissions'];
+    categories.forEach((category) => {
+        const categoryChecks = checks.filter((c) => c.category === category);
+        if (categoryChecks.length === 0)
+            return;
+        categoryChecks.forEach((check) => {
+            const icon = check.status === 'pass' ? '✅' : check.status === 'fail' ? '❌' : '⚠️';
+            const color = check.status === 'pass' ? kleur.green : check.status === 'fail' ? kleur.red : kleur.yellow;
+            console.log(color(`${icon} ${check.name}: ${check.message}`));
+            if (options.explain && check.explanation) {
+                console.log(kleur.dim(`   ℹ️  ${check.explanation}`));
+            }
+            if (check.fix) {
+                console.log(kleur.cyan(`   💡 ${check.fix}`));
+            }
+        });
+    });
+    // Summary
+    console.log(kleur.bold('\n' + '─'.repeat(80)));
+    console.log(kleur.bold(`Total Checks: ${summary.total}`));
+    console.log(kleur.green(`✅ Passed: ${summary.passed}`));
+    if (summary.failed > 0) {
+        console.log(kleur.red(`❌ Failed: ${summary.failed}`));
+    }
+    if (summary.warnings > 0) {
+        console.log(kleur.yellow(`⚠️  Warnings: ${summary.warnings}`));
+    }
+    const passed = summary.failed === 0 && (!options.strict || summary.warnings === 0);
+    console.log(kleur.bold('\n' + '═'.repeat(80)));
+    if (passed) {
+        console.log(kleur.bold().green('✅ Verification PASSED'));
+    }
+    else {
+        console.log(kleur.bold().red('❌ Verification FAILED'));
+        if (options.ci) {
+            process.exit(1);
+        }
+    }
+    console.log(kleur.bold('═'.repeat(80) + '\n'));
+}

package/dist/config/index.d.ts

@@ -0,0 +1,145 @@
+import { z } from 'zod';
+export type BuildMode = 'development' | 'production' | 'test';
+export declare const BuildConfigSchema: z.ZodObject<{
+    root: z.ZodOptional<z.ZodString>;
+    adapter: z.ZodOptional<z.ZodString>;
+    framework: z.ZodOptional<z.ZodString>;
+    entry: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        development: "development";
+        production: "production";
+        test: "test";
+    }>>;
+    outDir: z.ZodDefault<z.ZodString>;
+    port: z.ZodDefault<z.ZodNumber>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    esbuildPlugins: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    platform: z.ZodDefault<z.ZodEnum<{
+        browser: "browser";
+        node: "node";
+        edge: "edge";
+    }>>;
+    preset: z.ZodDefault<z.ZodEnum<{
+        spa: "spa";
+        ssr: "ssr";
+        ssg: "ssg";
+    }>>;
+    federation: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        exposes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        remotes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        shared: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            singleton: z.ZodOptional<z.ZodBoolean>;
+            requiredVersion: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        prefetch: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fallback: z.ZodOptional<z.ZodString>;
+        mock: z.ZodOptional<z.ZodBoolean>;
+        healthCheck: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    css: z.ZodOptional<z.ZodObject<{
+        framework: z.ZodOptional<z.ZodEnum<{
+            tailwind: "tailwind";
+            bootstrap: "bootstrap";
+            bulma: "bulma";
+            material: "material";
+            none: "none";
+        }>>;
+        purge: z.ZodOptional<z.ZodBoolean>;
+        critical: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    build: z.ZodOptional<z.ZodObject<{
+        minify: z.ZodOptional<z.ZodBoolean>;
+        sourcemap: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodEnum<{
+            none: "none";
+            inline: "inline";
+            external: "external";
+            hidden: "hidden";
+        }>, z.ZodBoolean]>, z.ZodTransform<"none" | "inline" | "external" | "hidden", boolean | "none" | "inline" | "external" | "hidden">>>;
+        splitting: z.ZodOptional<z.ZodBoolean>;
+        cssModules: z.ZodDefault<z.ZodBoolean>;
+        targets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        manualChunks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>;
+    server: z.ZodOptional<z.ZodObject<{
+        host: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodNumber>;
+        strictPort: z.ZodOptional<z.ZodBoolean>;
+        cors: z.ZodOptional<z.ZodBoolean>;
+        open: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        proxy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>>;
+        https: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            key: z.ZodString;
+            cert: z.ZodString;
+        }, z.core.$strip>]>>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>;
+    prebundle: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$loose>;
+export type BuildConfig = {
+    root: string;
+    adapter?: string;
+    framework?: string;
+    entry: string[];
+    mode: 'development' | 'production' | 'test';
+    outDir: string;
+    port: number;
+    plugins?: any[];
+    esbuildPlugins?: any[];
+    platform: 'browser' | 'node' | 'edge';
+    preset: 'spa' | 'ssr' | 'ssg';
+    federation?: {
+        name: string;
+        filename?: string;
+        exposes?: Record<string, string>;
+        remotes?: Record<string, string>;
+        shared?: Record<string, {
+            singleton?: boolean;
+            requiredVersion?: string;
+        }>;
+        prefetch?: string[];
+        fallback?: string;
+        mock?: boolean;
+        healthCheck?: string;
+    };
+    css?: {
+        framework?: 'tailwind' | 'bootstrap' | 'bulma' | 'material' | 'none';
+        purge?: boolean;
+        critical?: boolean;
+    };
+    build?: {
+        minify?: boolean;
+        sourcemap?: 'inline' | 'external' | 'hidden' | 'none';
+        splitting?: boolean;
+        cssModules?: boolean;
+        targets?: string[];
+        manualChunks?: Record<string, string[]>;
+    };
+    server?: {
+        host?: string;
+        port?: number;
+        strictPort?: boolean;
+        cors?: boolean | any;
+        open?: boolean | string;
+        proxy?: Record<string, string | any>;
+        https?: boolean | {
+            key: string;
+            cert: string;
+        };
+        headers?: Record<string, string>;
+    };
+    prebundle?: {
+        enabled?: boolean;
+        include?: string[];
+        exclude?: string[];
+    };
+    cache?: boolean;
+};
+export declare function loadConfig(cwd: string): Promise<BuildConfig>;
+export declare function saveConfig(cwd: string, config: any): Promise<void>;
+export declare function defineConfig(config: Partial<BuildConfig>): Partial<BuildConfig>;