nuclie 1.0.0

package/dist/presets/core.js

@@ -0,0 +1,239 @@
+/**
+ * @nuclie/preset-core
+ *
+ * Opinionated defaults for 80% of applications.
+ * Zero-config experience with smart auto-detection.
+ *
+ * Philosophy:
+ * - Convention over configuration
+ * - Auto-detect framework from package.json
+ * - Smart defaults that "just work"
+ * - Easy to override when needed
+ */
+import fs from 'fs';
+import path from 'path';
+/**
+ * Core preset implementation
+ */
+export class CorePreset {
+    constructor(cwd, options = {}) {
+        this.cwd = cwd;
+        this.options = {
+            autoDetectFramework: options.autoDetectFramework ?? true,
+            autoDetectEntry: options.autoDetectEntry ?? true,
+            autoEnableHMR: options.autoEnableHMR ?? true,
+            autoConfigureCSS: options.autoConfigureCSS ?? true,
+            autoConfigureAssets: options.autoConfigureAssets ?? true,
+            portStrategy: options.portStrategy ?? 'auto',
+            outDir: options.outDir ?? 'dist',
+            publicDir: options.publicDir ?? 'public',
+            srcDir: options.srcDir ?? 'src'
+        };
+    }
+    /**
+     * Apply core preset to build config
+     */
+    apply(config = {}) {
+        const preset = { ...config };
+        // 1. Auto-detect framework
+        if (this.options.autoDetectFramework && !config.plugins) {
+            const detection = this.detectFramework();
+            if (detection.framework) {
+                console.log(`🔍 Auto-detected framework: ${detection.framework} (${detection.confidence} confidence)`);
+                // Framework plugins would be loaded here
+            }
+        }
+        // 2. Auto-detect entry points
+        if (this.options.autoDetectEntry && !config.entry) {
+            preset.entry = this.detectEntryPoints();
+            console.log(`🔍 Auto-detected entry: ${preset.entry.join(', ')}`);
+        }
+        // 3. Auto-configure port
+        if (!config.port) {
+            preset.port = this.selectPort();
+        }
+        // 4. Auto-configure directories
+        if (!config.outDir) {
+            preset.outDir = this.options.outDir;
+        }
+        // 5. Auto-enable HMR in development
+        if (this.options.autoEnableHMR && config.mode === 'development') {
+            // HMR is enabled by default in dev server
+        }
+        // 6. Auto-configure CSS
+        if (this.options.autoConfigureCSS && !config.css) {
+            preset.css = this.detectCSSFramework();
+        }
+        // 7. Set smart defaults
+        preset.root = preset.root || this.cwd;
+        preset.mode = preset.mode || 'development';
+        preset.platform = preset.platform || 'browser';
+        preset.preset = preset.preset || 'spa';
+        return preset;
+    }
+    /**
+     * Detect framework from package.json
+     */
+    detectFramework() {
+        const pkgPath = path.join(this.cwd, 'package.json');
+        if (!fs.existsSync(pkgPath)) {
+            return {
+                framework: null,
+                version: null,
+                confidence: 'low',
+                source: 'manual'
+            };
+        }
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        const allDeps = {
+            ...pkg.dependencies,
+            ...pkg.devDependencies,
+            ...pkg.peerDependencies
+        };
+        // Framework detection priority (most specific first)
+        const frameworkPatterns = [
+            { name: 'react', packages: ['react', 'react-dom'], confidence: 'high' },
+            { name: 'vue', packages: ['vue'], confidence: 'high' },
+            { name: 'svelte', packages: ['svelte'], confidence: 'high' },
+            { name: 'solid-js', packages: ['solid-js'], confidence: 'high' },
+            { name: 'lit', packages: ['lit'], confidence: 'high' },
+            { name: 'preact', packages: ['preact'], confidence: 'high' },
+            { name: 'alpine', packages: ['alpinejs'], confidence: 'high' },
+            { name: 'mithril', packages: ['mithril'], confidence: 'high' },
+            { name: 'angular', packages: ['@angular/core'], confidence: 'high' },
+            { name: 'qwik', packages: ['@builder.io/qwik'], confidence: 'high' },
+            { name: 'astro', packages: ['astro'], confidence: 'high' },
+        ];
+        for (const pattern of frameworkPatterns) {
+            for (const pkgName of pattern.packages) {
+                if (allDeps[pkgName]) {
+                    const source = pkgName in (pkg.dependencies || {}) ? 'dependencies' :
+                        pkgName in (pkg.devDependencies || {}) ? 'devDependencies' :
+                            'peerDependencies';
+                    return {
+                        framework: pattern.name,
+                        version: allDeps[pkgName],
+                        confidence: pattern.confidence,
+                        source: source
+                    };
+                }
+            }
+        }
+        return {
+            framework: null,
+            version: null,
+            confidence: 'low',
+            source: 'manual'
+        };
+    }
+    /**
+     * Detect entry points from common locations
+     */
+    detectEntryPoints() {
+        const candidates = [
+            // TypeScript + JSX
+            'src/main.tsx',
+            'src/index.tsx',
+            'src/app.tsx',
+            // TypeScript
+            'src/main.ts',
+            'src/index.ts',
+            'src/app.ts',
+            // JavaScript + JSX
+            'src/main.jsx',
+            'src/index.jsx',
+            'src/app.jsx',
+            // JavaScript
+            'src/main.js',
+            'src/index.js',
+            'src/app.js',
+            // Root level
+            'index.tsx',
+            'index.ts',
+            'index.jsx',
+            'index.js',
+            'main.tsx',
+            'main.ts',
+            'main.jsx',
+            'main.js',
+        ];
+        for (const candidate of candidates) {
+            const fullPath = path.join(this.cwd, candidate);
+            if (fs.existsSync(fullPath)) {
+                return [candidate];
+            }
+        }
+        // Fallback to default
+        return ['src/main.tsx'];
+    }
+    /**
+     * Select port based on strategy
+     */
+    selectPort() {
+        if (typeof this.options.portStrategy === 'number') {
+            return this.options.portStrategy;
+        }
+        if (this.options.portStrategy === 'fixed') {
+            return 5173;
+        }
+        // Auto strategy: Try 5173, then find next available
+        // For now, just return 5173 (actual port checking would be in dev server)
+        return 5173;
+    }
+    /**
+     * Detect CSS framework from package.json
+     */
+    detectCSSFramework() {
+        const pkgPath = path.join(this.cwd, 'package.json');
+        if (!fs.existsSync(pkgPath)) {
+            return { framework: 'none' };
+        }
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        const allDeps = {
+            ...pkg.dependencies,
+            ...pkg.devDependencies
+        };
+        // Detect CSS framework
+        if (allDeps['tailwindcss']) {
+            console.log('🔍 Auto-detected CSS framework: Tailwind CSS');
+            return { framework: 'tailwind', purge: true };
+        }
+        if (allDeps['bootstrap']) {
+            console.log('🔍 Auto-detected CSS framework: Bootstrap');
+            return { framework: 'bootstrap' };
+        }
+        if (allDeps['bulma']) {
+            console.log('🔍 Auto-detected CSS framework: Bulma');
+            return { framework: 'bulma' };
+        }
+        if (allDeps['@mui/material'] || allDeps['@material-ui/core']) {
+            console.log('🔍 Auto-detected CSS framework: Material UI');
+            return { framework: 'material' };
+        }
+        return { framework: 'none' };
+    }
+    /**
+     * Get preset info for diagnostics
+     */
+    getInfo() {
+        return {
+            framework: this.detectFramework(),
+            entry: this.detectEntryPoints(),
+            port: this.selectPort(),
+            css: this.detectCSSFramework()
+        };
+    }
+}
+/**
+ * Factory function for easy usage
+ */
+export function corePreset(options = {}) {
+    return (cwd) => {
+        const preset = new CorePreset(cwd, options);
+        return preset;
+    };
+}
+/**
+ * Default export
+ */
+export default corePreset;

package/dist/presets/frameworks.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Framework Presets
+ * Production-ready configurations for all supported frameworks
+ */
+import type { Framework } from '../core/framework-detector.js';
+export interface FrameworkPreset {
+    name: Framework;
+    compiler?: string;
+    extensions: string[];
+    jsx?: {
+        runtime?: 'automatic' | 'classic';
+        importSource?: string;
+        pragma?: string;
+        pragmaFrag?: string;
+    };
+    hmr?: {
+        enabled: boolean;
+        runtime?: string;
+    };
+    transform?: {
+        babel?: any;
+        esbuild?: any;
+        custom?: string;
+    };
+    build?: {
+        splitting?: boolean;
+        minify?: boolean;
+        sourcemap?: boolean;
+    };
+}
+export declare const frameworkPresets: Record<Framework, FrameworkPreset>;
+export declare function getFrameworkPreset(framework: Framework): FrameworkPreset;
+export declare function getFrameworkExtensions(framework: Framework): string[];
+export declare function isFrameworkFile(filePath: string, framework: Framework): boolean;

package/dist/presets/frameworks.js

@@ -0,0 +1,270 @@
+/**
+ * Framework Presets
+ * Production-ready configurations for all supported frameworks
+ */
+export const frameworkPresets = {
+    react: {
+        name: 'react',
+        extensions: ['.jsx', '.tsx', '.js', '.ts'],
+        jsx: {
+            runtime: 'automatic',
+            importSource: 'react'
+        },
+        hmr: {
+            enabled: true,
+            runtime: 'react-refresh'
+        },
+        transform: {
+            babel: {
+                presets: [
+                    ['@babel/preset-react', { runtime: 'automatic', development: true }],
+                    '@babel/preset-typescript'
+                ]
+            }
+        },
+        build: {
+            splitting: true,
+            minify: true,
+            sourcemap: true
+        }
+    },
+    vue: {
+        name: 'vue',
+        compiler: '@vue/compiler-sfc',
+        extensions: ['.vue', '.js', '.ts'],
+        hmr: {
+            enabled: true
+        },
+        transform: {
+            custom: 'vue-sfc'
+        },
+        build: {
+            splitting: true,
+            minify: true,
+            sourcemap: true
+        }
+    },
+    svelte: {
+        name: 'svelte',
+        compiler: 'svelte/compiler',
+        extensions: ['.svelte', '.js', '.ts'],
+        hmr: {
+            enabled: true
+        },
+        transform: {
+            custom: 'svelte'
+        },
+        build: {
+            splitting: true,
+            minify: true,
+            sourcemap: true
+        }
+    },
+    angular: {
+        name: 'angular',
+        compiler: '@angular/compiler-cli',
+        extensions: ['.ts', '.html', '.css', '.scss'],
+        hmr: {
+            enabled: true
+        },
+        transform: {
+            custom: 'angular'
+        },
+        build: {
+            splitting: true,
+            minify: true,
+            sourcemap: true
+        }
+    },
+    solid: {
+        name: 'solid',
+        compiler: 'babel-preset-solid',
+        extensions: ['.jsx', '.tsx', '.js', '.ts'],
+        jsx: {
+            runtime: 'automatic',
+            importSource: 'solid-js'
+        },
+        hmr: {
+            enabled: true
+        },
+        transform: {
+            babel: {
+                presets: ['solid', '@babel/preset-typescript']
+            }
+        },
+        build: {
+            splitting: true,
+            minify: true,
+            sourcemap: true
+        }
+    },
+    preact: {
+        name: 'preact',
+        extensions: ['.jsx', '.tsx', '.js', '.ts'],
+        jsx: {
+            runtime: 'automatic',
+            importSource: 'preact'
+        },
+        hmr: {
+            enabled: true,
+            runtime: '@prefresh/core'
+        },
+        transform: {
+            babel: {
+                presets: [
+                    ['@babel/preset-react', { runtime: 'automatic', importSource: 'preact' }],
+                    '@babel/preset-typescript'
+                ]
+            }
+        },
+        build: {
+            splitting: true,
+            minify: true,
+            sourcemap: true
+        }
+    },
+    qwik: {
+        name: 'qwik',
+        compiler: '@builder.io/qwik/optimizer',
+        extensions: ['.tsx', '.ts', '.jsx', '.js'],
+        jsx: {
+            runtime: 'automatic',
+            importSource: '@builder.io/qwik'
+        },
+        hmr: {
+            enabled: true
+        },
+        transform: {
+            custom: 'qwik'
+        },
+        build: {
+            splitting: true,
+            minify: true,
+            sourcemap: true
+        }
+    },
+    lit: {
+        name: 'lit',
+        extensions: ['.ts', '.js'],
+        hmr: {
+            enabled: true
+        },
+        transform: {
+            esbuild: {
+                target: 'es2020',
+                tsconfigRaw: {
+                    compilerOptions: {
+                        experimentalDecorators: true,
+                        useDefineForClassFields: false
+                    }
+                }
+            }
+        },
+        build: {
+            splitting: true,
+            minify: true,
+            sourcemap: true
+        }
+    },
+    astro: {
+        name: 'astro',
+        compiler: 'astro',
+        extensions: ['.astro', '.md', '.mdx'],
+        hmr: {
+            enabled: true
+        },
+        transform: {
+            custom: 'astro'
+        },
+        build: {
+            splitting: true,
+            minify: true,
+            sourcemap: true
+        }
+    },
+    next: {
+        name: 'next',
+        compiler: 'next',
+        extensions: ['.jsx', '.tsx', '.js', '.ts'],
+        jsx: {
+            runtime: 'automatic',
+            importSource: 'react'
+        },
+        hmr: {
+            enabled: true,
+            runtime: 'react-refresh'
+        },
+        transform: {
+            custom: 'next'
+        },
+        build: {
+            splitting: true,
+            minify: true,
+            sourcemap: true
+        }
+    },
+    nuxt: {
+        name: 'nuxt',
+        compiler: 'nuxt',
+        extensions: ['.vue', '.js', '.ts'],
+        hmr: {
+            enabled: true
+        },
+        transform: {
+            custom: 'nuxt'
+        },
+        build: {
+            splitting: true,
+            minify: true,
+            sourcemap: true
+        }
+    },
+    remix: {
+        name: 'remix',
+        compiler: '@remix-run/dev',
+        extensions: ['.jsx', '.tsx', '.js', '.ts'],
+        jsx: {
+            runtime: 'automatic',
+            importSource: 'react'
+        },
+        hmr: {
+            enabled: true,
+            runtime: 'react-refresh'
+        },
+        transform: {
+            custom: 'remix'
+        },
+        build: {
+            splitting: true,
+            minify: true,
+            sourcemap: true
+        }
+    },
+    vanilla: {
+        name: 'vanilla',
+        extensions: ['.js', '.ts', '.mjs'],
+        hmr: {
+            enabled: true
+        },
+        transform: {
+            esbuild: {
+                target: 'es2020'
+            }
+        },
+        build: {
+            splitting: true,
+            minify: true,
+            sourcemap: true
+        }
+    }
+};
+export function getFrameworkPreset(framework) {
+    return frameworkPresets[framework] || frameworkPresets.vanilla;
+}
+export function getFrameworkExtensions(framework) {
+    return getFrameworkPreset(framework).extensions;
+}
+export function isFrameworkFile(filePath, framework) {
+    const extensions = getFrameworkExtensions(framework);
+    return extensions.some(ext => filePath.endsWith(ext));
+}

package/dist/presets/index.d.ts

@@ -0,0 +1,8 @@
+import { BuildConfig } from '../config/index.js';
+export interface Preset {
+    name: string;
+    apply(config: Partial<BuildConfig>): Partial<BuildConfig>;
+}
+export { spaPreset } from './spa.js';
+export { ssrPreset } from './ssr.js';
+export { ssgPreset } from './ssg.js';

package/dist/presets/index.js

@@ -0,0 +1,3 @@
+export { spaPreset } from './spa.js';
+export { ssrPreset } from './ssr.js';
+export { ssgPreset } from './ssg.js';

package/dist/presets/infrastructure.d.ts

@@ -0,0 +1,2 @@
+import { NucliePlugin } from '../core/plugins/types.js';
+export declare function getInfrastructurePreset(rootDir: string, outDir?: string, config?: any): NucliePlugin[];

package/dist/presets/infrastructure.js

@@ -0,0 +1,33 @@
+import { createJsTransformPlugin } from '../plugins/js-transform.js';
+import { createPostCssPlugin } from '../plugins/css/postcss.js';
+import { createLinkerPlugin } from '../plugins/core/linker.js';
+// We'll assume these are standard internal plugins or adapters for common ecosystem tools
+// For this baseline, we'll collect the core logic we've built.
+import { createAssetPlugin } from '../plugins/assets.js';
+import { createJsonPlugin } from '../plugins/json.js';
+import { createHtmlPlugin } from '../plugins/html.js';
+import { createFederationPlugin } from '../plugins/federation_next.js';
+import { createStaticPlugin } from '../plugins/static.js';
+export function getInfrastructurePreset(rootDir, outDir, config) {
+    const plugins = [];
+    const effectiveOutDir = outDir || 'dist';
+    // 0. JSON (Load early)
+    plugins.push(createJsonPlugin());
+    // 1. Assets (Run early to handle imports)
+    plugins.push(createAssetPlugin(outDir));
+    // 2. JS/TS Transformation & Env handling (Honest Implementation via UniversalTransformer)
+    plugins.push(createJsTransformPlugin(rootDir));
+    // 3. CSS Handling (PostCSS / Tailwind Support)
+    plugins.push(createPostCssPlugin(rootDir));
+    // 4. Linker (Final specifier rewriting)
+    plugins.push(createLinkerPlugin());
+    // 5. HTML Entry Generation
+    plugins.push(createHtmlPlugin(rootDir, effectiveOutDir));
+    // 6. Federation (Micro-frontends)
+    if (config?.federation) {
+        plugins.push(createFederationPlugin(config.federation));
+    }
+    // 7. Static Assets (public folder)
+    plugins.push(createStaticPlugin(rootDir, effectiveOutDir));
+    return plugins;
+}

package/dist/presets/spa.d.ts

@@ -0,0 +1,2 @@
+import { Preset } from './index.js';
+export declare const spaPreset: Preset;

package/dist/presets/spa.js

@@ -0,0 +1,15 @@
+export const spaPreset = {
+    name: 'spa',
+    apply(config) {
+        return {
+            ...config,
+            platform: 'browser',
+            // In a real implementation, we would add specific SPA plugins here
+            // e.g., history API fallback, specific chunking strategies
+            esbuildPlugins: [
+                ...(config.esbuildPlugins || []),
+                // Placeholder for SPA specific plugins
+            ]
+        };
+    }
+};

package/dist/presets/ssg.d.ts

@@ -0,0 +1,2 @@
+import { Preset } from './index.js';
+export declare const ssgPreset: Preset;

package/dist/presets/ssg.js

@@ -0,0 +1,9 @@
+export const ssgPreset = {
+    name: 'ssg',
+    apply(config) {
+        return {
+            ...config,
+            // SSG might run a post-build script to render pages
+        };
+    }
+};

package/dist/presets/ssr.d.ts

@@ -0,0 +1,2 @@
+import { Preset } from './index.js';
+export declare const ssrPreset: Preset;

package/dist/presets/ssr.js

@@ -0,0 +1,13 @@
+export const ssrPreset = {
+    name: 'ssr',
+    apply(config) {
+        // SSR typically requires two builds: client and server.
+        // This preset might configure the server build or adjust the client build.
+        // For this prototype, we'll mark the platform as node for server builds or hybrid.
+        return {
+            ...config,
+            platform: 'node', // Or 'neutral' depending on the target
+            // Add SSR specific config
+        };
+    }
+};