nuclie 1.0.0

package/dist/meta-frameworks/ssr/server.js

@@ -0,0 +1,312 @@
+/**
+ * SSR Server Runtime
+ * Universal server-side rendering for Next.js, Nuxt, and Remix
+ */
+import express from 'express';
+import path from 'path';
+import { NextJsRouter } from '../nextjs/router.js';
+import { NuxtRouter } from '../nuxt/router.js';
+import { RemixRouter } from '../remix/router.js';
+import { log } from '../../utils/logger.js';
+import { ReactSSRRenderer } from './react-renderer.js';
+import { VueSSRRenderer } from './vue-renderer.js';
+import * as React from 'react';
+// Polyfill React for SSR context where transforms might expect global React
+global.React = React;
+export class SSRServer {
+    constructor(config) {
+        this.config = config;
+        this.app = express();
+        // Initialize framework-specific router
+        this.router = this.createRouter();
+    }
+    /**
+     * Create framework-specific router
+     */
+    createRouter() {
+        const routerConfig = {
+            root: this.config.root,
+            framework: this.config.framework
+        };
+        switch (this.config.framework) {
+            case 'nextjs':
+                return new NextJsRouter(routerConfig);
+            case 'nuxt':
+                return new NuxtRouter(routerConfig);
+            case 'remix':
+                return new RemixRouter(routerConfig);
+            default:
+                throw new Error(`Unsupported framework: ${this.config.framework}`);
+        }
+    }
+    /**
+     * Start the SSR server
+     */
+    async start() {
+        console.log(`DEBUG: Running SSR Server from ${import.meta.url}`);
+        console.log('DEBUG: EXECUTION-ID-999');
+        log.info('🚀 Starting SSR Server...');
+        // Scan routes
+        const manifest = await this.router.scanRoutes();
+        log.info(`📋 Found ${manifest.routes.length} routes`);
+        // Serve static assets
+        this.app.use('/assets', express.static(path.join(this.config.root, this.config.outDir)));
+        this.app.use('/public', express.static(path.join(this.config.root, 'public')));
+        // Handle API routes
+        for (const route of manifest.apiRoutes) {
+            let regexPath = route.path
+                .replace(/:(\w+)/g, '[^/]+')
+                .replace(/\*(\w+)/g, '.*');
+            const routeRegex = new RegExp(`^${regexPath}$`);
+            this.app.all(routeRegex, async (req, res) => {
+                await this.handleAPIRoute(route, req, res);
+            });
+        }
+        // Handle page routes
+        for (const route of manifest.pageRoutes) {
+            // Create a simple regex for Express that matches this route
+            // NextJsRouter.match will handle the actual parameter extraction
+            let regexPath = route.path
+                .replace(/:(\w+)/g, '[^/]+') // Match dynamic segments
+                .replace(/\*(\w+)/g, '.*'); // Match catch-all segments
+            const routeRegex = new RegExp(`^${regexPath}$`);
+            this.app.get(routeRegex, async (req, res) => {
+                await this.handlePageRoute(route, req, res);
+            });
+        }
+        // 404 handler
+        this.app.use((req, res) => {
+            res.status(404).send(this.render404());
+        });
+        // Start listening
+        this.app.listen(this.config.port, () => {
+            log.info(`✅ SSR Server running on http://localhost:${this.config.port}`);
+            log.info(`📦 Framework: ${this.config.framework}`);
+            log.info(`📁 Root: ${this.config.root}`);
+        });
+    }
+    /**
+     * Handle API route request
+     */
+    async handleAPIRoute(route, req, res) {
+        try {
+            log.info(`🔌 API: ${req.method} ${req.path}`);
+            // Import the API handler
+            const handler = await this.importRoute(route.filePath);
+            if (typeof handler.default === 'function') {
+                await handler.default(req, res);
+            }
+            else if (typeof handler === 'function') {
+                await handler(req, res);
+            }
+            else {
+                res.status(500).json({ error: 'Invalid API handler' });
+            }
+        }
+        catch (error) {
+            log.error(`❌ API Error: ${error.message}`);
+            res.status(500).json({ error: error.message });
+        }
+    }
+    /**
+     * Handle page route request
+     */
+    async handlePageRoute(route, req, res) {
+        try {
+            log.info(`📄 Page: ${req.method} ${req.path}`);
+            // Match route and extract params
+            const match = this.router.match(req.path);
+            if (!match) {
+                res.status(404).send(this.render404());
+                return;
+            }
+            // Create render context
+            const context = {
+                route: match.route,
+                req,
+                res,
+                params: match.params,
+                query: match.query,
+            };
+            // Fetch data for this route
+            context.data = await this.fetchData(context);
+            // Render the page
+            const html = await this.renderPage(context);
+            // Send response
+            res.status(200).send(html);
+        }
+        catch (error) {
+            log.error(`❌ Render Error: ${error.message}`);
+            res.status(500).send(this.render500(error));
+        }
+    }
+    /**
+     * Fetch data for a route
+     */
+    async fetchData(context) {
+        try {
+            const module = await this.importRoute(context.route.filePath);
+            // Next.js data fetching
+            if (this.config.framework === 'nextjs') {
+                if (module.getServerSideProps) {
+                    const result = await module.getServerSideProps({
+                        req: context.req,
+                        res: context.res,
+                        params: context.params,
+                        query: context.query,
+                    });
+                    return result.props;
+                }
+                if (module.getStaticProps) {
+                    const result = await module.getStaticProps({
+                        params: context.params,
+                    });
+                    return result.props;
+                }
+            }
+            // Remix data fetching
+            if (this.config.framework === 'remix') {
+                if (context.req.method === 'GET' && module.loader) {
+                    return await module.loader({
+                        request: context.req,
+                        params: context.params,
+                    });
+                }
+                if (context.req.method === 'POST' && module.action) {
+                    return await module.action({
+                        request: context.req,
+                        params: context.params,
+                    });
+                }
+            }
+            // Nuxt data fetching
+            if (this.config.framework === 'nuxt') {
+                // Nuxt uses composables, would need special handling
+                // For now, return empty data
+                return {};
+            }
+            return {};
+        }
+        catch (error) {
+            log.warn(`⚠️ Data fetch failed: ${error.message}`);
+            return {};
+        }
+    }
+    /**
+     * Render page to HTML
+     */
+    async renderPage(context) {
+        // Debug: confirm execution
+        console.log('DEBUG: renderPage executed cleanly');
+        try {
+            // Import the component
+            const Component = await this.importRoute(context.route.filePath);
+            // Render based on framework
+            let appHtml = '';
+            if (this.config.framework === 'nextjs') {
+                appHtml = await this.renderReact(Component, context);
+            }
+            else if (this.config.framework === 'nuxt') {
+                appHtml = await this.renderVue(Component, context);
+            }
+            else if (this.config.framework === 'remix') {
+                appHtml = await this.renderReact(Component, context);
+            }
+            // Wrap in HTML template
+            return this.wrapInDocument(appHtml, context);
+        }
+        catch (error) {
+            log.error(`❌ Render failed: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Render React component to HTML
+     */
+    async renderReact(Component, context) {
+        const renderer = new ReactSSRRenderer();
+        return await renderer.render(Component, context);
+    }
+    /**
+     * Render Vue component to HTML
+     */
+    async renderVue(Component, context) {
+        const renderer = new VueSSRRenderer();
+        return await renderer.render(Component, context);
+    }
+    /**
+     * Wrap rendered content in HTML document
+     */
+    wrapInDocument(appHtml, context) {
+        const template = this.config.template || this.getDefaultTemplate();
+        console.log(`DEBUG: Wrapping in document using template ID: PROD-READY-V1`);
+        return template
+            .replace('<!--app-html-->', appHtml)
+            .replace('<!--app-data-->', `<script>window.__INITIAL_DATA__=${JSON.stringify(context.data)}</script>`)
+            .replace('<!--app-title-->', `SSR App - ${context.route.name}`);
+    }
+    /**
+     * Get default HTML template
+     */
+    getDefaultTemplate() {
+        return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta name="nuclie-version" content="PROD-READY-V1">
+  <title><!--app-title--></title>
+</head>
+<body>
+  <div id="nuclie-root"><!--app-html--></div>
+  <!--app-data-->
+  <script type="module" src="/assets/entry0.js"></script>
+</body>
+</html>`;
+    }
+    /**
+     * Render 404 page
+     */
+    render404() {
+        return `<!DOCTYPE html>
+<html>
+<head><title>404 - Not Found</title></head>
+<body>
+  <h1>404 - Page Not Found</h1>
+  <p>The requested page does not exist.</p>
+</body>
+</html>`;
+    }
+    /**
+     * Render 500 error page
+     */
+    render500(error) {
+        return `<!DOCTYPE html>
+<html>
+<head><title>500 - Server Error</title></head>
+<body>
+  <h1>500 - Server Error</h1>
+  <p>${this.config.production ? 'An error occurred.' : error.message}</p>
+  ${this.config.production ? '' : `<pre>${error.stack}</pre>`}
+</body>
+</html>`;
+    }
+    /**
+     * Import a route module
+     */
+    async importRoute(filePath) {
+        try {
+            // In production, import from build output
+            if (this.config.production) {
+                const buildPath = path.join(this.config.root, this.config.outDir, path.basename(filePath, path.extname(filePath)) + '.js');
+                return await import(buildPath);
+            }
+            // In development, import source file
+            return await import(filePath);
+        }
+        catch (error) {
+            log.error(`❌ Failed to import ${filePath}: ${error.message}`);
+            throw error;
+        }
+    }
+}

package/dist/meta-frameworks/ssr/vue-renderer.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Vue SSR Renderer
+ * Server-side rendering for Vue 3 / Nuxt
+ */
+import { RenderContext } from './server.js';
+export declare class VueSSRRenderer {
+    /**
+     * Render Vue component to HTML string
+     */
+    render(Component: any, context: RenderContext): Promise<string>;
+}

package/dist/meta-frameworks/ssr/vue-renderer.js

@@ -0,0 +1,35 @@
+/**
+ * Vue SSR Renderer
+ * Server-side rendering for Vue 3 / Nuxt
+ */
+import { renderToString } from '@vue/server-renderer';
+import { createSSRApp, h } from 'vue';
+export class VueSSRRenderer {
+    /**
+     * Render Vue component to HTML string
+     */
+    async render(Component, context) {
+        try {
+            // Create the app instance
+            // Component.default is used if it's an ES module
+            const app = createSSRApp({
+                render: () => h(Component.default || Component, {
+                    ...context.data,
+                    params: context.params,
+                    query: context.query
+                })
+            });
+            // Set up error handling
+            app.config.errorHandler = (err) => {
+                console.error('Vue SSR App Error:', err);
+            };
+            // Render to string
+            const html = await renderToString(app);
+            return html;
+        }
+        catch (error) {
+            console.error('Vue SSR Render Error:', error);
+            throw new Error(`Failed to render Vue component: ${error.message}`);
+        }
+    }
+}

package/dist/meta-frameworks/types.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Core Route Types
+ * Shared types for all meta-framework routers
+ */
+export interface Route {
+    /** File system path to the route file */
+    filePath: string;
+    /** URL path pattern (e.g., /blog/:slug) */
+    path: string;
+    /** Route name/identifier */
+    name: string;
+    /** Whether this route has dynamic segments */
+    isDynamic: boolean;
+    /** Dynamic parameter names */
+    params: string[];
+    /** Route type */
+    type: 'page' | 'layout' | 'api' | 'middleware' | 'error';
+    /** Parent route (for nested routes) */
+    parent?: Route;
+    /** Child routes */
+    children: Route[];
+    /** Framework-specific metadata */
+    meta: Record<string, any>;
+}
+export interface RouteManifest {
+    /** All routes in the application */
+    routes: Route[];
+    /** Route lookup by path */
+    byPath: Map<string, Route>;
+    /** Route lookup by file path */
+    byFile: Map<string, Route>;
+    /** API routes */
+    apiRoutes: Route[];
+    /** Page routes */
+    pageRoutes: Route[];
+}
+export interface RouterConfig {
+    /** Project root directory */
+    root: string;
+    /** Framework type */
+    framework: 'nextjs' | 'nuxt' | 'remix';
+    /** Source directory (e.g., 'app', 'pages', 'src') */
+    srcDir?: string;
+    /** Custom route patterns */
+    patterns?: RoutePattern[];
+}
+export interface RoutePattern {
+    /** File pattern to match */
+    pattern: RegExp;
+    /** How to transform file path to URL path */
+    transform: (filePath: string) => string;
+    /** Route type */
+    type: Route['type'];
+}
+export interface RouteMatch {
+    /** Matched route */
+    route: Route;
+    /** Extracted parameters */
+    params: Record<string, string>;
+    /** Query parameters */
+    query: Record<string, string>;
+}
+/**
+ * Base Router Interface
+ * All framework routers must implement this
+ */
+export interface IRouter {
+    /** Scan and build route manifest */
+    scanRoutes(): Promise<RouteManifest>;
+    /** Match a URL to a route */
+    match(url: string): RouteMatch | null;
+    /** Generate URL from route name and params */
+    generate(name: string, params?: Record<string, any>): string;
+    /** Validate route configuration */
+    validate(): Promise<void>;
+}

package/dist/meta-frameworks/types.js

@@ -0,0 +1,5 @@
+/**
+ * Core Route Types
+ * Shared types for all meta-framework routers
+ */
+export {};

package/dist/migrate/analyzer.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Migration Analyzer (Day 43)
+ *
+ * Analyzes existing projects (Vite/Webpack/Rollup/Angular CLI) and generates
+ * a migration plan for converting to Nuclie.
+ */
+export type ToolchainType = 'vite' | 'webpack' | 'rollup' | 'angular-cli' | 'unknown';
+export type RiskLevel = 'LOW' | 'MEDIUM' | 'HIGH';
+export type Framework = 'react' | 'vue' | 'svelte' | 'angular' | 'solid' | 'preact' | 'lit' | 'qwik' | 'unknown';
+export interface MigrationPlan {
+    toolchainType: ToolchainType;
+    frameworks: Framework[];
+    plugins: string[];
+    loaders: string[];
+    riskLevel: RiskLevel;
+    autoMigrate: string[];
+    manualSteps: string[];
+    cssSetup: {
+        hasTailwind: boolean;
+        hasSass: boolean;
+        hasCSSModules: boolean;
+        hasCSSInJS: boolean;
+        cssInJSLibrary?: string;
+    };
+    projectStructure: {
+        isMonorepo: boolean;
+        hasWorkspaces: boolean;
+        entryPoints: string[];
+    };
+}
+export declare class MigrationAnalyzer {
+    private projectRoot;
+    constructor(projectRoot: string);
+    analyze(): Promise<MigrationPlan>;
+    private readPackageJson;
+    private detectToolchain;
+    private detectFrameworks;
+    private analyzeCSSSetup;
+    private checkForCSSModules;
+    private analyzeProjectStructure;
+    private detectPluginsAndLoaders;
+    private calculateRiskLevel;
+    private determineAutoMigrate;
+    private determineManualSteps;
+}
+export declare function analyzeMigration(projectPath: string): Promise<MigrationPlan>;