nuclie 1.0.0

package/dist/meta-frameworks/nextjs/router.js

@@ -0,0 +1,176 @@
+/**
+ * Next.js Router
+ * Supports both Pages Router and App Router
+ */
+import path from 'path';
+import { BaseRouter } from '../base-router.js';
+import { log } from '../../utils/logger.js';
+export class NextJsRouter extends BaseRouter {
+    constructor(config) {
+        super({ ...config, framework: 'nextjs' });
+    }
+    async scanRoutes() {
+        await this.validate();
+        const routes = [];
+        // Scan Pages Router (pages/ directory)
+        const pagesRoutes = await this.scanPagesRouter();
+        routes.push(...pagesRoutes);
+        // Scan App Router (app/ directory) - Next.js 13+
+        const appRoutes = await this.scanAppRouter();
+        routes.push(...appRoutes);
+        this.manifest = this.createManifest(routes);
+        this.logRoutes(this.manifest);
+        return this.manifest;
+    }
+    /**
+     * Scan Pages Router (pages/ directory)
+     */
+    async scanPagesRouter() {
+        const pagesDir = path.join(this.config.root, 'pages');
+        const files = await this.scanDirectory(pagesDir);
+        const routes = [];
+        for (const filePath of files) {
+            const relativePath = path.relative(pagesDir, filePath);
+            // Skip _app, _document, _error (special files)
+            if (relativePath.startsWith('_')) {
+                continue;
+            }
+            // Check if it's an API route
+            const isApiRoute = relativePath.startsWith('api/') || relativePath.startsWith('api\\');
+            const route = this.createPagesRoute(filePath, pagesDir, isApiRoute);
+            routes.push(route);
+        }
+        return routes;
+    }
+    /**
+     * Create route from Pages Router file
+     */
+    createPagesRoute(filePath, baseDir, isApi) {
+        let routePath = this.fileToRoutePath(filePath, baseDir);
+        // Handle dynamic routes
+        // [id].tsx -> :id
+        // [...slug].tsx -> *slug (catch-all)
+        // [[...slug]].tsx -> *slug? (optional catch-all)
+        routePath = routePath.replace(/\[\.\.\.([^\]]+)\]/g, '*$1'); // catch-all
+        routePath = routePath.replace(/\[\[\.\.\.([^\]]+)\]\]/g, '*$1?'); // optional catch-all
+        routePath = routePath.replace(/\[([^\]]+)\]/g, ':$1'); // dynamic
+        const params = this.extractParams(routePath);
+        const isDynamic = this.isDynamicPath(routePath);
+        // Generate route name
+        const name = this.generateRouteName(filePath, baseDir);
+        return {
+            filePath,
+            path: routePath,
+            name,
+            isDynamic,
+            params,
+            type: isApi ? 'api' : 'page',
+            children: [],
+            meta: {
+                router: 'pages',
+                framework: 'nextjs'
+            }
+        };
+    }
+    /**
+     * Scan App Router (app/ directory)
+     */
+    async scanAppRouter() {
+        const appDir = path.join(this.config.root, 'app');
+        const files = await this.scanDirectory(appDir);
+        const routes = [];
+        for (const filePath of files) {
+            const fileName = path.basename(filePath, path.extname(filePath));
+            // Only process route files
+            if (!['page', 'layout', 'loading', 'error', 'route'].includes(fileName)) {
+                continue;
+            }
+            const route = this.createAppRoute(filePath, appDir);
+            if (route) {
+                routes.push(route);
+            }
+        }
+        return routes;
+    }
+    /**
+     * Create route from App Router file
+     */
+    createAppRoute(filePath, baseDir) {
+        const fileName = path.basename(filePath, path.extname(filePath));
+        const dirPath = path.dirname(filePath);
+        let routePath = this.fileToRoutePath(dirPath, baseDir);
+        // Handle route groups: (group) -> ignored in URL
+        routePath = routePath.replace(/\/\([^)]+\)/g, '');
+        // Handle dynamic routes
+        routePath = routePath.replace(/\[\.\.\.([^\]]+)\]/g, '*$1'); // catch-all
+        routePath = routePath.replace(/\[([^\]]+)\]/g, ':$1'); // dynamic
+        const params = this.extractParams(routePath);
+        const isDynamic = this.isDynamicPath(routePath);
+        // Determine route type
+        let type = 'page';
+        if (fileName === 'layout')
+            type = 'layout';
+        else if (fileName === 'error')
+            type = 'error';
+        else if (fileName === 'route')
+            type = 'api';
+        // Generate route name
+        const name = this.generateRouteName(filePath, baseDir);
+        return {
+            filePath,
+            path: routePath,
+            name,
+            isDynamic,
+            params,
+            type,
+            children: [],
+            meta: {
+                router: 'app',
+                framework: 'nextjs',
+                segment: fileName
+            }
+        };
+    }
+    /**
+     * Generate unique route name
+     */
+    generateRouteName(filePath, baseDir) {
+        const relativePath = path.relative(baseDir, filePath);
+        return relativePath
+            .replace(/\.(tsx?|jsx?)$/, '')
+            .replace(/[\/\\]/g, '.')
+            .replace(/\[|\]/g, '')
+            .replace(/^\./, '');
+    }
+    /**
+     * Validate Next.js project structure
+     */
+    async validate() {
+        const pagesDir = path.join(this.config.root, 'pages');
+        const appDir = path.join(this.config.root, 'app');
+        let found = false;
+        try {
+            await this.checkDirectory(pagesDir);
+            found = true;
+        }
+        catch {
+            // pages/ not found, try app/
+        }
+        if (!found) {
+            try {
+                await this.checkDirectory(appDir);
+                found = true;
+            }
+            catch {
+                // app/ not found either
+            }
+        }
+        if (!found) {
+            log.warn('No Next.js routing directories found (pages/ or app/)');
+        }
+    }
+    async checkDirectory(dir) {
+        const fs = await import('fs/promises');
+        await fs.access(dir);
+    }
+}

package/dist/meta-frameworks/nuxt/router.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Nuxt 3 Router
+ * Auto-routing from pages/ directory
+ */
+import { BaseRouter } from '../base-router.js';
+import { RouteManifest, RouterConfig } from '../types.js';
+export declare class NuxtRouter extends BaseRouter {
+    constructor(config: RouterConfig);
+    scanRoutes(): Promise<RouteManifest>;
+    /**
+     * Create Nuxt route from file
+     */
+    private createNuxtRoute;
+    /**
+     * Generate Nuxt route name (kebab-case)
+     */
+    private generateRouteName;
+    /**
+     * Validate Nuxt project structure
+     */
+    validate(): Promise<void>;
+}

package/dist/meta-frameworks/nuxt/router.js

@@ -0,0 +1,84 @@
+/**
+ * Nuxt 3 Router
+ * Auto-routing from pages/ directory
+ */
+import path from 'path';
+import { BaseRouter } from '../base-router.js';
+import { log } from '../../utils/logger.js';
+export class NuxtRouter extends BaseRouter {
+    constructor(config) {
+        super({ ...config, framework: 'nuxt' });
+    }
+    async scanRoutes() {
+        await this.validate();
+        const pagesDir = path.join(this.config.root, 'pages');
+        const files = await this.scanDirectory(pagesDir, ['.vue']);
+        const routes = [];
+        for (const filePath of files) {
+            const route = this.createNuxtRoute(filePath, pagesDir);
+            routes.push(route);
+        }
+        this.manifest = this.createManifest(routes);
+        this.logRoutes(this.manifest);
+        return this.manifest;
+    }
+    /**
+     * Create Nuxt route from file
+     */
+    createNuxtRoute(filePath, baseDir) {
+        let routePath = this.fileToRoutePath(filePath, baseDir);
+        // Handle dynamic routes
+        // [id].vue -> :id
+        // [...slug].vue -> :slug(.*) (catch-all)
+        // [[slug]].vue -> :slug? (optional)
+        routePath = routePath.replace(/\[\.\.\.([^\]]+)\]/g, ':$1(.*)'); // catch-all
+        routePath = routePath.replace(/\[\[([^\]]+)\]\]/g, ':$1?'); // optional
+        routePath = routePath.replace(/\[([^\]]+)\]/g, ':$1'); // dynamic
+        const params = this.extractParams(routePath);
+        const isDynamic = this.isDynamicPath(routePath);
+        // Generate route name (Nuxt uses kebab-case)
+        const name = this.generateRouteName(filePath, baseDir);
+        // Check if it's a middleware or layout
+        const fileName = path.basename(filePath, '.vue');
+        const isMiddleware = fileName.startsWith('middleware.');
+        const isLayout = fileName.startsWith('layout.');
+        return {
+            filePath,
+            path: routePath,
+            name,
+            isDynamic,
+            params,
+            type: isMiddleware ? 'middleware' : isLayout ? 'layout' : 'page',
+            children: [],
+            meta: {
+                framework: 'nuxt',
+                fileName
+            }
+        };
+    }
+    /**
+     * Generate Nuxt route name (kebab-case)
+     */
+    generateRouteName(filePath, baseDir) {
+        const relativePath = path.relative(baseDir, filePath);
+        return relativePath
+            .replace(/\.vue$/, '')
+            .replace(/[\/\\]/g, '-')
+            .replace(/\[|\]/g, '')
+            .replace(/^-/, '')
+            .toLowerCase();
+    }
+    /**
+     * Validate Nuxt project structure
+     */
+    async validate() {
+        const pagesDir = path.join(this.config.root, 'pages');
+        try {
+            const fs = await import('fs/promises');
+            await fs.access(pagesDir);
+        }
+        catch {
+            log.warn('No Nuxt pages/ directory found');
+        }
+    }
+}

package/dist/meta-frameworks/remix/router.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Remix Router
+ * File-based routing with nested routes
+ */
+import { BaseRouter } from '../base-router.js';
+import { RouteManifest, RouterConfig } from '../types.js';
+export declare class RemixRouter extends BaseRouter {
+    constructor(config: RouterConfig);
+    scanRoutes(): Promise<RouteManifest>;
+    /**
+     * Create Remix route from file
+     * Remix uses special naming conventions:
+     * - _index.tsx -> /
+     * - about.tsx -> /about
+     * - blog.$slug.tsx -> /blog/:slug
+     * - blog._index.tsx -> /blog
+     * - __layout.tsx -> pathless layout
+     */
+    private createRemixRoute;
+    /**
+     * Generate Remix route name
+     */
+    private generateRouteName;
+    /**
+     * Validate Remix project structure
+     */
+    validate(): Promise<void>;
+}

package/dist/meta-frameworks/remix/router.js

@@ -0,0 +1,136 @@
+/**
+ * Remix Router
+ * File-based routing with nested routes
+ */
+import path from 'path';
+import { BaseRouter } from '../base-router.js';
+import { log } from '../../utils/logger.js';
+export class RemixRouter extends BaseRouter {
+    constructor(config) {
+        super({ ...config, framework: 'remix' });
+    }
+    async scanRoutes() {
+        await this.validate();
+        const routesDir = path.join(this.config.root, 'app', 'routes');
+        const files = await this.scanDirectory(routesDir);
+        const routes = [];
+        for (const filePath of files) {
+            const route = this.createRemixRoute(filePath, routesDir);
+            routes.push(route);
+        }
+        this.manifest = this.createManifest(routes);
+        this.logRoutes(this.manifest);
+        return this.manifest;
+    }
+    /**
+     * Create Remix route from file
+     * Remix uses special naming conventions:
+     * - _index.tsx -> /
+     * - about.tsx -> /about
+     * - blog.$slug.tsx -> /blog/:slug
+     * - blog._index.tsx -> /blog
+     * - __layout.tsx -> pathless layout
+     */
+    createRemixRoute(filePath, baseDir) {
+        const fileName = path.basename(filePath, path.extname(filePath));
+        // Handle special files
+        if (fileName === '_index') {
+            const dirPath = path.dirname(filePath);
+            const routePath = this.fileToRoutePath(dirPath, baseDir);
+            return {
+                filePath,
+                path: routePath || '/',
+                name: this.generateRouteName(filePath, baseDir),
+                isDynamic: false,
+                params: [],
+                type: 'page',
+                children: [],
+                meta: {
+                    framework: 'remix',
+                    isIndex: true
+                }
+            };
+        }
+        // Parse Remix route syntax
+        let routePath = fileName;
+        // Handle pathless layouts: __layout -> ignored in URL
+        if (routePath.startsWith('__')) {
+            return {
+                filePath,
+                path: '',
+                name: this.generateRouteName(filePath, baseDir),
+                isDynamic: false,
+                params: [],
+                type: 'layout',
+                children: [],
+                meta: {
+                    framework: 'remix',
+                    pathless: true
+                }
+            };
+        }
+        // Handle layout routes: _layout -> layout but no URL segment
+        if (routePath.startsWith('_') && !routePath.includes('.')) {
+            return {
+                filePath,
+                path: '',
+                name: this.generateRouteName(filePath, baseDir),
+                isDynamic: false,
+                params: [],
+                type: 'layout',
+                children: [],
+                meta: {
+                    framework: 'remix',
+                    layout: true
+                }
+            };
+        }
+        // Convert dots to slashes: blog.post -> /blog/post
+        routePath = routePath.replace(/\./g, '/');
+        // Handle dynamic segments: $slug -> :slug
+        routePath = routePath.replace(/\$([a-zA-Z0-9_]+)/g, ':$1');
+        // Handle splat routes: $.tsx -> *
+        routePath = routePath.replace(/\$$/g, '*');
+        // Add leading slash
+        routePath = '/' + routePath;
+        const params = this.extractParams(routePath);
+        const isDynamic = this.isDynamicPath(routePath);
+        return {
+            filePath,
+            path: routePath,
+            name: this.generateRouteName(filePath, baseDir),
+            isDynamic,
+            params,
+            type: 'page',
+            children: [],
+            meta: {
+                framework: 'remix'
+            }
+        };
+    }
+    /**
+     * Generate Remix route name
+     */
+    generateRouteName(filePath, baseDir) {
+        const relativePath = path.relative(baseDir, filePath);
+        return relativePath
+            .replace(/\.(tsx?|jsx?)$/, '')
+            .replace(/[\/\\]/g, '.')
+            .replace(/\$/g, '')
+            .replace(/^_/, '')
+            .replace(/^\./, '');
+    }
+    /**
+     * Validate Remix project structure
+     */
+    async validate() {
+        const routesDir = path.join(this.config.root, 'app', 'routes');
+        try {
+            const fs = await import('fs/promises');
+            await fs.access(routesDir);
+        }
+        catch {
+            log.warn('No Remix app/routes/ directory found');
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+/**
+ * React SSR Renderer
+ * Server-side rendering for React/Next.js/Remix
+ */
+import * as React from 'react';
+import { RenderContext } from './server.js';
+export interface ReactSSROptions {
+    /** Enable streaming */
+    streaming?: boolean;
+    /** Custom wrapper component */
+    wrapper?: React.ComponentType<any>;
+}
+export declare class ReactSSRRenderer {
+    private options;
+    constructor(options?: ReactSSROptions);
+    /**
+     * Render React component to HTML string
+     */
+    render(Component: any, context: RenderContext): Promise<string>;
+    /**
+     * Render with streaming (React 18+)
+     */
+    renderToStream(Component: any, context: RenderContext): Promise<ReadableStream>;
+}

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

@@ -0,0 +1,53 @@
+/**
+ * React SSR Renderer
+ * Server-side rendering for React/Next.js/Remix
+ */
+import * as React from 'react';
+import { renderToString } from 'react-dom/server';
+export class ReactSSRRenderer {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    /**
+     * Render React component to HTML string
+     */
+    async render(Component, context) {
+        try {
+            console.log('DEBUG: ReactSSRRenderer.render', {
+                ReactType: typeof React,
+                ReactIsUndef: React === undefined,
+                ComponentType: typeof Component,
+                ComponentDefault: typeof Component?.default
+            });
+            // Create element with props
+            const element = React.createElement(Component.default || Component, {
+                ...context.data,
+                params: context.params,
+                searchParams: context.query,
+            });
+            // Wrap in custom wrapper if provided
+            const wrappedElement = this.options.wrapper
+                ? React.createElement(this.options.wrapper, {}, element)
+                : element;
+            // Render to string
+            const html = renderToString(wrappedElement);
+            return html;
+        }
+        catch (error) {
+            console.error('React SSR Error Detailed:', {
+                message: error.message,
+                stack: error.stack,
+                component: Component?.displayName || Component?.name
+            });
+            throw new Error(`Failed to render React component: ${error.message}\nStack: ${error.stack}`);
+        }
+    }
+    /**
+     * Render with streaming (React 18+)
+     */
+    async renderToStream(Component, context) {
+        // This would use renderToPipeableStream for Node.js
+        // or renderToReadableStream for edge runtimes
+        throw new Error('Streaming SSR not yet implemented');
+    }
+}

package/dist/meta-frameworks/ssr/server.d.ts

@@ -0,0 +1,92 @@
+/**
+ * SSR Server Runtime
+ * Universal server-side rendering for Next.js, Nuxt, and Remix
+ */
+import { Request, Response } from 'express';
+import { Route } from '../types.js';
+export interface SSRConfig {
+    /** Project root directory */
+    root: string;
+    /** Framework type */
+    framework: 'nextjs' | 'nuxt' | 'remix';
+    /** Build output directory */
+    outDir: string;
+    /** Server port */
+    port: number;
+    /** Enable production mode */
+    production?: boolean;
+    /** Custom HTML template */
+    template?: string;
+}
+export interface RenderContext {
+    /** Current route */
+    route: Route;
+    /** Request object */
+    req: Request;
+    /** Response object */
+    res: Response;
+    /** Route parameters */
+    params: Record<string, string>;
+    /** Query parameters */
+    query: Record<string, string>;
+    /** Data fetched for this route */
+    data?: any;
+}
+export declare class SSRServer {
+    private app;
+    private config;
+    private router;
+    constructor(config: SSRConfig);
+    /**
+     * Create framework-specific router
+     */
+    private createRouter;
+    /**
+     * Start the SSR server
+     */
+    start(): Promise<void>;
+    /**
+     * Handle API route request
+     */
+    private handleAPIRoute;
+    /**
+     * Handle page route request
+     */
+    private handlePageRoute;
+    /**
+     * Fetch data for a route
+     */
+    private fetchData;
+    /**
+     * Render page to HTML
+     */
+    private renderPage;
+    /**
+     * Render React component to HTML
+     */
+    private renderReact;
+    /**
+     * Render Vue component to HTML
+     */
+    private renderVue;
+    /**
+     * Wrap rendered content in HTML document
+     */
+    private wrapInDocument;
+    /**
+     * Get default HTML template
+     */
+    private getDefaultTemplate;
+    /**
+     * Render 404 page
+     */
+    private render404;
+    /**
+     * Render 500 error page
+     */
+    private render500;
+    /**
+     * Import a route module
+     */
+    private importRoute;
+}