nuclie 1.0.7 → 1.0.9

package/README.md

@@ -432,14 +432,21 @@ nuclie bootstrap --name my-app --template svelte-ts
 nuclie bootstrap --name my-app --template solid-ts
 nuclie bootstrap --name my-app --template preact-ts
 nuclie bootstrap --name my-app --template lit-ts
+nuclie bootstrap --name my-app --template mithril-ts
+nuclie bootstrap --name my-app --template alpine-ts
 nuclie bootstrap --name my-app --template vanilla-ts
 
 # JavaScript
-nuclie bootstrap --name my-app --template react-js
-nuclie bootstrap --name my-app --template vue-js
-nuclie bootstrap --name my-app --template svelte-js
-nuclie bootstrap --name my-app --template alpine-js
-nuclie bootstrap --name my-app --template vanilla-js
+nuclie bootstrap --name my-app --template react
+nuclie bootstrap --name my-app --template vue
+nuclie bootstrap --name my-app --template svelte
+nuclie bootstrap --name my-app --template solid
+nuclie bootstrap --name my-app --template preact
+nuclie bootstrap --name my-app --template lit
+nuclie bootstrap --name my-app --template qwik
+nuclie bootstrap --name my-app --template mithril
+nuclie bootstrap --name my-app --template alpine
+nuclie bootstrap --name my-app --template vanilla
 ```
 
 ---
@@ -454,9 +461,9 @@ nuclie bootstrap --name my-app --template vanilla-js
 | SolidJS    | ✅ Stable | ✅ Signal-aware | ✅ | |
 | Preact     | ✅ Stable | ✅ Fast Refresh | ✅ | React compat |
 | Lit        | ✅ Verified | ✅ Web Component | ✅ | |
-| Alpine.js  | ✅ Verified | ✅ Core Reload | ➖ | HTML-first |
+| Alpine.js  | ✅ Verified | ✅ Core Reload | ✅ | HTML-first |
 | Qwik       | 🔶 Experimental | ✅ | ✅ | |
-| Mithril.js | 🔵 Legacy | ✅ | ➖ | |
+| Mithril.js | ✅ Stable | ✅ | ✅ | |
 | Vanilla JS | ✅ Stable | ✅ | ✅ | |
 
 ---

package/dist/config/index.d.ts

@@ -4,7 +4,7 @@ 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[]>>>;
+    entry: z.ZodOptional<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";

package/dist/config/index.js

@@ -13,7 +13,7 @@ export const BuildConfigSchema = z.object({
     framework: z.string().optional(),
     entry: z.union([z.string(), z.array(z.string())])
         .transform((val) => (typeof val === 'string' ? [val] : val))
-        .default(['src/main.tsx']),
+        .optional(),
     mode: z.enum(['development', 'production', 'test']).default('development'),
     outDir: z.string().default('build_output'),
     port: z.number().default(5173),
@@ -135,27 +135,9 @@ export async function loadConfig(cwd) {
         else {
             // Return default config if file not found, with auto-detection
             log.info('No config file found, using defaults...');
-            // Auto-detect entry point
-            const entryCandidates = [
-                'src/main.tsx',
-                'src/main.ts',
-                'src/main.jsx',
-                'src/main.js',
-                'src/index.tsx',
-                'src/index.ts',
-                'src/index.jsx',
-                'src/index.js'
-            ];
-            let detectedEntry = ['src/main.tsx']; // Default fallback
-            for (const candidate of entryCandidates) {
-                if (await fs.access(path.join(cwd, candidate)).then(() => true).catch(() => false)) {
-                    detectedEntry = [candidate];
-                    break;
-                }
-            }
             return {
                 root: cwd,
-                entry: detectedEntry,
+                entry: [], // will be auto-detected below
                 mode: 'development',
                 outDir: 'build_output',
                 port: 5173,
@@ -176,6 +158,29 @@ export async function loadConfig(cwd) {
         const config = result.data;
         // Ensure root is set
         const root = config.root || cwd;
+        // Auto-detect entry point if missing
+        if (!config.entry || config.entry.length === 0) {
+            const entryCandidates = [
+                'src/main.tsx',
+                'src/main.ts',
+                'src/main.jsx',
+                'src/main.js',
+                'src/index.tsx',
+                'src/index.ts',
+                'src/index.jsx',
+                'src/index.js',
+                'src/root.tsx',
+                'src/root.ts',
+            ];
+            let detectedEntry = ['src/main.tsx']; // Default fallback
+            for (const candidate of entryCandidates) {
+                if (await fs.access(path.join(root, candidate)).then(() => true).catch(() => false)) {
+                    detectedEntry = [candidate];
+                    break;
+                }
+            }
+            config.entry = detectedEntry;
+        }
         let finalConfig = { ...config };
         if (config.preset === 'spa')
             finalConfig = { ...finalConfig, ...spaPreset.apply(finalConfig) };

package/dist/core/framework-detector.d.ts

@@ -2,7 +2,7 @@
  * Framework Detector
  * Automatically detects which framework(s) are being used in the project
  */
-export type Framework = 'react' | 'vue' | 'svelte' | 'angular' | 'solid' | 'preact' | 'qwik' | 'lit' | 'astro' | 'next' | 'nuxt' | 'remix' | 'vanilla';
+export type Framework = 'react' | 'vue' | 'svelte' | 'angular' | 'solid' | 'preact' | 'qwik' | 'lit' | 'astro' | 'next' | 'nuxt' | 'remix' | 'alpine' | 'mithril' | 'vanilla';
 export interface FrameworkInfo {
     name: Framework;
     version?: string;

package/dist/core/framework-detector.js

@@ -122,6 +122,22 @@ export class FrameworkDetector {
                 confidence: 1.0
             });
         }
+        if (deps['alpinejs']) {
+            frameworks.push({
+                name: 'alpine',
+                version: deps['alpinejs'],
+                detected: true,
+                confidence: 1.0
+            });
+        }
+        if (deps['mithril']) {
+            frameworks.push({
+                name: 'mithril',
+                version: deps['mithril'],
+                detected: true,
+                confidence: 1.0
+            });
+        }
         // If no framework detected, it's vanilla JS/TS
         if (frameworks.length === 0) {
             frameworks.push({

package/dist/core/pipeline/framework-pipeline.js

@@ -20,16 +20,26 @@ export class FrameworkPipeline {
         // Honor explicit configuration (Phase 2/3 Alignment)
         let framework = config.framework;
         if (!framework && config.adapter) {
-            if (config.adapter.includes('react'))
+            if (config.adapter === 'react' || config.adapter === 'react-typescript' || config.adapter === 'react-adapter')
                 framework = 'react';
-            else if (config.adapter.includes('vue'))
+            else if (config.adapter === 'vue')
                 framework = 'vue';
-            else if (config.adapter.includes('svelte'))
+            else if (config.adapter === 'svelte')
                 framework = 'svelte';
-            else if (config.adapter.includes('angular'))
+            else if (config.adapter === 'angular')
                 framework = 'angular';
-            else if (config.adapter.includes('solid'))
+            else if (config.adapter === 'solid')
                 framework = 'solid';
+            else if (config.adapter === 'preact')
+                framework = 'preact';
+            else if (config.adapter === 'qwik')
+                framework = 'qwik';
+            else if (config.adapter === 'lit')
+                framework = 'lit';
+            else if (config.adapter === 'alpine')
+                framework = 'alpine';
+            else if (config.adapter === 'mithril' || config.adapter === 'mithril-ts')
+                framework = 'mithril';
         }
         if (!framework) {
             framework = await detectFramework(rootDir);

package/dist/core/universal-transformer.js

@@ -8,6 +8,7 @@ import fs from 'fs/promises';
 import { getFrameworkPreset } from '../presets/frameworks.js';
 import { log } from '../utils/logger.js';
 import { createRequire } from 'module';
+import { fileURLToPath, pathToFileURL } from 'url';
 import * as esbuild from 'esbuild';
 import { canonicalHash } from '../core/engine/hash.js';
 const _require = createRequire(import.meta.url);
@@ -219,8 +220,11 @@ if (import.meta.hot) {
         try {
             let compiler;
             try {
-                const compilerPath = _require.resolve('@vue/compiler-sfc', { paths: [this.root, process.cwd()] });
-                compiler = await import(compilerPath);
+                // Try: user project first, then nuclie's own node_modules (nuclie ships @vue/compiler-sfc as a dep)
+                const searchPaths = [this.root, process.cwd(), fileURLToPath(new URL('../..', import.meta.url))];
+                const compilerPath = _require.resolve('@vue/compiler-sfc', { paths: searchPaths });
+                const compilerUrl = pathToFileURL(compilerPath).href;
+                compiler = await import(compilerUrl);
             }
             catch {
                 log.warn('No Vue 3 compiler found, using fallback with HMR');
@@ -317,7 +321,7 @@ if (import.meta.hot) {
                 ` : ''}
 
                 ${descriptor.styles.some((s) => s.scoped) ? `_sfc_main.__scopeId = "${scopeId}";` : ''}
-                _sfc_main.__file = "${filePath}";
+                _sfc_main.__file = "${filePath.replace(/\\/g, '/')}";
                 
                 export default _sfc_main;
             `;
@@ -360,7 +364,8 @@ if (import.meta.hot) {
             let svelte;
             try {
                 const compilerPath = _require.resolve('svelte/compiler', { paths: [this.root, process.cwd()] });
-                const mod = await import(compilerPath);
+                const compilerUrl = pathToFileURL(compilerPath).href;
+                const mod = await import(compilerUrl);
                 svelte = typeof mod.compile === 'function' ? mod : (mod.default || mod);
             }
             catch {
@@ -533,7 +538,8 @@ if (import.meta.hot) {
             if (dispose) dispose();
             const NewComponent = newModule.default || newModule[component];
             if (NewComponent && container) {
-                import('solid-js/web').then(({ render }) => {
+                // Use server-relative path so the dev server resolves via exports field
+                import('/node_modules/solid-js/web').then(({ render }) => {
                     render(() => NewComponent({}), container);
                 });
             }
@@ -592,14 +598,19 @@ if (import.meta.hot) {
      * Qwik Transformer - Works with all Qwik versions
      */
     async transformQwik(code, filePath, isDev) {
+        const ext = path.extname(filePath);
+        if (ext !== '.tsx' && ext !== '.ts' && ext !== '.jsx' && ext !== '.js') {
+            return this.transformVanilla(code, filePath, isDev);
+        }
         try {
             let qwik;
             try {
                 const compilerPath = _require.resolve('@builder.io/qwik/optimizer', { paths: [this.root, process.cwd()] });
-                const mod = await import(compilerPath);
+                const mod = await import(pathToFileURL(compilerPath).href);
                 qwik = typeof mod.createOptimizer === 'function' ? mod : (mod.default || mod);
             }
-            catch {
+            catch (e) {
+                console.error("[Qwik Optimizer] Original import failed:", e);
                 const fallbackQwikOptimizer = '@builder.io/qwik/optimizer';
                 const mod = await import(fallbackQwikOptimizer);
                 qwik = typeof mod.createOptimizer === 'function' ? mod : (mod.default || mod);
@@ -608,9 +619,11 @@ if (import.meta.hot) {
             const result = await optimizer.transformModules({
                 input: [{ code, path: filePath }],
                 srcDir: path.join(this.root, 'src'),
-                entryStrategy: { type: 'single' },
+                rootDir: this.root,
+                entryStrategy: { type: 'inline' },
                 minify: isDev ? 'none' : 'simplify',
                 sourceMaps: isDev,
+                mode: isDev ? 'dev' : 'lib',
                 transpile: true,
             });
             const output = result.modules[0];
@@ -618,15 +631,34 @@ if (import.meta.hot) {
             const final = await transform(output.code, {
                 loader: 'tsx',
                 format: 'esm',
-                target: 'es2022',
+                target: 'es2020',
                 jsx: 'automatic',
                 jsxImportSource: '@builder.io/qwik'
             });
-            return { code: final.code, map: final.map ? JSON.stringify(final.map) : undefined };
+            const finalCode = final.code;
+            return { code: finalCode, map: final.map ? JSON.stringify(final.map) : undefined };
         }
         catch (error) {
-            log.error(`Qwik transform failed for ${filePath}: ${error.stack || error.message}`);
-            return this.transformVanilla(code, filePath, isDev);
+            // Fallback: use esbuild directly with Qwik JSX classic mode
+            log.warn(`Qwik optimizer failed, using esbuild fallback: ${error.message}`);
+            try {
+                const final = await esbuild.transform(code, {
+                    loader: (path.extname(filePath) === '.tsx' || path.extname(filePath) === '.jsx') ? 'tsx' : 'ts',
+                    format: 'esm',
+                    target: 'es2020',
+                    jsx: 'transform',
+                    jsxFactory: 'h',
+                    jsxFragment: 'Fragment',
+                    jsxImportSource: undefined,
+                });
+                // Inject h/Fragment imports from qwik
+                const imports = `import { h, Fragment } from '@builder.io/qwik';\n`;
+                return { code: imports + final.code };
+            }
+            catch (fallbackErr) {
+                log.error(`Qwik fallback also failed for ${filePath}: ${fallbackErr.message}`);
+                return this.transformVanilla(code, filePath, isDev);
+            }
         }
     }
     /**

package/dist/create-nuclie/cli.js

@@ -5,8 +5,21 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { TEMPLATES } from './templates.js';
+import { fileURLToPath } from 'url';
+import { TEMPLATES } from '../utils/templates.js';
 import { red, green, blue, bold } from 'kleur/colors';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Read real nuclie version from its own package.json
+function getNuclieVersion() {
+    try {
+        const pkgPath = path.resolve(__dirname, '../../package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        return `^${pkg.version}`;
+    }
+    catch {
+        return 'latest';
+    }
+}
 async function main() {
     const args = process.argv.slice(2);
     let projectName = args[0];
@@ -43,29 +56,18 @@ async function main() {
     console.log(blue(`\n🚀 Scaffolding ${bold(template.name)} project in ${bold(projectName)}...`));
     // 1. Create Dir
     fs.mkdirSync(targetDir, { recursive: true });
-    // 2. Create Files
+    // 2. Create Files (replace version placeholder with real version)
+    const nuclieVersion = getNuclieVersion();
+    const versionLabel = nuclieVersion.replace('^', '');
     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);
+        const content = file.content.replace(/\{\{NUCLIE_VERSION\}\}/g, versionLabel);
+        fs.writeFileSync(filePath, content);
     }
     // 3. Create package.json
-    let nuclieVersion = 'latest';
-    try {
-        const pkgjsonPath = path.resolve(process.cwd(), 'node_modules/nuclie/package.json');
-        if (fs.existsSync(pkgjsonPath)) {
-            nuclieVersion = '^' + JSON.parse(fs.readFileSync(pkgjsonPath, 'utf8')).version;
-        }
-        else {
-            const localPkgPath = new URL('../../package.json', import.meta.url);
-            if (fs.existsSync(localPkgPath)) {
-                nuclieVersion = '^' + JSON.parse(fs.readFileSync(localPkgPath, 'utf8')).version;
-            }
-        }
-    }
-    catch (e) { }
     const pkg = {
         name: projectName,
         version: '0.0.0',