@vistagenic/vista 0.1.0-alpha.1

package/bin/vista.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+const command = process.argv[2];
+const flags = process.argv.slice(3);
+
+// Check for RSC mode flag
+const useRSC = flags.includes('--rsc') || process.env.VISTA_RSC === 'true';
+
+if (command === 'dev') {
+  if (useRSC) {
+    // RSC Mode - True React Server Components Architecture
+    console.log('');
+    console.log('🚀 Starting Vista in RSC mode (React Server Components)');
+    console.log('');
+
+    const { buildRSC } = require('../dist/bin/build-rsc');
+    const { startRSCServer } = require('../dist/server/rsc-engine');
+
+    buildRSC(true)
+      .then(({ clientCompiler }) => {
+        startRSCServer({
+          port: process.env.PORT || 3003,
+          compiler: clientCompiler,
+        });
+      })
+      .catch((err) => {
+        console.error('RSC Build failed:', err);
+        process.exit(1);
+      });
+  } else {
+    // Legacy Mode
+    const { startServer } = require('../dist/server/engine');
+    const { buildClient } = require('../dist/bin/build');
+
+    buildClient(true)
+      .then((compiler) => {
+        startServer(process.env.PORT || 3003, compiler);
+      })
+      .catch((err) => {
+        console.error('Build failed:', err);
+        process.exit(1);
+      });
+  }
+} else if (command === 'build') {
+  if (useRSC) {
+    // RSC Production Build
+    const { buildRSC } = require('../dist/bin/build-rsc');
+
+    buildRSC(false)
+      .then(() => {
+        console.log('');
+        console.log('✅ RSC Production build complete!');
+      })
+      .catch((err) => {
+        console.error('RSC Build failed:', err);
+        process.exit(1);
+      });
+  } else {
+    // Legacy Build
+    const { buildClient } = require('../dist/bin/build');
+
+    buildClient(false)
+      .then(() => {
+        console.log('Production build complete!');
+      })
+      .catch((err) => {
+        console.error('Build failed:', err);
+        process.exit(1);
+      });
+  }
+} else if (command === 'start') {
+  if (useRSC) {
+    const { startRSCServer } = require('../dist/server/rsc-engine');
+    startRSCServer({ port: process.env.PORT || 3003 });
+  } else {
+    const { startServer } = require('../dist/server/engine');
+    startServer(process.env.PORT || 3003);
+  }
+} else {
+  console.log('');
+  console.log('Vista Framework CLI');
+  console.log('');
+  console.log('Usage: vista <command> [options]');
+  console.log('');
+  console.log('Commands:');
+  console.log('  dev     Start development server with HMR');
+  console.log('  build   Create production build');
+  console.log('  start   Start production server');
+  console.log('');
+  console.log('Options:');
+  console.log('  --rsc   Enable React Server Components mode');
+  console.log('');
+  console.log('Examples:');
+  console.log('  vista dev          # Start dev server (legacy mode)');
+  console.log('  vista dev --rsc    # Start dev server with RSC');
+  console.log('  vista build --rsc  # Production build with RSC');
+  console.log('');
+}

package/dist/auth/index.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export declare function AuthProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare const useAuth: () => {
+    user: any;
+    login: () => void;
+};

package/dist/auth/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAuth = void 0;
+exports.AuthProvider = AuthProvider;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const AuthContext = (0, react_1.createContext)({ user: null, login: () => { } });
+function AuthProvider({ children }) {
+    const [user, setUser] = (0, react_1.useState)(null);
+    const login = () => {
+        setUser({ name: "Vista User" });
+    };
+    return ((0, jsx_runtime_1.jsx)(AuthContext.Provider, { value: { user, login }, children: children }));
+}
+const useAuth = () => (0, react_1.useContext)(AuthContext);
+exports.useAuth = useAuth;

package/dist/bin/build-rsc.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Vista RSC Build System
+ *
+ * Builds the application using the True RSC Architecture:
+ * 1. Server bundle (.vista/server/) - All code for SSR
+ * 2. Client bundle (.vista/static/) - Only client components
+ * 3. Manifests for hydration coordination
+ */
+import webpack from 'webpack';
+/**
+ * Build with RSC architecture
+ */
+export declare function buildRSC(watch?: boolean): Promise<{
+    serverCompiler: webpack.Compiler | null;
+    clientCompiler: webpack.Compiler | null;
+}>;
+export { buildRSC as default };

package/dist/bin/build-rsc.js

@@ -0,0 +1,320 @@
+"use strict";
+/**
+ * Vista RSC Build System
+ *
+ * Builds the application using the True RSC Architecture:
+ * 1. Server bundle (.vista/server/) - All code for SSR
+ * 2. Client bundle (.vista/static/) - Only client components
+ * 3. Manifests for hydration coordination
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRSC = buildRSC;
+exports.default = buildRSC;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const webpack_1 = __importDefault(require("webpack"));
+const compiler_1 = require("../build/rsc/compiler");
+const manifest_1 = require("../build/manifest");
+const client_manifest_1 = require("../build/rsc/client-manifest");
+const server_manifest_1 = require("../build/rsc/server-manifest");
+const file_scanner_1 = require("./file-scanner");
+/**
+ * Run PostCSS for CSS compilation
+ */
+function runPostCSS(cwd, vistaDir) {
+    const globalsCss = path_1.default.join(cwd, 'app/globals.css');
+    if (fs_1.default.existsSync(globalsCss)) {
+        console.log('[Vista RSC] Building CSS with PostCSS...');
+        const { execSync } = require('child_process');
+        try {
+            const cssOut = path_1.default.join(vistaDir, 'client.css');
+            execSync(`npx postcss app/globals.css -o "${cssOut}"`, { stdio: 'inherit', cwd });
+            console.log('[Vista RSC] CSS Built Successfully!');
+        }
+        catch (cssErr) {
+            console.error('[Vista RSC] CSS Build failed (PostCSS error).');
+        }
+    }
+}
+/**
+ * Generate the RSC-aware client entry file
+ */
+function generateRSCClientEntry(cwd, vistaDir) {
+    const clientManifestPath = path_1.default.join(vistaDir, 'client-manifest.json');
+    let clientImports = '';
+    let clientComponents = '{}';
+    if (fs_1.default.existsSync(clientManifestPath)) {
+        const manifest = JSON.parse(fs_1.default.readFileSync(clientManifestPath, 'utf-8'));
+        // Generate imports for all client components
+        const imports = [];
+        const components = [];
+        Object.values(manifest.clientModules).forEach((entry, index) => {
+            const varName = `ClientComponent_${index}`;
+            const relativePath = './' + path_1.default.relative(vistaDir, entry.absolutePath).replace(/\\/g, '/');
+            imports.push(`import ${varName} from '${relativePath}';`);
+            components.push(`'${entry.id}': ${varName}`);
+        });
+        clientImports = imports.join('\n');
+        clientComponents = `{\n    ${components.join(',\n    ')}\n}`;
+    }
+    const clientEntryContent = `/**
+ * Vista RSC Client Entry
+ * 
+ * This file is auto-generated. Do not edit directly.
+ * It handles selective hydration of client components.
+ */
+
+import * as React from 'react';
+import { createRoot } from 'react-dom/client';
+
+// Import all client components
+${clientImports}
+
+// Client component registry
+const clientComponents = ${clientComponents};
+
+// Hydration logic
+interface ClientReference {
+    id: string;
+    mountId: string;
+    props: Record<string, any>;
+    chunkUrl: string;
+    exportName: string;
+}
+
+function deserializeProps(props: Record<string, any>): Record<string, any> {
+    const result: Record<string, any> = {};
+    for (const [key, value] of Object.entries(props)) {
+        if (value && typeof value === 'object' && value.__type) {
+            switch (value.__type) {
+                case 'Date':
+                    result[key] = new Date(value.value);
+                    break;
+                case 'undefined':
+                    result[key] = undefined;
+                    break;
+                default:
+                    result[key] = value;
+            }
+        } else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+
+async function hydrateClientComponents() {
+    const references: ClientReference[] = (window as any).__VISTA_CLIENT_REFERENCES__ || [];
+    
+    console.log('[Vista RSC] Hydrating', references.length, 'client component(s)');
+    
+    for (const ref of references) {
+        try {
+            const mountPoint = document.getElementById(ref.mountId);
+            if (!mountPoint) {
+                console.warn('[Vista RSC] Mount point not found:', ref.mountId);
+                continue;
+            }
+            
+            // Get component from registry
+            let Component = clientComponents[ref.id];
+            
+            if (!Component) {
+                // Try dynamic import
+                try {
+                    const module = await import(/* webpackIgnore: true */ ref.chunkUrl);
+                    Component = module[ref.exportName] || module.default;
+                } catch (e) {
+                    console.error('[Vista RSC] Failed to load component:', ref.id, e);
+                    continue;
+                }
+            }
+            
+            if (!Component) {
+                console.error('[Vista RSC] Component not found:', ref.id);
+                continue;
+            }
+            
+            const props = deserializeProps(ref.props);
+            
+            // Use createRoot since we render a placeholder on server
+            const root = createRoot(mountPoint);
+            root.render(React.createElement(Component, props));
+            
+            mountPoint.setAttribute('data-hydrated', 'true');
+            
+        } catch (e) {
+            console.error('[Vista RSC] Hydration error:', ref.id, e);
+        }
+    }
+}
+
+// Initialize
+if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', hydrateClientComponents);
+} else {
+    hydrateClientComponents();
+}
+
+// HMR Support
+if ((module as any).hot) {
+    (module as any).hot.accept();
+}
+`;
+    fs_1.default.writeFileSync(path_1.default.join(vistaDir, 'rsc-client.tsx'), clientEntryContent);
+    console.log('[Vista RSC] Generated client entry file');
+}
+/**
+ * Build with RSC architecture
+ */
+async function buildRSC(watch = false) {
+    const cwd = process.cwd();
+    const appDir = path_1.default.join(cwd, 'app');
+    console.log('');
+    console.log('╔══════════════════════════════════════════════════════════════╗');
+    console.log('║           Vista RSC Build System (React Server Components)   ║');
+    console.log('╚══════════════════════════════════════════════════════════════╝');
+    console.log('');
+    // Create .vista directory structure
+    const vistaDirs = (0, manifest_1.createVistaDirectories)(cwd);
+    const buildId = (0, manifest_1.getBuildId)(vistaDirs.root, !watch);
+    console.log(`[Vista RSC] Build ID: ${buildId}`);
+    console.log(`[Vista RSC] Mode: ${watch ? 'Development (Watch)' : 'Production'}`);
+    console.log('');
+    // Scan app directory
+    if (fs_1.default.existsSync(appDir)) {
+        console.log(`[Vista RSC] Using ${(0, file_scanner_1.isNativeAvailable)() ? 'Rust native' : 'JS fallback'} scanner (v${(0, file_scanner_1.getVersion)()})`);
+        const scanResult = (0, file_scanner_1.scanAppDirectory)(appDir);
+        console.log(`[Vista RSC] Found ${scanResult.serverComponents.length} server components`);
+        console.log(`[Vista RSC] Found ${scanResult.clientComponents.length} client components ('client load')`);
+        console.log('');
+        // List client components
+        if (scanResult.clientComponents.length > 0) {
+            console.log('[Vista RSC] Client Components (will be hydrated on browser):');
+            scanResult.clientComponents.forEach((c) => {
+                console.log(`  ✓ ${c.relativePath}`);
+            });
+            console.log('');
+        }
+        // List server components (first few)
+        if (scanResult.serverComponents.length > 0) {
+            console.log('[Vista RSC] Server Components (0kb client bundle contribution):');
+            scanResult.serverComponents.slice(0, 5).forEach((c) => {
+                console.log(`  • ${c.relativePath}`);
+            });
+            if (scanResult.serverComponents.length > 5) {
+                console.log(`  ... and ${scanResult.serverComponents.length - 5} more`);
+            }
+            console.log('');
+        }
+        // Check for errors (using client hooks without 'client load')
+        if (scanResult.errors.length > 0) {
+            console.log('\x1b[41m\x1b[37m ERROR \x1b[0m \x1b[31mServer Component Violations\x1b[0m');
+            console.log('');
+            for (const error of scanResult.errors) {
+                console.log(`\x1b[31m✗\x1b[0m ${error.file}`);
+                console.log(`  Using: \x1b[33m${error.hooks.slice(0, 3).join(', ')}\x1b[0m in a Server Component`);
+                console.log('');
+                console.log(`  \x1b[36mTo fix:\x1b[0m Add \x1b[33m'client load'\x1b[0m at the top of the file`);
+                console.log('');
+            }
+            if (!watch) {
+                console.log('\x1b[31mBuild failed due to Server Component violations.\x1b[0m');
+                process.exit(1);
+            }
+        }
+    }
+    // Generate manifests
+    console.log('[Vista RSC] Generating manifests...');
+    const clientManifest = (0, client_manifest_1.generateClientManifest)(cwd, appDir);
+    fs_1.default.writeFileSync(path_1.default.join(vistaDirs.root, 'client-manifest.json'), JSON.stringify(clientManifest, null, 2));
+    console.log(`  ✓ client-manifest.json (${Object.keys(clientManifest.clientModules).length} modules)`);
+    const serverManifest = (0, server_manifest_1.generateServerManifest)(cwd, appDir);
+    fs_1.default.writeFileSync(path_1.default.join(vistaDirs.server, 'server-manifest.json'), JSON.stringify(serverManifest, null, 2));
+    console.log(`  ✓ server-manifest.json (${Object.keys(serverManifest.serverModules).length} modules, ${serverManifest.routes.length} routes)`);
+    console.log('');
+    // Generate client entry
+    generateRSCClientEntry(cwd, vistaDirs.root);
+    // Create webpack configs
+    const options = { cwd, isDev: watch, vistaDirs, buildId };
+    // Build CSS
+    runPostCSS(cwd, vistaDirs.root);
+    if (watch) {
+        // Development mode - return compilers for middleware
+        console.log('[Vista RSC] Creating development compilers...');
+        const clientConfig = (0, compiler_1.createClientWebpackConfig)(options);
+        const clientCompiler = (0, webpack_1.default)(clientConfig);
+        // Watch for CSS changes
+        try {
+            const chokidar = require('chokidar');
+            chokidar.watch(path_1.default.join(cwd, 'app/**/*.css'), { ignoreInitial: true }).on('change', () => {
+                console.log('[Vista RSC] CSS changed, rebuilding...');
+                runPostCSS(cwd, vistaDirs.root);
+            });
+        }
+        catch (e) {
+            // chokidar not installed
+        }
+        console.log('[Vista RSC] Ready for development');
+        console.log('');
+        return { serverCompiler: null, clientCompiler };
+    }
+    else {
+        // Production build
+        console.log('[Vista RSC] Building for production...');
+        console.log('');
+        const serverConfig = (0, compiler_1.createServerWebpackConfig)(options);
+        const clientConfig = (0, compiler_1.createClientWebpackConfig)(options);
+        // Build server bundle
+        console.log('[Vista RSC] Building server bundle...');
+        await new Promise((resolve, reject) => {
+            (0, webpack_1.default)(serverConfig).run((err, stats) => {
+                if (err) {
+                    console.error('[Vista RSC] Server build error:', err);
+                    reject(err);
+                    return;
+                }
+                if (stats?.hasErrors()) {
+                    console.error('[Vista RSC] Server compilation errors:', stats.toString('errors-only'));
+                    reject(new Error('Server compilation failed'));
+                    return;
+                }
+                console.log('[Vista RSC] Server bundle complete');
+                resolve();
+            });
+        });
+        // Build client bundle
+        console.log('[Vista RSC] Building client bundle...');
+        await new Promise((resolve, reject) => {
+            (0, webpack_1.default)(clientConfig).run((err, stats) => {
+                if (err) {
+                    console.error('[Vista RSC] Client build error:', err);
+                    reject(err);
+                    return;
+                }
+                if (stats?.hasErrors()) {
+                    console.error('[Vista RSC] Client compilation errors:', stats.toString('errors-only'));
+                    reject(new Error('Client compilation failed'));
+                    return;
+                }
+                console.log('[Vista RSC] Client bundle complete');
+                console.log(stats?.toString('minimal'));
+                resolve();
+            });
+        });
+        console.log('');
+        console.log('╔══════════════════════════════════════════════════════════════╗');
+        console.log('║                    Build Complete! 🎉                        ║');
+        console.log('╚══════════════════════════════════════════════════════════════╝');
+        console.log('');
+        console.log('  Output directory: .vista/');
+        console.log('    ├── server/     (Server-side bundle - NEVER sent to client)');
+        console.log('    ├── static/     (Client assets - only client components)');
+        console.log('    └── cache/      (Build cache for faster rebuilds)');
+        console.log('');
+        return { serverCompiler: null, clientCompiler: null };
+    }
+}

package/dist/bin/build.d.ts

@@ -0,0 +1,4 @@
+import webpack from 'webpack';
+declare let compiler: webpack.Compiler | null;
+export declare function buildClient(watch?: boolean, onRebuild?: () => void): Promise<webpack.Compiler | null>;
+export { compiler };