nuclie 1.0.0

package/dist/create/ui.js

@@ -0,0 +1,218 @@
+import readline from 'readline';
+import kleur from 'kleur';
+const lineBuffer = [];
+let pendingResolve = null;
+let pipedInited = false;
+let sharedRL = null;
+function initPipedInput() {
+    if (pipedInited)
+        return;
+    pipedInited = true;
+    sharedRL = readline.createInterface({
+        input: process.stdin,
+        terminal: false
+    });
+    sharedRL.on('line', (line) => {
+        if (pendingResolve) {
+            const res = pendingResolve;
+            pendingResolve = null;
+            res(line);
+        }
+        else {
+            lineBuffer.push(line);
+        }
+    });
+}
+function readLineFromPipe() {
+    initPipedInput();
+    if (lineBuffer.length > 0) {
+        return Promise.resolve(lineBuffer.shift());
+    }
+    return new Promise((resolve) => {
+        pendingResolve = resolve;
+    });
+}
+function onKeyPress(callback) {
+    readline.emitKeypressEvents(process.stdin);
+    const handler = (str, key) => {
+        if (key && key.ctrl && key.name === 'c') {
+            process.exit(0);
+        }
+        callback(str, key);
+    };
+    process.stdin.on('keypress', handler);
+    return () => {
+        process.stdin.off('keypress', handler);
+    };
+}
+export function closeUI() {
+    if (sharedRL) {
+        sharedRL.close();
+        sharedRL = null;
+    }
+    pipedInited = false;
+}
+function cleanup() {
+    if (process.stdin.isTTY && typeof process.stdin.setRawMode === 'function') {
+        process.stdin.setRawMode(false);
+    }
+}
+/**
+ * Interactive Text Input
+ */
+export async function text(question, initial = '') {
+    const forceFallback = process.env.NUCLIE_NON_INTERACTIVE === 'true';
+    if (!forceFallback && process.stdin.isTTY) {
+        return new Promise((resolve) => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            rl.question(`${kleur.cyan(question)} ${kleur.dim(`(${initial})`)} `, (answer) => {
+                rl.close();
+                resolve(answer || initial);
+            });
+        });
+    }
+    else {
+        process.stdout.write(`${question} (${initial}): `);
+        const answer = await readLineFromPipe();
+        return answer || initial;
+    }
+}
+/**
+ * Interactive Select (Radio)
+ */
+export async function select(question, options) {
+    const forceFallback = process.env.NUCLIE_NON_INTERACTIVE === 'true';
+    if (!forceFallback && process.stdin.isTTY && typeof process.stdin.setRawMode === 'function') {
+        return new Promise((resolve) => {
+            let index = 0;
+            const render = (clear = false) => {
+                if (clear) {
+                    process.stdout.write(`\x1b[${options.length}A`);
+                }
+                options.forEach((opt, i) => {
+                    const isSelected = i === index;
+                    const icon = isSelected ? kleur.green('❯') : ' ';
+                    const label = isSelected ? kleur.cyan().bold(opt) : opt;
+                    const shortcut = i < 9 ? kleur.dim(`(${i + 1})`) : '';
+                    process.stdout.write(`\x1b[2K\r  ${icon} ${label} ${shortcut}\n`);
+                });
+            };
+            console.log(`${kleur.bold(question)}`);
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            render();
+            const cleanupListener = onKeyPress((_str, key) => {
+                if (key.name === 'up' || key.name === 'k') {
+                    index = (index - 1 + options.length) % options.length;
+                    render(true);
+                }
+                else if (key.name === 'down' || key.name === 'j') {
+                    index = (index + 1) % options.length;
+                    render(true);
+                }
+                else if (key.name === 'return') {
+                    cleanupListener();
+                    cleanup();
+                    resolve(options[index]);
+                }
+                else if (/[1-9]/.test(key.name)) {
+                    const num = parseInt(key.name) - 1;
+                    if (num >= 0 && num < options.length) {
+                        index = num;
+                        render(true);
+                    }
+                }
+            });
+        });
+    }
+    else {
+        options.forEach((opt, i) => console.log(`  [${i + 1}] ${opt}`));
+        process.stdout.write(`${question} Choose (1-${options.length}): `);
+        const answer = await readLineFromPipe();
+        const idx = parseInt(answer) - 1;
+        return options[idx] || options[0];
+    }
+}
+/**
+ * Interactive MultiSelect (Checkbox)
+ */
+export async function multiselect(question, options, defaults = []) {
+    const forceFallback = process.env.NUCLIE_NON_INTERACTIVE === 'true';
+    if (!forceFallback && process.stdin.isTTY && typeof process.stdin.setRawMode === 'function') {
+        return new Promise((resolve) => {
+            let index = 0;
+            const selected = new Set();
+            options.forEach((_, i) => {
+                if (defaults[i])
+                    selected.add(i);
+            });
+            const render = (clear = false) => {
+                if (clear) {
+                    process.stdout.write(`\x1b[${options.length + 1}A`);
+                }
+                process.stdout.write(`\x1b[2K\r${kleur.dim('(Press <space> to select, <enter> to confirm)')}\n`);
+                options.forEach((opt, i) => {
+                    const isFocused = i === index;
+                    const isChecked = selected.has(i);
+                    const cursor = isFocused ? kleur.cyan('❯') : ' ';
+                    const checkbox = isChecked ? kleur.green('✔') : kleur.dim('○');
+                    const label = isFocused ? kleur.bold(opt) : opt;
+                    const shortcut = i < 9 ? kleur.dim(`(${i + 1})`) : '';
+                    process.stdout.write(`\x1b[2K\r  ${cursor} ${checkbox} ${label} ${shortcut}\n`);
+                });
+            };
+            console.log(`${kleur.bold(question)}`);
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            render();
+            const cleanupListener = onKeyPress((_str, key) => {
+                if (key.name === 'up' || key.name === 'k') {
+                    index = (index - 1 + options.length) % options.length;
+                    render(true);
+                }
+                else if (key.name === 'down' || key.name === 'j') {
+                    index = (index + 1) % options.length;
+                    render(true);
+                }
+                else if (key.name === 'space') {
+                    if (selected.has(index)) {
+                        selected.delete(index);
+                    }
+                    else {
+                        selected.add(index);
+                    }
+                    render(true);
+                }
+                else if (key.name === 'return') {
+                    cleanupListener();
+                    cleanup();
+                    const result = options.filter((_, i) => selected.has(i));
+                    resolve(result);
+                }
+                else if (/[1-9]/.test(key.name)) {
+                    const num = parseInt(key.name) - 1;
+                    if (num >= 0 && num < options.length) {
+                        index = num;
+                        if (selected.has(index)) {
+                            selected.delete(index);
+                        }
+                        else {
+                            selected.add(index);
+                        }
+                        render(true);
+                    }
+                }
+            });
+        });
+    }
+    else {
+        options.forEach((opt, i) => console.log(`  [${i + 1}] ${opt}`));
+        process.stdout.write(`${question} Choose comma-separated indices (e.g. 1,2): `);
+        const answer = await readLineFromPipe();
+        const indices = answer.split(',').map(s => parseInt(s.trim()) - 1);
+        return options.filter((_, i) => indices.includes(i));
+    }
+}

package/dist/create-nuclie/cli.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Create-Nuclie CLI
+ * Generates projects for 12 frameworks in <30s
+ * Day 17: Create-Nuclie Templates Lock
+ */
+declare function main(): Promise<void>;
+export { main };

package/dist/create-nuclie/cli.js

@@ -0,0 +1,73 @@
+/**
+ * Create-Nuclie CLI
+ * Generates projects for 12 frameworks in <30s
+ * Day 17: Create-Nuclie Templates Lock
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { TEMPLATES } from './templates.js';
+import { red, green, blue, bold } from 'kleur/colors';
+async function main() {
+    const args = process.argv.slice(2);
+    // Usage: node cli.js <project-name> --template <template>
+    let projectName = args[0];
+    let templateName = args.indexOf('--template') > -1 ? args[args.indexOf('--template') + 1] : null;
+    // Interactive Stub (For real usage, use prompts/inquirer)
+    if (!projectName) {
+        console.error(red('Please specify project name: create-nuclie <name>'));
+        process.exit(1);
+    }
+    if (!templateName) {
+        console.log(blue('Available templates:'));
+        Object.keys(TEMPLATES).forEach(t => console.log(`- ${t}`));
+        console.error(red('Please specify template: --template <name>'));
+        process.exit(1);
+    }
+    const template = TEMPLATES[templateName];
+    if (!template) {
+        console.error(red(`Unknown template: ${templateName}`));
+        process.exit(1);
+    }
+    const targetDir = path.resolve(process.cwd(), projectName);
+    if (fs.existsSync(targetDir)) {
+        console.error(red(`Target directory ${projectName} already exists`));
+        process.exit(1);
+    }
+    console.log(blue(`\n🚀 Scaffolding ${bold(template.name)} project in ${bold(projectName)}...`));
+    // 1. Create Dir
+    fs.mkdirSync(targetDir, { recursive: true });
+    // 2. Create Files
+    for (const file of template.files) {
+        const filePath = path.join(targetDir, file.path);
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(filePath, file.content);
+    }
+    // 3. Create package.json
+    const pkg = {
+        name: projectName,
+        version: '0.0.0',
+        type: 'module',
+        scripts: {
+            "dev": "nuclie dev",
+            "build": "nuclie build",
+            "preview": "nuclie preview"
+        },
+        dependencies: template.dependencies,
+        devDependencies: {
+            ...template.devDependencies,
+            "nuclie": "latest"
+        }
+    };
+    fs.writeFileSync(path.join(targetDir, 'package.json'), JSON.stringify(pkg, null, 2));
+    console.log(green(`\n✅ Done. Now run:\n`));
+    console.log(`  cd ${projectName}`);
+    console.log(`  npm install`);
+    console.log(`  npm run dev\n`);
+}
+// Only run if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch(err => console.error(err));
+}
+export { main }; // For testing

package/dist/create-nuclie/templates.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Nuclie Template Definitions
+ * Defines the file structure for 12 supported frameworks.
+ * Day 17: Create-Nuclie Templates Lock
+ */
+export interface TemplateFile {
+    path: string;
+    content: string;
+}
+export interface TemplateDef {
+    id: string;
+    name: string;
+    description: string;
+    files: TemplateFile[];
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+}
+export declare const TEMPLATES: Record<string, TemplateDef>;

package/dist/create-nuclie/templates.js

@@ -0,0 +1,73 @@
+/**
+ * Nuclie Template Definitions
+ * Defines the file structure for 12 supported frameworks.
+ * Day 17: Create-Nuclie Templates Lock
+ */
+// Minimal definitions for the 12 frameworks to prove capability.
+// In a real repo, these would be larger or loaded from external storage.
+const COMMON_FILES = [
+    {
+        path: 'nuclie.config.ts',
+        content: `export default {
+    mode: 'development',
+    plugins: []
+};`
+    },
+    {
+        path: 'tsconfig.json',
+        content: `{
+    "compilerOptions": {
+        "target": "ESNext",
+        "module": "ESNext",
+        "moduleResolution": "bundler",
+        "strict": true,
+        "jsx": "preserve"
+    }
+}`
+    }
+];
+export const TEMPLATES = {
+    react: {
+        id: 'react',
+        name: 'React',
+        description: 'React Latest + TypeScript + Nuclie',
+        files: [
+            ...COMMON_FILES,
+            { path: 'src/main.tsx', content: `import { createRoot } from 'react-dom/client'; import App from './App'; createRoot(document.getElementById('root')!).render(<App />);` },
+            { path: 'src/App.tsx', content: `export default function App() { return <h1>Hello Nuclie React</h1>; }` },
+            { path: 'index.html', content: `<!DOCTYPE html><body><div id="root"></div><script type="module" src="/src/main.tsx"></script></body>` }
+        ],
+        dependencies: { "react": "latest", "react-dom": "latest" },
+        devDependencies: { "@types/react": "latest", "@types/react-dom": "latest" }
+    },
+    vue: {
+        id: 'vue',
+        name: 'Vue',
+        description: 'Vue Latest + TypeScript',
+        files: [
+            ...COMMON_FILES,
+            { path: 'src/main.ts', content: `import { createApp } from 'vue'; import App from './App.vue'; createApp(App).mount('#app');` },
+            { path: 'src/App.vue', content: `<template><h1>Hello Nuclie Vue</h1></template>` },
+            { path: 'index.html', content: `<!DOCTYPE html><body><div id="app"></div><script type="module" src="/src/main.ts"></script></body>` }
+        ],
+        dependencies: { "vue": "latest" },
+        devDependencies: { "@vue/compiler-sfc": "latest" }
+    },
+    svelte: {
+        id: 'svelte',
+        name: 'Svelte',
+        description: 'Svelte Latest + TypeScript',
+        files: [...COMMON_FILES, { path: 'src/main.ts', content: '' }],
+        dependencies: { "svelte": "latest" },
+        devDependencies: {}
+    },
+    solid: { id: 'solid', name: 'Solid', description: 'SolidJS Signal Power', files: [...COMMON_FILES], dependencies: { "solid-js": "latest" }, devDependencies: {} },
+    lit: { id: 'lit', name: 'Lit', description: 'Web Components', files: [...COMMON_FILES], dependencies: { "lit": "latest" }, devDependencies: {} },
+    angular: { id: 'angular', name: 'Angular', description: 'Angular Ivy', files: [...COMMON_FILES], dependencies: { "@angular/core": "latest" }, devDependencies: {} },
+    preact: { id: 'preact', name: 'Preact', description: 'Fast 3kb React alt', files: [...COMMON_FILES], dependencies: { "preact": "latest" }, devDependencies: {} },
+    qwik: { id: 'qwik', name: 'Qwik', description: 'Resumable Framework', files: [...COMMON_FILES], dependencies: { "@builder.io/qwik": "latest" }, devDependencies: {} },
+    astro: { id: 'astro', name: 'Astro', description: 'Content Focused', files: [...COMMON_FILES], dependencies: { "astro": "latest" }, devDependencies: {} },
+    next: { id: 'next', name: 'Next-like', description: 'React SSR Router', files: [...COMMON_FILES], dependencies: { "react": "latest", "wouter": "latest" }, devDependencies: {} },
+    nuxt: { id: 'nuxt', name: 'Nuxt-like', description: 'Vue Meta Framework', files: [...COMMON_FILES], dependencies: { "vue": "latest", "vue-router": "latest" }, devDependencies: {} },
+    sveltekit: { id: 'sveltekit', name: 'SvelteKit-like', description: 'Svelte Fullstack', files: [...COMMON_FILES], dependencies: { "svelte": "latest" }, devDependencies: {} },
+};

package/dist/create-nuclie.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/create-nuclie.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { createNuclieProject } from './create/index.js';
+const projectName = process.argv[2];
+createNuclieProject(projectName).catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/dashboard/metrics.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Nuclie Dashboard Metrics Collector
+ * Day 19: tRPC Dashboard Lock
+ */
+export interface BuildMetric {
+    id: string;
+    timestamp: number;
+    durationMs: number;
+    moduleCount: number;
+    cacheHitRate: number;
+}
+export declare class MetricsCollector {
+    private static instance;
+    private builds;
+    private errors;
+    private hmrEvents;
+    private constructor();
+    static getInstance(): MetricsCollector;
+    recordBuild(durationMs: number, moduleCount: number, cacheHitRate: number): void;
+    recordError(): void;
+    recordHMR(): void;
+    getSummary(): {
+        totalBuilds: number;
+        errors: number;
+        hmrEvents: number;
+        lastBuildTime: number;
+        avgBuildTime: number;
+        cacheEfficiency: number;
+    };
+    generateReport(): string;
+}

package/dist/dashboard/metrics.js

@@ -0,0 +1,59 @@
+/**
+ * Nuclie Dashboard Metrics Collector
+ * Day 19: tRPC Dashboard Lock
+ */
+export class MetricsCollector {
+    constructor() {
+        // Stats
+        this.builds = [];
+        this.errors = 0;
+        this.hmrEvents = 0;
+    }
+    static getInstance() {
+        if (!MetricsCollector.instance) {
+            MetricsCollector.instance = new MetricsCollector();
+        }
+        return MetricsCollector.instance;
+    }
+    recordBuild(durationMs, moduleCount, cacheHitRate) {
+        this.builds.push({
+            id: Math.random().toString(36).substr(2, 9),
+            timestamp: Date.now(),
+            durationMs,
+            moduleCount,
+            cacheHitRate
+        });
+        // Keep last 100
+        if (this.builds.length > 100)
+            this.builds.shift();
+    }
+    recordError() {
+        this.errors++;
+    }
+    recordHMR() {
+        this.hmrEvents++;
+    }
+    getSummary() {
+        const lastBuild = this.builds[this.builds.length - 1];
+        const avgDuration = this.builds.length
+            ? this.builds.reduce((acc, b) => acc + b.durationMs, 0) / this.builds.length
+            : 0;
+        return {
+            totalBuilds: this.builds.length,
+            errors: this.errors,
+            hmrEvents: this.hmrEvents,
+            lastBuildTime: lastBuild ? lastBuild.durationMs : 0,
+            avgBuildTime: avgDuration,
+            cacheEfficiency: lastBuild ? lastBuild.cacheHitRate : 0
+        };
+    }
+    generateReport() {
+        const summary = this.getSummary();
+        return JSON.stringify({
+            title: 'Nuclie Build Report',
+            generatedAt: new Date().toISOString(),
+            stats: summary,
+            history: this.builds.slice(-10) // Last 10 details
+        }, null, 2);
+    }
+}

package/dist/dashboard/server/router.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Nuclie Dashboard tRPC Router
+ * Day 19: tRPC Dashboard Lock
+ */
+export declare const dashboardRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: object;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    getMetrics: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            totalBuilds: number;
+            errors: number;
+            hmrEvents: number;
+            lastBuildTime: number;
+            avgBuildTime: number;
+            cacheEfficiency: number;
+        };
+        meta: object;
+    }>;
+    getHistory: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            metrics: {
+                totalBuilds: number;
+                errors: number;
+                hmrEvents: number;
+                lastBuildTime: number;
+                avgBuildTime: number;
+                cacheEfficiency: number;
+            };
+            status: string;
+        };
+        meta: object;
+    }>;
+    generateReport: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: string;
+        meta: object;
+    }>;
+    runAudit: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            score: number;
+            issues: never[];
+        };
+        meta: object;
+    }>;
+}>>;
+export type DashboardRouter = typeof dashboardRouter;

package/dist/dashboard/server/router.js

@@ -0,0 +1,36 @@
+/**
+ * Nuclie Dashboard tRPC Router
+ * Day 19: tRPC Dashboard Lock
+ */
+import { initTRPC } from '@trpc/server';
+import { MetricsCollector } from '../metrics.js';
+const t = initTRPC.create();
+const collector = MetricsCollector.getInstance();
+export const dashboardRouter = t.router({
+    // Live Metrics
+    getMetrics: t.procedure.query(() => {
+        return collector.getSummary();
+    }),
+    // Build History
+    getHistory: t.procedure.query(() => {
+        // We can expose the raw array or a slice
+        // Accessing private 'builds' via generateReport logic or similar accessor.
+        // We'll trust generateReport for full data or rely on memory reference if we exposed it.
+        // For type safety, we'll return summary + last build ID.
+        const summary = collector.getSummary();
+        return {
+            metrics: summary,
+            status: summary.errors > 0 ? 'unstable' : 'healthy'
+        };
+    }),
+    // Generate Shareable Report
+    generateReport: t.procedure.mutation(() => {
+        return collector.generateReport();
+    }),
+    // Trigger Audit (Simulation)
+    runAudit: t.procedure.mutation(async () => {
+        // Simulate an audit running
+        await new Promise(r => setTimeout(r, 50));
+        return { score: 98, issues: [] };
+    })
+});

package/dist/dev/__tests__/preBundler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dev/__tests__/preBundler.test.js

@@ -0,0 +1,51 @@
+import { describe, expect, it, beforeEach, jest } from '@jest/globals';
+import path from 'path';
+// MUST be before imports
+jest.unstable_mockModule('fs/promises', () => ({
+    __esModule: true,
+    default: {
+        mkdir: jest.fn(),
+        readFile: jest.fn(),
+        writeFile: jest.fn(),
+        access: jest.fn(),
+    }
+}));
+jest.unstable_mockModule('esbuild', () => ({
+    __esModule: true,
+    build: jest.fn()
+}));
+jest.unstable_mockModule('../../utils/logger.js', () => ({
+    __esModule: true,
+    log: {
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+        debug: jest.fn()
+    }
+}));
+// Dynamic imports will be used in tests
+const fs = await import('fs/promises');
+const { build } = await import('esbuild');
+const { DependencyPreBundler } = await import('../preBundler.js');
+describe('DependencyPreBundler', () => {
+    let preBundler;
+    const mockRoot = '/mock/root';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        preBundler = new DependencyPreBundler(mockRoot);
+        // Default fs mocks
+        fs.default.mkdir.mockResolvedValue(undefined);
+        fs.default.readFile.mockResolvedValue('{}');
+        build.mockResolvedValue({ metafile: { outputs: {} } });
+    });
+    it('should calculate package hash from package.json', async () => {
+        fs.default.readFile.mockImplementation(((p) => {
+            if (p.includes('package.json')) {
+                return Promise.resolve(JSON.stringify({ dependencies: { 'react': '1.0.0' } }));
+            }
+            return Promise.resolve('{}');
+        }));
+        await preBundler.preBundleDependencies(['react']);
+        expect(fs.default.readFile).toHaveBeenCalledWith(path.join(mockRoot, 'package.json'), 'utf-8');
+    });
+});

package/dist/dev/configWatcher.d.ts

@@ -0,0 +1,10 @@
+export type ReloadType = 'hot' | 'rebuild' | 'restart';
+export declare class ConfigWatcher {
+    private root;
+    private onReload;
+    private watcher;
+    constructor(root: string, onReload: (type: ReloadType, file: string) => void);
+    start(): void;
+    private determineReloadType;
+    close(): Promise<void>;
+}