@ereo/cli 0.1.6

package/dist/index.js

@@ -0,0 +1,2335 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/commands/build.ts
+var exports_build = {};
+__export(exports_build, {
+  build: () => build
+});
+import { join as join2 } from "path";
+import { build as bundlerBuild, printBuildReport } from "@ereo/bundler";
+async function build(options = {}) {
+  const root = process.cwd();
+  console.log(`
+  \x1B[36m\u2B21\x1B[0m \x1B[1mEreo\x1B[0m Production Build
+`);
+  let config = {};
+  const configPath = join2(root, "ereo.config.ts");
+  try {
+    if (await Bun.file(configPath).exists()) {
+      const configModule = await import(configPath);
+      config = configModule.default || configModule;
+    }
+  } catch (error) {
+    console.warn("Could not load config:", error);
+  }
+  const configTarget = config.build?.target || "bun";
+  const bundlerTarget = ["bun", "node", "browser"].includes(configTarget) ? configTarget : "bun";
+  const buildOptions = {
+    root,
+    outDir: options.outDir || config.build?.outDir || ".ereo",
+    minify: options.minify ?? config.build?.minify ?? true,
+    sourcemap: options.sourcemap ?? config.build?.sourcemap ?? true,
+    target: bundlerTarget
+  };
+  console.log(`  Target: ${buildOptions.target}`);
+  console.log(`  Output: ${buildOptions.outDir}`);
+  console.log("");
+  const result = await bundlerBuild(buildOptions);
+  if (result.success) {
+    printBuildReport(result);
+    console.log(`
+  \x1B[32m\u2713\x1B[0m Build completed successfully
+`);
+  } else {
+    console.error(`
+  \x1B[31m\u2717\x1B[0m Build failed
+`);
+    if (result.errors) {
+      for (const error of result.errors) {
+        console.error(`  ${error}`);
+      }
+    }
+    process.exit(1);
+  }
+}
+var init_build = () => {};
+
+// src/commands/dev.ts
+import { join } from "path";
+import {
+  createApp,
+  setupEnv
+} from "@ereo/core";
+import { initFileRouter } from "@ereo/router";
+import { createServer } from "@ereo/server";
+import {
+  createHMRServer,
+  createHMRWatcher,
+  createHMRWebSocket,
+  HMR_CLIENT_CODE,
+  ERROR_OVERLAY_SCRIPT
+} from "@ereo/bundler";
+async function dev(options = {}) {
+  const port = options.port || 3000;
+  const hostname = options.host || "localhost";
+  const root = process.cwd();
+  console.log(`
+  \x1B[36m\u2B21\x1B[0m \x1B[1mEreo\x1B[0m Dev Server
+`);
+  let config = {};
+  const configPath = join(root, "ereo.config.ts");
+  try {
+    if (await Bun.file(configPath).exists()) {
+      const configModule = await import(configPath);
+      config = configModule.default || configModule;
+    }
+  } catch (error) {
+    console.warn("Could not load config:", error);
+  }
+  if (config.env) {
+    console.log("  \x1B[2mLoading environment variables...\x1B[0m");
+    const envResult = await setupEnv(root, config.env, "development");
+    if (!envResult.valid) {
+      console.error(`
+  \x1B[31m\u2716\x1B[0m Environment validation failed
+`);
+      process.exit(1);
+    }
+    console.log(`  \x1B[32m\u2713\x1B[0m Loaded ${Object.keys(envResult.env).length} environment variables
+`);
+  }
+  const app = createApp({
+    config: {
+      ...config,
+      server: {
+        port,
+        hostname,
+        development: true,
+        ...config.server
+      }
+    }
+  });
+  const router = await initFileRouter({
+    routesDir: config.routesDir || "app/routes",
+    watch: true
+  });
+  await router.loadAllModules();
+  const hmr = createHMRServer();
+  const hmrWatcher = createHMRWatcher(hmr);
+  hmrWatcher.watch(join(root, "app"));
+  router.on("reload", async () => {
+    console.log("\x1B[33m\u27F3\x1B[0m Routes reloaded");
+    await router.loadAllModules();
+    hmr.reload();
+  });
+  router.on("change", (route) => {
+    console.log(`\x1B[33m\u27F3\x1B[0m ${route.path} changed`);
+    hmr.jsUpdate(route.file);
+  });
+  const server = createServer({
+    port,
+    hostname,
+    development: true,
+    logging: true,
+    websocket: createHMRWebSocket(hmr)
+  });
+  server.setApp(app);
+  server.setRouter(router);
+  const pluginRegistry = app.getPluginRegistry();
+  await pluginRegistry.registerAll(config.plugins || []);
+  const devServer = {
+    ws: {
+      send: (data) => {
+        if (data && typeof data === "object") {
+          hmr.send(data);
+        }
+      },
+      on: (event, callback) => {}
+    },
+    restart: async () => {
+      console.log("\x1B[33m\u27F3\x1B[0m Restarting server...");
+      hmr.reload();
+    },
+    middlewares: [],
+    watcher: {
+      add: (path) => hmrWatcher.watch(path),
+      on: (event, callback) => {}
+    }
+  };
+  await pluginRegistry.configureServer(devServer);
+  for (const middleware of devServer.middlewares) {
+    server.use(middleware);
+  }
+  server.use(async (request, context, next) => {
+    const url = new URL(request.url);
+    if (url.pathname === "/__hmr-client.js") {
+      return new Response(HMR_CLIENT_CODE, {
+        headers: { "Content-Type": "text/javascript" }
+      });
+    }
+    try {
+      const response = await next();
+      if (response.headers.get("Content-Type")?.includes("text/html")) {
+        let html = await response.text();
+        const scripts = `
+          <script src="/__hmr-client.js"></script>
+          ${ERROR_OVERLAY_SCRIPT}
+        `;
+        html = html.replace("</body>", `${scripts}</body>`);
+        return new Response(html, {
+          status: response.status,
+          headers: response.headers
+        });
+      }
+      return response;
+    } catch (error) {
+      hmr.error(error instanceof Error ? error.message : String(error), error instanceof Error ? error.stack : undefined);
+      throw error;
+    }
+  });
+  await server.start();
+  console.log(`  \x1B[32m\u279C\x1B[0m  Local:   \x1B[36mhttp://${hostname}:${port}/\x1B[0m`);
+  if (options.open) {
+    const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    Bun.spawn([opener, `http://${hostname}:${port}`]);
+  }
+  console.log(`
+  \x1B[2mpress h to show help\x1B[0m
+`);
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", async (data) => {
+      const key = data.toString();
+      switch (key) {
+        case "h":
+          console.log(`
+  Shortcuts:`);
+          console.log("    r - Reload routes");
+          console.log("    c - Clear console");
+          console.log("    q - Quit");
+          console.log("");
+          break;
+        case "r":
+          console.log("\x1B[33m\u27F3\x1B[0m Reloading routes...");
+          await router.discoverRoutes();
+          await router.loadAllModules();
+          hmr.reload();
+          break;
+        case "c":
+          console.clear();
+          console.log(`
+  \x1B[36m\u2B21\x1B[0m \x1B[1mEreo\x1B[0m Dev Server
+`);
+          console.log(`  \x1B[32m\u279C\x1B[0m  Local:   \x1B[36mhttp://${hostname}:${port}/\x1B[0m
+`);
+          break;
+        case "q":
+        case "\x03":
+          console.log(`
+  Shutting down...
+`);
+          server.stop();
+          hmrWatcher.stop();
+          process.exit(0);
+          break;
+      }
+    });
+  }
+  process.on("SIGINT", () => {
+    console.log(`
+  Shutting down...
+`);
+    server.stop();
+    hmrWatcher.stop();
+    process.exit(0);
+  });
+}
+
+// src/index.ts
+init_build();
+
+// src/commands/start.ts
+import { join as join3 } from "path";
+import { createApp as createApp2 } from "@ereo/core";
+import { initFileRouter as initFileRouter2 } from "@ereo/router";
+import { createServer as createServer2 } from "@ereo/server";
+async function start(options = {}) {
+  const root = process.cwd();
+  const buildDir = join3(root, ".ereo");
+  console.log(`
+  \x1B[36m\u2B21\x1B[0m \x1B[1mEreo\x1B[0m Production Server
+`);
+  const manifestPath = join3(buildDir, "manifest.json");
+  if (!await Bun.file(manifestPath).exists()) {
+    console.error("  \x1B[31m\u2717\x1B[0m No build found. Run `ereo build` first.\n");
+    process.exit(1);
+  }
+  const manifest = await Bun.file(manifestPath).json();
+  let config = {};
+  const configPath = join3(root, "ereo.config.ts");
+  try {
+    if (await Bun.file(configPath).exists()) {
+      const configModule = await import(configPath);
+      config = configModule.default || configModule;
+    }
+  } catch {}
+  const port = options.port || config.server?.port || 3000;
+  const hostname = options.host || config.server?.hostname || "0.0.0.0";
+  const app = createApp2({
+    config: {
+      ...config,
+      server: {
+        port,
+        hostname,
+        development: false
+      }
+    }
+  });
+  const router = await initFileRouter2({
+    routesDir: config.routesDir || "app/routes",
+    watch: false
+  });
+  await router.loadAllModules();
+  const server = createServer2({
+    port,
+    hostname,
+    development: false,
+    logging: true,
+    static: {
+      root: join3(buildDir, "client"),
+      prefix: "/_ereo",
+      maxAge: 31536000,
+      immutable: true
+    }
+  });
+  server.setApp(app);
+  server.setRouter(router);
+  await server.start();
+  console.log(`  \x1B[32m\u279C\x1B[0m  Server running at \x1B[36mhttp://${hostname}:${port}/\x1B[0m
+`);
+  process.on("SIGINT", () => {
+    console.log(`
+  Shutting down...
+`);
+    server.stop();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    console.log(`
+  Shutting down...
+`);
+    server.stop();
+    process.exit(0);
+  });
+}
+
+// src/commands/create.ts
+import { join as join4 } from "path";
+import { mkdir } from "fs/promises";
+async function create(projectName, options = {}) {
+  const template = options.template || "tailwind";
+  const typescript = options.typescript !== false;
+  console.log(`
+  \x1B[36m\u2B21\x1B[0m \x1B[1mEreo\x1B[0m Create Project
+`);
+  console.log(`  Creating ${projectName} with ${template} template...
+`);
+  const projectDir = join4(process.cwd(), projectName);
+  await mkdir(projectDir, { recursive: true });
+  await mkdir(join4(projectDir, "app/routes"), { recursive: true });
+  await mkdir(join4(projectDir, "app/components"), { recursive: true });
+  await mkdir(join4(projectDir, "app/middleware"), { recursive: true });
+  await mkdir(join4(projectDir, "public"), { recursive: true });
+  const files = generateTemplateFiles(template, typescript, projectName);
+  const sortedPaths = Object.keys(files).sort();
+  for (const path of sortedPaths) {
+    const content = files[path];
+    const fullPath = join4(projectDir, path);
+    await mkdir(join4(fullPath, ".."), { recursive: true });
+    await Bun.write(fullPath, content);
+    console.log(`  \x1B[32m+\x1B[0m ${path}`);
+  }
+  console.log(`
+  \x1B[32m\u2713\x1B[0m Project created successfully!
+`);
+  console.log(`  Next steps:
+`);
+  console.log(`    cd ${projectName}`);
+  console.log("    bun install");
+  console.log(`    bun run dev
+`);
+}
+function generateTemplateFiles(template, typescript, projectName) {
+  const ext = typescript ? "tsx" : "jsx";
+  const files = {};
+  const dependencies = {
+    "@ereo/core": "^0.1.0",
+    "@ereo/router": "^0.1.0",
+    "@ereo/server": "^0.1.0",
+    "@ereo/client": "^0.1.0",
+    "@ereo/data": "^0.1.0",
+    "@ereo/cli": "^0.1.0",
+    react: "^18.2.0",
+    "react-dom": "^18.2.0"
+  };
+  if (template === "tailwind") {
+    dependencies["@ereo/plugin-tailwind"] = "^0.1.0";
+  }
+  files["package.json"] = JSON.stringify({
+    name: projectName,
+    version: "0.1.0",
+    type: "module",
+    scripts: {
+      dev: "ereo dev",
+      build: "ereo build",
+      start: "ereo start"
+    },
+    dependencies,
+    devDependencies: typescript ? {
+      "@types/react": "^18.2.0",
+      "@types/react-dom": "^18.2.0",
+      typescript: "^5.4.0"
+    } : {}
+  }, null, 2);
+  if (typescript) {
+    files["tsconfig.json"] = JSON.stringify({
+      compilerOptions: {
+        target: "ESNext",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        jsx: "react-jsx",
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        forceConsistentCasingInFileNames: true,
+        types: ["bun-types"]
+      },
+      include: ["app/**/*", "ereo.config.ts"]
+    }, null, 2);
+  }
+  files[`ereo.config.${typescript ? "ts" : "js"}`] = generateEreoConfig(template);
+  files[".env"] = generateEnvFile();
+  files[".env.example"] = generateEnvFile();
+  files[`app/routes/_layout.${ext}`] = generateRootLayout(template, typescript);
+  files[`app/entry.client.${ext}`] = generateClientEntry(typescript);
+  files[`app/routes/index.${ext}`] = generateIndexPage(template, typescript);
+  files[`app/routes/about.${ext}`] = generateAboutPage(template, typescript);
+  files[`app/routes/contact.${ext}`] = generateContactPage(template, typescript);
+  files[`app/components/Counter.${ext}`] = generateCounterComponent(template, typescript);
+  files[`app/middleware/logger.${typescript ? "ts" : "js"}`] = generateLoggerMiddleware(typescript);
+  files[`app/routes/_error.${ext}`] = generateErrorBoundary(template, typescript);
+  files[`app/routes/blog/[slug].${ext}`] = generateDynamicRoute(template, typescript);
+  files[`app/routes/blog/index.${ext}`] = generateBlogIndex(template, typescript);
+  files[`app/routes/api/health.${typescript ? "ts" : "js"}`] = generateApiRoute(typescript);
+  if (template === "tailwind") {
+    files["tailwind.config.js"] = generateTailwindConfig();
+    files["app/globals.css"] = generateGlobalCSS();
+  }
+  files[".gitignore"] = generateGitignore();
+  return files;
+}
+function generateEreoConfig(template) {
+  const tailwindImport = template === "tailwind" ? `import tailwind from '@ereo/plugin-tailwind';
+` : "";
+  const tailwindPlugin = template === "tailwind" ? "    tailwind()," : "";
+  return `import { defineConfig } from '@ereo/core';
+${tailwindImport}
+export default defineConfig({
+  server: {
+    port: 3000,
+  },
+  build: {
+    target: 'bun',
+  },
+  plugins: [
+${tailwindPlugin}
+  ],
+});
+`.trim();
+}
+function generateEnvFile() {
+  return `# Environment Variables
+# Prefix with EREO_PUBLIC_ to expose to the client
+
+# Server-only (never sent to browser)
+DATABASE_URL=postgresql://localhost:5432/mydb
+API_SECRET=your-secret-key
+
+# Public (available in client code)
+EREO_PUBLIC_APP_NAME=EreoJS App
+EREO_PUBLIC_API_URL=http://localhost:3000/api
+`.trim();
+}
+function generateRootLayout(template, typescript) {
+  const imports = typescript ? `import type { ReactNode } from 'react';
+import { Link } from '@ereo/client';` : `import { Link } from '@ereo/client';`;
+  const propsType = typescript ? ": { children: ReactNode }" : "";
+  const tailwindStyles = template === "tailwind";
+  const navClasses = tailwindStyles ? ' className="flex gap-4 p-4 border-b border-gray-200 dark:border-gray-700"' : "";
+  const linkClasses = tailwindStyles ? ' className="text-blue-600 hover:text-blue-800 dark:text-blue-400"' : "";
+  const bodyClasses = tailwindStyles ? ' className="min-h-screen bg-white dark:bg-gray-900 text-gray-900 dark:text-white"' : "";
+  const stylesheet = tailwindStyles ? `
+        <link rel="stylesheet" href="/app/globals.css" />` : "";
+  return `${imports}
+
+export default function RootLayout({ children }${propsType}) {
+  return (
+    <html lang="en">
+      <head>
+        <meta charSet="utf-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />${stylesheet}
+      </head>
+      <body${bodyClasses}>
+        <nav${navClasses}>
+          <Link to="/"${linkClasses}>Home</Link>
+          <Link to="/about"${linkClasses}>About</Link>
+          <Link to="/blog"${linkClasses}>Blog</Link>
+          <Link to="/contact"${linkClasses}>Contact</Link>
+        </nav>
+        {children}
+        {/* Client-side hydration script - bundled by EreoJS */}
+        <script type="module" src="/@ereo/client-entry.js" />
+      </body>
+    </html>
+  );
+}
+`.trim();
+}
+function generateClientEntry(typescript) {
+  return `/**
+ * Client Entry Point
+ *
+ * This file initializes the client-side runtime:
+ * - Hydrates island components
+ * - Sets up client-side navigation
+ * - Enables link prefetching
+ */
+import { initClient } from '@ereo/client';
+
+// Initialize the EreoJS client runtime
+initClient();
+
+// You can also manually hydrate specific islands:
+// import { hydrateIslands } from '@ereo/client';
+// hydrateIslands();
+`.trim();
+}
+function generateIndexPage(template, typescript) {
+  const imports = typescript ? `import type { LoaderArgs, MetaArgs, RouteConfig } from '@ereo/core';
+import { Counter } from '../components/Counter';` : `import { Counter } from '../components/Counter';`;
+  const loaderType = typescript ? ": LoaderArgs" : "";
+  const loaderDataType = `{ message: string; timestamp: string; visitors: number }`;
+  const metaType = typescript ? `: MetaArgs<${loaderDataType}>` : "";
+  const tailwindStyles = template === "tailwind";
+  const mainClasses = tailwindStyles ? ' className="flex flex-col items-center justify-center min-h-[80vh] p-8"' : "";
+  const h1Classes = tailwindStyles ? ' className="text-4xl font-bold mb-4"' : "";
+  const pClasses = tailwindStyles ? ' className="text-gray-600 dark:text-gray-400 mb-2"' : "";
+  const sectionClasses = tailwindStyles ? ' className="mt-8 p-6 border border-gray-200 dark:border-gray-700 rounded-lg"' : "";
+  const h2Classes = tailwindStyles ? ' className="text-xl font-semibold mb-4"' : "";
+  const configType = typescript ? ": RouteConfig" : "";
+  return `${imports}
+
+/**
+ * Route Configuration
+ *
+ * Export a config object to configure middleware, caching,
+ * rendering mode, and other route-level settings.
+ */
+export const config${configType} = {
+  // Apply middleware to this route
+  middleware: ['logger'],
+  // Cache configuration
+  cache: {
+    edge: {
+      maxAge: 60,
+      staleWhileRevalidate: 300,
+    },
+    data: {
+      tags: ['homepage', 'content'],
+    },
+  },
+};
+
+/**
+ * Loader - Server-side data fetching
+ *
+ * Runs on the server for every request. Use context.cache
+ * for explicit cache control with tagged invalidation.
+ */
+export async function loader({ request, params, context }${loaderType}) {
+  // Access environment variables
+  const appName = context.env.EREO_PUBLIC_APP_NAME || 'EreoJS App';
+
+  return {
+    message: \`Welcome to \${appName}!\`,
+    timestamp: new Date().toISOString(),
+    visitors: Math.floor(Math.random() * 1000),
+  };
+}
+
+/**
+ * Meta - Dynamic SEO metadata
+ *
+ * Generate meta tags based on loader data.
+ */
+export function meta({ data }${metaType}) {
+  return [
+    { title: data.message },
+    { name: 'description', content: 'A blazing fast React framework built on Bun' },
+    { property: 'og:title', content: data.message },
+  ];
+}
+
+/**
+ * Page Component
+ *
+ * Receives loaderData from the loader function.
+ * For client components, use useLoaderData() hook from @ereo/client.
+ */
+export default function HomePage({ loaderData }${typescript ? `: { loaderData: ${loaderDataType} }` : ""}) {
+  return (
+    <main${mainClasses}>
+      <h1${h1Classes}>
+        {loaderData.message}
+      </h1>
+      <p${pClasses}>
+        Server time: {loaderData.timestamp}
+      </p>
+      <p${pClasses}>
+        Today's visitors: {loaderData.visitors}
+      </p>
+
+      {/* Islands Architecture Example */}
+      <section${sectionClasses}>
+        <h2${h2Classes}>Interactive Island</h2>
+        <p${pClasses}>
+          This counter is an "island" - only this component hydrates on the client.
+          The rest of the page stays static HTML with zero JavaScript.
+        </p>
+        {/* client:load hydrates immediately */}
+        <Counter client:load initialCount={0} />
+      </section>
+    </main>
+  );
+}
+`.trim();
+}
+function generateAboutPage(template, typescript) {
+  const imports = typescript ? `import type { MetaFunction } from '@ereo/core';` : "";
+  const tailwindStyles = template === "tailwind";
+  const mainClasses = tailwindStyles ? ' className="flex flex-col items-center justify-center min-h-[80vh] p-8"' : "";
+  const h1Classes = tailwindStyles ? ' className="text-4xl font-bold mb-4"' : "";
+  const pClasses = tailwindStyles ? ' className="text-gray-600 dark:text-gray-400 max-w-2xl text-center"' : "";
+  const ulClasses = tailwindStyles ? ' className="mt-6 space-y-2 text-left"' : "";
+  const liClasses = tailwindStyles ? ' className="flex items-center gap-2"' : "";
+  const metaExport = typescript ? `
+/**
+ * Static meta tags for this page
+ */
+export const meta: MetaFunction = () => {
+  return [
+    { title: 'About - EreoJS App' },
+    { name: 'description', content: 'Learn about the EreoJS framework' },
+  ];
+};
+` : `
+/**
+ * Static meta tags for this page
+ */
+export function meta() {
+  return [
+    { title: 'About - EreoJS App' },
+    { name: 'description', content: 'Learn about the EreoJS framework' },
+  ];
+}
+`;
+  return `${imports}
+${metaExport}
+/**
+ * About Page - Static content (no loader needed)
+ *
+ * Pages without loaders are rendered as static HTML.
+ */
+export default function AboutPage() {
+  return (
+    <main${mainClasses}>
+      <h1${h1Classes}>
+        About EreoJS
+      </h1>
+      <p${pClasses}>
+        EreoJS is a React fullstack framework built on Bun, designed for
+        simplicity and performance. It features islands architecture for
+        minimal JavaScript and explicit caching for predictable behavior.
+      </p>
+      <ul${ulClasses}>
+        <li${liClasses}>
+          <span>5-6x faster than Node.js</span>
+        </li>
+        <li${liClasses}>
+          <span>Islands architecture for minimal JS</span>
+        </li>
+        <li${liClasses}>
+          <span>One unified loader pattern</span>
+        </li>
+        <li${liClasses}>
+          <span>Explicit tagged cache invalidation</span>
+        </li>
+      </ul>
+    </main>
+  );
+}
+`.trim();
+}
+function generateContactPage(template, typescript) {
+  const imports = typescript ? `import type { ActionArgs, LoaderArgs, RouteConfig } from '@ereo/core';
+import { json } from '@ereo/data';
+import { Form, useActionData, useNavigation } from '@ereo/client';` : `import { json } from '@ereo/data';
+import { Form, useActionData, useNavigation } from '@ereo/client';`;
+  const loaderType = typescript ? ": LoaderArgs" : "";
+  const actionType = typescript ? ": ActionArgs" : "";
+  const propsType = typescript ? ": { loaderData: { csrfToken: string } }" : "";
+  const actionDataType = typescript ? `
+interface ActionData {
+  success: boolean;
+  message?: string;
+  errors?: Record<string, string>;
+}` : "";
+  const tailwindStyles = template === "tailwind";
+  const mainClasses = tailwindStyles ? ' className="flex flex-col items-center justify-center min-h-[80vh] p-8"' : "";
+  const h1Classes = tailwindStyles ? ' className="text-4xl font-bold mb-4"' : "";
+  const formClasses = tailwindStyles ? ' className="w-full max-w-md space-y-4"' : "";
+  const labelClasses = tailwindStyles ? ' className="block text-sm font-medium mb-1"' : "";
+  const inputClasses = tailwindStyles ? ' className="w-full px-3 py-2 border border-gray-300 dark:border-gray-600 rounded-md bg-white dark:bg-gray-800"' : "";
+  const textareaClasses = tailwindStyles ? ' className="w-full px-3 py-2 border border-gray-300 dark:border-gray-600 rounded-md bg-white dark:bg-gray-800 h-32"' : "";
+  const buttonClasses = tailwindStyles ? ' className="w-full px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700"' : "";
+  const errorClasses = tailwindStyles ? ' className="text-red-600 dark:text-red-400 text-sm mt-1"' : "";
+  const successClasses = tailwindStyles ? ' className="bg-green-100 dark:bg-green-900 text-green-800 dark:text-green-200 p-4 rounded-md mb-4"' : "";
+  return `${imports}
+${actionDataType}
+
+/**
+ * Route Configuration
+ */
+export const config${typescript ? ": RouteConfig" : ""} = {
+  // Progressive enhancement - form works without JS
+  progressive: {
+    forms: {
+      fallback: 'server',
+    },
+  },
+};
+
+/**
+ * Loader - Provide CSRF token for form security
+ */
+export async function loader({ context }${loaderType}) {
+  return {
+    csrfToken: crypto.randomUUID(),
+  };
+}
+
+/**
+ * Action - Handle form submission
+ *
+ * Actions handle POST/PUT/DELETE requests.
+ * Use json() for responses, redirect() for redirects.
+ */
+export async function action({ request, context }${actionType})${typescript ? ": Promise<Response>" : ""} {
+  const formData = await request.formData();
+
+  const name = formData.get('name') as string;
+  const email = formData.get('email') as string;
+  const message = formData.get('message') as string;
+
+  // Validate
+  const errors${typescript ? ": Record<string, string>" : ""} = {};
+  if (!name || name.length < 2) {
+    errors.name = 'Name must be at least 2 characters';
+  }
+  if (!email || !email.includes('@')) {
+    errors.email = 'Please enter a valid email';
+  }
+  if (!message || message.length < 10) {
+    errors.message = 'Message must be at least 10 characters';
+  }
+
+  if (Object.keys(errors).length > 0) {
+    return json({ success: false, errors }, { status: 400 });
+  }
+
+  // Process the submission (e.g., send email, save to DB)
+  console.log('Contact form submitted:', { name, email, message });
+
+  // Return success or redirect
+  return json({ success: true, message: 'Thank you for your message!' });
+}
+
+/**
+ * Contact Page with Enhanced Form
+ *
+ * Uses the Form component from @ereo/client for:
+ * - Automatic loading states
+ * - Client-side validation feedback
+ * - Progressive enhancement (works without JS)
+ *
+ * The useActionData hook provides access to the action response.
+ * The useNavigation hook provides loading state.
+ */
+export default function ContactPage({ loaderData }${propsType}) {
+  // Get action response data (available after form submission)
+  const actionData = useActionData${typescript ? "<ActionData>" : ""}();
+  // Get navigation state for loading indicator
+  const navigation = useNavigation();
+  const isSubmitting = navigation.state === 'submitting';
+
+  return (
+    <main${mainClasses}>
+      <h1${h1Classes}>Contact Us</h1>
+
+      {actionData?.success && (
+        <div${successClasses}>
+          {actionData.message}
+        </div>
+      )}
+
+      <Form method="post"${formClasses}>
+        <input type="hidden" name="csrf" value={loaderData.csrfToken} />
+
+        <div>
+          <label htmlFor="name"${labelClasses}>Name</label>
+          <input
+            type="text"
+            id="name"
+            name="name"
+            required${inputClasses}
+            aria-invalid={actionData?.errors?.name ? 'true' : undefined}
+          />
+          {actionData?.errors?.name && (
+            <p${errorClasses}>{actionData.errors.name}</p>
+          )}
+        </div>
+
+        <div>
+          <label htmlFor="email"${labelClasses}>Email</label>
+          <input
+            type="email"
+            id="email"
+            name="email"
+            required${inputClasses}
+            aria-invalid={actionData?.errors?.email ? 'true' : undefined}
+          />
+          {actionData?.errors?.email && (
+            <p${errorClasses}>{actionData.errors.email}</p>
+          )}
+        </div>
+
+        <div>
+          <label htmlFor="message"${labelClasses}>Message</label>
+          <textarea
+            id="message"
+            name="message"
+            required${textareaClasses}
+            aria-invalid={actionData?.errors?.message ? 'true' : undefined}
+          />
+          {actionData?.errors?.message && (
+            <p${errorClasses}>{actionData.errors.message}</p>
+          )}
+        </div>
+
+        <button type="submit" disabled={isSubmitting}${buttonClasses}>
+          {isSubmitting ? 'Sending...' : 'Send Message'}
+        </button>
+      </Form>
+    </main>
+  );
+}
+`.trim();
+}
+function generateCounterComponent(template, typescript) {
+  const propsType = typescript ? ": { initialCount?: number }" : "";
+  const tailwindStyles = template === "tailwind";
+  const containerClasses = tailwindStyles ? ' className="flex items-center gap-4 mt-4"' : "";
+  const buttonClasses = tailwindStyles ? ' className="px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700"' : "";
+  const countClasses = tailwindStyles ? ' className="text-2xl font-bold min-w-[3ch] text-center"' : "";
+  return `'use client';
+/**
+ * Counter Component - Island Example
+ *
+ * This component demonstrates the islands architecture.
+ * Only components with 'use client' directive hydrate on the client.
+ *
+ * Hydration strategies:
+ * - client:load   - Hydrate immediately on page load
+ * - client:idle   - Hydrate when browser is idle
+ * - client:visible - Hydrate when element is visible (IntersectionObserver)
+ * - client:media  - Hydrate when media query matches
+ *
+ * Usage:
+ *   <Counter client:load initialCount={0} />
+ *   <Counter client:visible initialCount={5} />
+ */
+import { useState } from 'react';
+
+export function Counter({ initialCount = 0 }${propsType}) {
+  const [count, setCount] = useState(initialCount);
+
+  return (
+    <div${containerClasses}>
+      <button onClick={() => setCount(c => c - 1)}${buttonClasses}>
+        -
+      </button>
+      <span${countClasses}>{count}</span>
+      <button onClick={() => setCount(c => c + 1)}${buttonClasses}>
+        +
+      </button>
+    </div>
+  );
+}
+`.trim();
+}
+function generateLoggerMiddleware(typescript) {
+  const imports = typescript ? `import type { MiddlewareHandler } from '@ereo/core';` : "";
+  const typeAnnotation = typescript ? ": MiddlewareHandler" : "";
+  return `${imports}
+/**
+ * Logger Middleware
+ *
+ * Logs request information and timing.
+ *
+ * Register in ereo.config.ts or use the route config:
+ *
+ * export const config = {
+ *   middleware: ['logger'],
+ * };
+ */
+export const logger${typeAnnotation} = async (request, context, next) => {
+  const start = Date.now();
+  const url = new URL(request.url);
+
+  console.log(\`--> \${request.method} \${url.pathname}\`);
+
+  // Call next middleware/handler
+  const response = await next();
+
+  const duration = Date.now() - start;
+  console.log(\`<-- \${request.method} \${url.pathname} \${response.status} \${duration}ms\`);
+
+  return response;
+};
+
+export default logger;
+`.trim();
+}
+function generateErrorBoundary(template, typescript) {
+  const imports = typescript ? `import type { RouteErrorComponentProps } from '@ereo/core';
+import { Link } from '@ereo/client';
+import { isRouteErrorResponse } from '@ereo/client';` : `import { Link } from '@ereo/client';
+import { isRouteErrorResponse } from '@ereo/client';`;
+  const propsType = typescript ? ": RouteErrorComponentProps" : "";
+  const tailwindStyles = template === "tailwind";
+  const mainClasses = tailwindStyles ? ' className="flex flex-col items-center justify-center min-h-[80vh] p-8"' : "";
+  const h1Classes = tailwindStyles ? ' className="text-4xl font-bold text-red-600 mb-4"' : "";
+  const pClasses = tailwindStyles ? ' className="text-gray-600 dark:text-gray-400 mb-4"' : "";
+  const preClasses = tailwindStyles ? ' className="p-4 bg-gray-100 dark:bg-gray-800 rounded-md overflow-auto max-w-2xl text-sm"' : "";
+  const linkClasses = tailwindStyles ? ' className="mt-6 px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700 inline-block"' : "";
+  const statusClasses = tailwindStyles ? ' className="text-6xl font-bold text-gray-300 dark:text-gray-600 mb-4"' : "";
+  return `${imports}
+
+/**
+ * Error Boundary Page
+ *
+ * This component renders when an error occurs in a route.
+ * It receives the error and route params.
+ *
+ * Error types:
+ * - Response errors (404, 500, etc.) - thrown via \`throw new Response()\`
+ * - JavaScript errors - unexpected exceptions
+ *
+ * File naming:
+ * - _error.tsx  - Catches errors in current route and children
+ * - error.tsx   - Same as above (alternative naming)
+ *
+ * The error boundary closest to the error will be used.
+ */
+export default function ErrorBoundary({ error, params }${propsType}) {
+  // Check if this is a Response error (e.g., 404)
+  if (isRouteErrorResponse(error)) {
+    return (
+      <main${mainClasses}>
+        <div${statusClasses}>{error.status}</div>
+        <h1${h1Classes}>
+          {error.status === 404 ? 'Page Not Found' : 'Error'}
+        </h1>
+        <p${pClasses}>
+          {error.status === 404
+            ? "The page you're looking for doesn't exist."
+            : error.statusText || 'An error occurred.'}
+        </p>
+        <Link to="/"${linkClasses}>
+          Go back home
+        </Link>
+      </main>
+    );
+  }
+
+  // JavaScript/runtime error
+  return (
+    <main${mainClasses}>
+      <h1${h1Classes}>Something went wrong</h1>
+      <p${pClasses}>
+        We're sorry, but an error occurred while processing your request.
+      </p>
+
+      {process.env.NODE_ENV === 'development' && (
+        <pre${preClasses}>
+          <code>{error.message}</code>
+          {error.stack && (
+            <>
+              {'\\n\\n'}
+              {error.stack}
+            </>
+          )}
+        </pre>
+      )}
+
+      <Link to="/"${linkClasses}>
+        Go back home
+      </Link>
+    </main>
+  );
+}
+`.trim();
+}
+function generateTailwindConfig() {
+  return `/** @type {import('tailwindcss').Config} */
+export default {
+  content: [
+    './app/**/*.{js,ts,jsx,tsx}',
+    './components/**/*.{js,ts,jsx,tsx}',
+  ],
+  darkMode: 'class',
+  theme: {
+    extend: {
+      // Add your custom theme extensions here
+    },
+  },
+  plugins: [],
+};
+`.trim();
+}
+function generateGlobalCSS() {
+  return `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+/* Custom global styles */
+@layer base {
+  html {
+    @apply antialiased;
+  }
+
+  body {
+    @apply bg-white dark:bg-gray-900 text-gray-900 dark:text-white;
+  }
+}
+
+@layer components {
+  /* Add reusable component styles here */
+}
+
+@layer utilities {
+  /* Add custom utilities here */
+}
+`.trim();
+}
+function generateGitignore() {
+  return `# Dependencies
+node_modules
+
+# Build output
+.ereo
+dist
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# Logs
+*.log
+npm-debug.log*
+
+# OS
+.DS_Store
+Thumbs.db
+
+# IDE
+.vscode
+.idea
+*.swp
+*.swo
+
+# Bun
+bun.lockb
+`.trim();
+}
+function generateDynamicRoute(template, typescript) {
+  const imports = typescript ? `import type { LoaderArgs, MetaArgs, RouteConfig } from '@ereo/core';
+import { Link } from '@ereo/client';` : `import { Link } from '@ereo/client';`;
+  const loaderType = typescript ? ": LoaderArgs" : "";
+  const configType = typescript ? ": RouteConfig" : "";
+  const postType = typescript ? `
+interface Post {
+  slug: string;
+  title: string;
+  content: string;
+  author: string;
+  publishedAt: string;
+}` : "";
+  const metaType = typescript ? ": MetaArgs<Post>" : "";
+  const propsType = typescript ? ": { loaderData: Post }" : "";
+  const tailwindStyles = template === "tailwind";
+  const articleClasses = tailwindStyles ? ' className="max-w-3xl mx-auto p-8"' : "";
+  const backLinkClasses = tailwindStyles ? ' className="text-blue-600 hover:text-blue-800 dark:text-blue-400 mb-6 inline-block"' : "";
+  const h1Classes = tailwindStyles ? ' className="text-4xl font-bold mb-4"' : "";
+  const metaClasses = tailwindStyles ? ' className="text-gray-500 dark:text-gray-400 mb-8"' : "";
+  const contentClasses = tailwindStyles ? ' className="prose dark:prose-invert max-w-none"' : "";
+  return `${imports}
+${postType}
+
+/**
+ * Route Configuration for dynamic routes
+ *
+ * Cache by slug parameter for efficient CDN caching.
+ */
+export const config${configType} = {
+  cache: {
+    edge: {
+      maxAge: 3600,
+      staleWhileRevalidate: 86400,
+    },
+    data: {
+      // Dynamic tags based on the slug parameter
+      tags: (params) => ['blog', \`post:\${params.slug}\`],
+    },
+  },
+};
+
+/**
+ * Loader - Fetch blog post by slug
+ *
+ * The slug parameter comes from the [slug] in the filename.
+ * Access via params.slug.
+ */
+export async function loader({ params, context }${loaderType})${typescript ? ": Promise<Post>" : ""} {
+  const { slug } = params;
+
+  // In a real app, fetch from database or CMS
+  // Example: const post = await db.posts.findBySlug(slug);
+
+  // Mock data for demonstration
+  const posts${typescript ? ": Record<string, Post>" : ""} = {
+    'hello-world': {
+      slug: 'hello-world',
+      title: 'Hello World',
+      content: 'This is the first blog post using EreoJS framework. It demonstrates dynamic routing with [slug] parameters.',
+      author: 'EreoJS Team',
+      publishedAt: '2024-01-15',
+    },
+    'getting-started': {
+      slug: 'getting-started',
+      title: 'Getting Started with EreoJS',
+      content: 'Learn how to build blazing fast applications with EreoJS and Bun. This guide covers loaders, actions, and islands architecture.',
+      author: 'EreoJS Team',
+      publishedAt: '2024-01-20',
+    },
+  };
+
+  const post = posts[slug${typescript ? " as string" : ""}];
+
+  if (!post) {
+    throw new Response('Post not found', { status: 404 });
+  }
+
+  return post;
+}
+
+/**
+ * Meta - Generate SEO tags from post data
+ */
+export function meta({ data }${metaType}) {
+  return [
+    { title: \`\${data.title} - Blog\` },
+    { name: 'description', content: data.content.slice(0, 160) },
+    { property: 'og:title', content: data.title },
+    { property: 'og:type', content: 'article' },
+    { property: 'article:author', content: data.author },
+    { property: 'article:published_time', content: data.publishedAt },
+  ];
+}
+
+/**
+ * Blog Post Page
+ */
+export default function BlogPost({ loaderData: post }${propsType}) {
+  return (
+    <article${articleClasses}>
+      <Link to="/blog"${backLinkClasses}>
+        \u2190 Back to Blog
+      </Link>
+
+      <h1${h1Classes}>{post.title}</h1>
+
+      <div${metaClasses}>
+        By {post.author} \u2022 {new Date(post.publishedAt).toLocaleDateString()}
+      </div>
+
+      <div${contentClasses}>
+        <p>{post.content}</p>
+      </div>
+    </article>
+  );
+}
+`.trim();
+}
+function generateBlogIndex(template, typescript) {
+  const imports = typescript ? `import type { LoaderArgs, MetaArgs } from '@ereo/core';
+import { Link } from '@ereo/client';` : `import { Link } from '@ereo/client';`;
+  const loaderType = typescript ? ": LoaderArgs" : "";
+  const postType = typescript ? `
+interface PostSummary {
+  slug: string;
+  title: string;
+  excerpt: string;
+  publishedAt: string;
+}` : "";
+  const metaType = typescript ? ": MetaArgs<PostSummary[]>" : "";
+  const propsType = typescript ? ": { loaderData: PostSummary[] }" : "";
+  const tailwindStyles = template === "tailwind";
+  const mainClasses = tailwindStyles ? ' className="max-w-3xl mx-auto p-8"' : "";
+  const h1Classes = tailwindStyles ? ' className="text-4xl font-bold mb-8"' : "";
+  const listClasses = tailwindStyles ? ' className="space-y-6"' : "";
+  const cardClasses = tailwindStyles ? ' className="border border-gray-200 dark:border-gray-700 rounded-lg p-6 hover:shadow-lg transition-shadow"' : "";
+  const titleClasses = tailwindStyles ? ' className="text-xl font-semibold text-blue-600 dark:text-blue-400 hover:underline"' : "";
+  const dateClasses = tailwindStyles ? ' className="text-sm text-gray-500 dark:text-gray-400 mt-1"' : "";
+  const excerptClasses = tailwindStyles ? ' className="text-gray-600 dark:text-gray-300 mt-2"' : "";
+  return `${imports}
+${postType}
+
+/**
+ * Meta - Blog listing page
+ */
+export function meta() {
+  return [
+    { title: 'Blog - EreoJS App' },
+    { name: 'description', content: 'Read our latest blog posts' },
+  ];
+}
+
+/**
+ * Loader - Fetch all blog posts
+ */
+export async function loader({ context }${loaderType})${typescript ? ": Promise<PostSummary[]>" : ""} {
+  // Set cache for the listing page
+  context.cache.set({
+    maxAge: 300,
+    tags: ['blog', 'blog-list'],
+  });
+
+  // In a real app, fetch from database
+  // Example: const posts = await db.posts.findMany({ orderBy: { publishedAt: 'desc' } });
+
+  return [
+    {
+      slug: 'getting-started',
+      title: 'Getting Started with EreoJS',
+      excerpt: 'Learn how to build blazing fast applications with EreoJS and Bun.',
+      publishedAt: '2024-01-20',
+    },
+    {
+      slug: 'hello-world',
+      title: 'Hello World',
+      excerpt: 'This is the first blog post using EreoJS framework.',
+      publishedAt: '2024-01-15',
+    },
+  ];
+}
+
+/**
+ * Blog Index Page
+ */
+export default function BlogIndex({ loaderData: posts }${propsType}) {
+  return (
+    <main${mainClasses}>
+      <h1${h1Classes}>Blog</h1>
+
+      <ul${listClasses}>
+        {posts.map((post) => (
+          <li key={post.slug}${cardClasses}>
+            <Link to={\`/blog/\${post.slug}\`}${titleClasses}>
+              {post.title}
+            </Link>
+            <p${dateClasses}>
+              {new Date(post.publishedAt).toLocaleDateString()}
+            </p>
+            <p${excerptClasses}>{post.excerpt}</p>
+          </li>
+        ))}
+      </ul>
+    </main>
+  );
+}
+`.trim();
+}
+function generateApiRoute(typescript) {
+  const typeAnnotations = typescript ? `
+interface HealthResponse {
+  status: 'ok' | 'error';
+  timestamp: string;
+  version: string;
+  uptime: number;
+}
+` : "";
+  const loaderType = typescript ? ": LoaderArgs" : "";
+  const returnType = typescript ? ": Promise<Response>" : "";
+  return `/**
+ * API Route Example - /api/health
+ *
+ * API routes return Response objects directly.
+ * They don't render React components.
+ *
+ * Common patterns:
+ * - GET  /api/health     -> Health check
+ * - GET  /api/users      -> List users
+ * - POST /api/users      -> Create user
+ * - GET  /api/users/[id] -> Get user by ID
+ */
+import type { LoaderArgs, ActionArgs } from '@ereo/core';
+import { json } from '@ereo/data';
+${typeAnnotations}
+const startTime = Date.now();
+
+/**
+ * GET /api/health
+ *
+ * Health check endpoint for monitoring and load balancers.
+ */
+export async function loader({ request, context }${loaderType})${returnType} {
+  const health${typescript ? ": HealthResponse" : ""} = {
+    status: 'ok',
+    timestamp: new Date().toISOString(),
+    version: '0.1.0',
+    uptime: Math.floor((Date.now() - startTime) / 1000),
+  };
+
+  return json(health, {
+    headers: {
+      'Cache-Control': 'no-cache, no-store, must-revalidate',
+    },
+  });
+}
+
+/**
+ * POST /api/health
+ *
+ * Example of handling POST requests in API routes.
+ * Use this pattern for webhooks, form submissions, etc.
+ */
+export async function action({ request, context }${typescript ? ": ActionArgs" : ""})${returnType} {
+  // Only allow POST
+  if (request.method !== 'POST') {
+    return json(
+      { error: 'Method not allowed' },
+      { status: 405 }
+    );
+  }
+
+  // Parse request body
+  const body = await request.json().catch(() => ({}));
+
+  // Example: Log the health check ping
+  console.log('Health check ping received:', body);
+
+  return json({ received: true, timestamp: new Date().toISOString() });
+}
+`.trim();
+}
+
+// src/commands/deploy.ts
+import { join as join5 } from "path";
+async function deploy(options = {}) {
+  const root = process.cwd();
+  const target = options.target || await detectTarget(root);
+  console.log(`
+  \x1B[36m\u2B21\x1B[0m \x1B[1mEreo\x1B[0m Deploy
+`);
+  console.log(`  Target: \x1B[33m${target}\x1B[0m
+`);
+  let config = {};
+  const configPath = join5(root, "ereo.config.ts");
+  try {
+    if (await Bun.file(configPath).exists()) {
+      const configModule = await import(configPath);
+      config = configModule.default || configModule;
+    }
+  } catch (error) {
+    console.warn("Could not load config:", error);
+  }
+  if (options.build !== false) {
+    console.log("  \x1B[2mBuilding for production...\x1B[0m");
+    const { build: build2 } = await Promise.resolve().then(() => (init_build(), exports_build));
+    await build2({ production: true });
+    console.log(`  \x1B[32m\u2713\x1B[0m Build complete
+`);
+  }
+  if (options.dryRun) {
+    console.log(`  \x1B[33m\u26A0\x1B[0m Dry run - skipping actual deployment
+`);
+    return generateDeployPreview(target, root, config);
+  }
+  try {
+    switch (target) {
+      case "vercel":
+        return await deployToVercel(root, options);
+      case "cloudflare":
+        return await deployToCloudflare(root, options);
+      case "fly":
+        return await deployToFly(root, options);
+      case "netlify":
+        return await deployToNetlify(root, options);
+      case "docker":
+        return await deployToDocker(root, options);
+      default:
+        return {
+          success: false,
+          error: `Unknown deployment target: ${target}`
+        };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function detectTarget(root) {
+  if (await Bun.file(join5(root, "vercel.json")).exists()) {
+    return "vercel";
+  }
+  if (await Bun.file(join5(root, "wrangler.toml")).exists()) {
+    return "cloudflare";
+  }
+  if (await Bun.file(join5(root, "fly.toml")).exists()) {
+    return "fly";
+  }
+  if (await Bun.file(join5(root, "netlify.toml")).exists()) {
+    return "netlify";
+  }
+  if (await Bun.file(join5(root, "Dockerfile")).exists()) {
+    return "docker";
+  }
+  return "vercel";
+}
+function generateDeployPreview(target, root, config) {
+  const logs = [];
+  logs.push(`Would deploy to ${target}`);
+  logs.push(`Project root: ${root}`);
+  logs.push(`Build target: ${config.build?.target || "bun"}`);
+  logs.push(`Output directory: ${config.build?.outDir || "dist"}`);
+  console.log("  Preview:");
+  for (const log of logs) {
+    console.log(`    ${log}`);
+  }
+  console.log("");
+  return {
+    success: true,
+    logs
+  };
+}
+async function deployToVercel(root, options) {
+  console.log(`  Deploying to Vercel...
+`);
+  const hasVercelCLI = await checkCommand("vercel");
+  if (!hasVercelCLI) {
+    console.log(`  \x1B[33m\u26A0\x1B[0m Vercel CLI not found. Installing...
+`);
+    await runCommand("bun", ["add", "-g", "vercel"]);
+  }
+  const vercelConfigPath = join5(root, "vercel.json");
+  if (!await Bun.file(vercelConfigPath).exists()) {
+    const vercelConfig = {
+      buildCommand: "bun run build",
+      outputDirectory: "dist",
+      framework: null,
+      functions: {
+        "api/**/*.ts": {
+          runtime: "@vercel/bun@0.1.0"
+        }
+      }
+    };
+    await Bun.write(vercelConfigPath, JSON.stringify(vercelConfig, null, 2));
+    console.log(`  \x1B[32m\u2713\x1B[0m Generated vercel.json
+`);
+  }
+  const args = ["deploy"];
+  if (options.production) {
+    args.push("--prod");
+  }
+  if (options.name) {
+    args.push("--name", options.name);
+  }
+  const result = await runCommandWithOutput("vercel", args, root);
+  if (result.success) {
+    const urlMatch = result.output.match(/https:\/\/[^\s]+\.vercel\.app/);
+    const url = urlMatch ? urlMatch[0] : undefined;
+    console.log(`
+  \x1B[32m\u2713\x1B[0m Deployed successfully!`);
+    if (url) {
+      console.log(`  \x1B[36m\u279C\x1B[0m ${url}
+`);
+    }
+    return {
+      success: true,
+      url,
+      logs: [result.output]
+    };
+  }
+  return {
+    success: false,
+    error: result.error || "Deployment failed",
+    logs: [result.output]
+  };
+}
+async function deployToCloudflare(root, options) {
+  console.log(`  Deploying to Cloudflare...
+`);
+  const hasWrangler = await checkCommand("wrangler");
+  if (!hasWrangler) {
+    console.log(`  \x1B[33m\u26A0\x1B[0m Wrangler CLI not found. Installing...
+`);
+    await runCommand("bun", ["add", "-g", "wrangler"]);
+  }
+  const wranglerConfigPath = join5(root, "wrangler.toml");
+  if (!await Bun.file(wranglerConfigPath).exists()) {
+    const projectName = options.name || "ereo-app";
+    const wranglerConfig = `name = "${projectName}"
+main = "dist/server/index.js"
+compatibility_date = "2024-01-01"
+
+[site]
+bucket = "./dist/client"
+
+[build]
+command = "bun run build"
+`;
+    await Bun.write(wranglerConfigPath, wranglerConfig);
+    console.log(`  \x1B[32m\u2713\x1B[0m Generated wrangler.toml
+`);
+  }
+  const result = await runCommandWithOutput("wrangler", ["deploy"], root);
+  if (result.success) {
+    const urlMatch = result.output.match(/https:\/\/[^\s]+\.workers\.dev/);
+    const url = urlMatch ? urlMatch[0] : undefined;
+    console.log(`
+  \x1B[32m\u2713\x1B[0m Deployed successfully!`);
+    if (url) {
+      console.log(`  \x1B[36m\u279C\x1B[0m ${url}
+`);
+    }
+    return {
+      success: true,
+      url,
+      logs: [result.output]
+    };
+  }
+  return {
+    success: false,
+    error: result.error || "Deployment failed",
+    logs: [result.output]
+  };
+}
+async function deployToFly(root, options) {
+  console.log(`  Deploying to Fly.io...
+`);
+  const hasFly = await checkCommand("flyctl");
+  if (!hasFly) {
+    console.log("  \x1B[33m\u26A0\x1B[0m Fly CLI not found.");
+    console.log(`  Install from: https://fly.io/docs/hands-on/install-flyctl/
+`);
+    return {
+      success: false,
+      error: "Fly CLI not installed"
+    };
+  }
+  const flyConfigPath = join5(root, "fly.toml");
+  if (!await Bun.file(flyConfigPath).exists()) {
+    const projectName = options.name || "ereo-app";
+    const flyConfig = `app = "${projectName}"
+primary_region = "iad"
+
+[build]
+  builder = "oven/bun"
+
+[http_service]
+  internal_port = 3000
+  force_https = true
+  auto_stop_machines = true
+  auto_start_machines = true
+  min_machines_running = 0
+`;
+    await Bun.write(flyConfigPath, flyConfig);
+    console.log(`  \x1B[32m\u2713\x1B[0m Generated fly.toml
+`);
+  }
+  const result = await runCommandWithOutput("flyctl", ["deploy"], root);
+  if (result.success) {
+    const urlMatch = result.output.match(/https:\/\/[^\s]+\.fly\.dev/);
+    const url = urlMatch ? urlMatch[0] : undefined;
+    console.log(`
+  \x1B[32m\u2713\x1B[0m Deployed successfully!`);
+    if (url) {
+      console.log(`  \x1B[36m\u279C\x1B[0m ${url}
+`);
+    }
+    return {
+      success: true,
+      url,
+      logs: [result.output]
+    };
+  }
+  return {
+    success: false,
+    error: result.error || "Deployment failed",
+    logs: [result.output]
+  };
+}
+async function deployToNetlify(root, options) {
+  console.log(`  Deploying to Netlify...
+`);
+  const hasNetlify = await checkCommand("netlify");
+  if (!hasNetlify) {
+    console.log(`  \x1B[33m\u26A0\x1B[0m Netlify CLI not found. Installing...
+`);
+    await runCommand("bun", ["add", "-g", "netlify-cli"]);
+  }
+  const netlifyConfigPath = join5(root, "netlify.toml");
+  if (!await Bun.file(netlifyConfigPath).exists()) {
+    const netlifyConfig = `[build]
+  command = "bun run build"
+  publish = "dist/client"
+  functions = "dist/server"
+
+[functions]
+  node_bundler = "esbuild"
+
+[[redirects]]
+  from = "/api/*"
+  to = "/.netlify/functions/api/:splat"
+  status = 200
+
+[[redirects]]
+  from = "/*"
+  to = "/index.html"
+  status = 200
+`;
+    await Bun.write(netlifyConfigPath, netlifyConfig);
+    console.log(`  \x1B[32m\u2713\x1B[0m Generated netlify.toml
+`);
+  }
+  const args = ["deploy", "--dir=dist/client"];
+  if (options.production) {
+    args.push("--prod");
+  }
+  const result = await runCommandWithOutput("netlify", args, root);
+  if (result.success) {
+    const urlMatch = result.output.match(/https:\/\/[^\s]+\.netlify\.app/);
+    const url = urlMatch ? urlMatch[0] : undefined;
+    console.log(`
+  \x1B[32m\u2713\x1B[0m Deployed successfully!`);
+    if (url) {
+      console.log(`  \x1B[36m\u279C\x1B[0m ${url}
+`);
+    }
+    return {
+      success: true,
+      url,
+      logs: [result.output]
+    };
+  }
+  return {
+    success: false,
+    error: result.error || "Deployment failed",
+    logs: [result.output]
+  };
+}
+async function deployToDocker(root, options) {
+  console.log(`  Building Docker image...
+`);
+  const hasDocker = await checkCommand("docker");
+  if (!hasDocker) {
+    return {
+      success: false,
+      error: "Docker not installed"
+    };
+  }
+  const dockerfilePath = join5(root, "Dockerfile");
+  if (!await Bun.file(dockerfilePath).exists()) {
+    const dockerfile = `# Build stage
+FROM oven/bun:1 as builder
+WORKDIR /app
+COPY package.json bun.lockb* ./
+RUN bun install --frozen-lockfile
+COPY . .
+RUN bun run build
+
+# Production stage
+FROM oven/bun:1-slim
+WORKDIR /app
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/package.json ./
+COPY --from=builder /app/node_modules ./node_modules
+ENV NODE_ENV=production
+EXPOSE 3000
+CMD ["bun", "run", "start"]
+`;
+    await Bun.write(dockerfilePath, dockerfile);
+    console.log(`  \x1B[32m\u2713\x1B[0m Generated Dockerfile
+`);
+  }
+  const imageName = options.name || "ereo-app";
+  const tag = options.production ? "latest" : "dev";
+  const result = await runCommandWithOutput("docker", ["build", "-t", `${imageName}:${tag}`, "."], root);
+  if (result.success) {
+    console.log(`
+  \x1B[32m\u2713\x1B[0m Docker image built: ${imageName}:${tag}`);
+    console.log(`  Run with: docker run -p 3000:3000 ${imageName}:${tag}
+`);
+    return {
+      success: true,
+      deploymentId: `${imageName}:${tag}`,
+      logs: [result.output]
+    };
+  }
+  return {
+    success: false,
+    error: result.error || "Docker build failed",
+    logs: [result.output]
+  };
+}
+async function checkCommand(command) {
+  try {
+    const proc = Bun.spawn(["which", command], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    await proc.exited;
+    return proc.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function runCommand(command, args) {
+  const proc = Bun.spawn([command, ...args], {
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  await proc.exited;
+  return proc.exitCode === 0;
+}
+async function runCommandWithOutput(command, args, cwd) {
+  try {
+    const proc = Bun.spawn([command, ...args], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    await proc.exited;
+    return {
+      success: proc.exitCode === 0,
+      output: stdout,
+      error: stderr || undefined
+    };
+  } catch (error) {
+    return {
+      success: false,
+      output: "",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function printDeployHelp() {
+  console.log(`
+  Usage: ereo deploy [target] [options]
+
+  Targets:
+    vercel       Deploy to Vercel (default)
+    cloudflare   Deploy to Cloudflare Pages/Workers
+    fly          Deploy to Fly.io
+    netlify      Deploy to Netlify
+    docker       Build Docker image
+
+  Options:
+    --prod       Deploy to production
+    --dry-run    Preview deployment without actually deploying
+    --name       Project name for new deployments
+    --no-build   Skip build step
+
+  Examples:
+    ereo deploy                    Deploy to auto-detected platform
+    ereo deploy vercel --prod      Deploy to Vercel production
+    ereo deploy cloudflare         Deploy to Cloudflare
+    ereo deploy docker --name app  Build Docker image named 'app'
+  `);
+}
+
+// src/commands/db.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { resolve, join as join6 } from "path";
+function findDrizzleConfig(customPath) {
+  const cwd = process.cwd();
+  if (customPath) {
+    const absolutePath = resolve(cwd, customPath);
+    if (existsSync(absolutePath)) {
+      return absolutePath;
+    }
+    throw new Error(`Config file not found: ${customPath}`);
+  }
+  const configNames = [
+    "drizzle.config.ts",
+    "drizzle.config.js",
+    "drizzle.config.mjs",
+    "drizzle.config.json"
+  ];
+  for (const name of configNames) {
+    const configPath = join6(cwd, name);
+    if (existsSync(configPath)) {
+      return configPath;
+    }
+  }
+  throw new Error("Drizzle config not found. Create a drizzle.config.ts file or specify --config path.");
+}
+async function runDrizzleKit(command, args = []) {
+  return new Promise((resolve2) => {
+    console.log(`
+  \x1B[36m\u25B6\x1B[0m Running: drizzle-kit ${command} ${args.join(" ")}
+`);
+    const runner = existsSync(join6(process.cwd(), "bun.lockb")) ? "bunx" : "npx";
+    const proc = spawn(runner, ["drizzle-kit", command, ...args], {
+      cwd: process.cwd(),
+      stdio: "inherit",
+      shell: true
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve2({ success: true });
+      } else {
+        resolve2({ success: false, error: `drizzle-kit ${command} failed with exit code ${code}` });
+      }
+    });
+    proc.on("error", (error) => {
+      resolve2({ success: false, error: error.message });
+    });
+  });
+}
+async function dbMigrate(options = {}) {
+  console.log(`
+  \x1B[36m\u2B21\x1B[0m \x1B[1mRunning database migrations...\x1B[0m`);
+  try {
+    const configPath = findDrizzleConfig(options.config);
+    const args = ["--config", configPath];
+    if (options.verbose) {
+      args.push("--verbose");
+    }
+    const result = await runDrizzleKit("migrate", args);
+    if (result.success) {
+      console.log(`
+  \x1B[32m\u2713\x1B[0m Migrations completed successfully
+`);
+    } else {
+      console.error(`
+  \x1B[31m\u2717\x1B[0m ${result.error}
+`);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(`
+  \x1B[31m\u2717\x1B[0m ${error instanceof Error ? error.message : error}
+`);
+    process.exit(1);
+  }
+}
+async function dbGenerate(options) {
+  console.log(`
+  \x1B[36m\u2B21\x1B[0m \x1B[1mGenerating migration...\x1B[0m`);
+  if (!options.name) {
+    console.error(`
+  \x1B[31m\u2717\x1B[0m Migration name is required (--name <name>)
+`);
+    process.exit(1);
+  }
+  try {
+    const configPath = findDrizzleConfig(options.config);
+    const args = ["--config", configPath, "--name", options.name];
+    if (options.out) {
+      args.push("--out", options.out);
+    }
+    const result = await runDrizzleKit("generate", args);
+    if (result.success) {
+      console.log(`
+  \x1B[32m\u2713\x1B[0m Migration "${options.name}" generated successfully
+`);
+    } else {
+      console.error(`
+  \x1B[31m\u2717\x1B[0m ${result.error}
+`);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(`
+  \x1B[31m\u2717\x1B[0m ${error instanceof Error ? error.message : error}
+`);
+    process.exit(1);
+  }
+}
+async function dbStudio(options = {}) {
+  console.log(`
+  \x1B[36m\u2B21\x1B[0m \x1B[1mStarting Drizzle Studio...\x1B[0m`);
+  try {
+    const configPath = findDrizzleConfig(options.config);
+    const args = ["--config", configPath];
+    if (options.port) {
+      args.push("--port", options.port.toString());
+    }
+    const result = await runDrizzleKit("studio", args);
+    if (!result.success) {
+      console.error(`
+  \x1B[31m\u2717\x1B[0m ${result.error}
+`);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(`
+  \x1B[31m\u2717\x1B[0m ${error instanceof Error ? error.message : error}
+`);
+    process.exit(1);
+  }
+}
+async function dbPush(options = {}) {
+  console.log(`
+  \x1B[36m\u2B21\x1B[0m \x1B[1mPushing schema to database...\x1B[0m`);
+  console.log(`  \x1B[33m\u26A0\x1B[0m  This should only be used in development
+`);
+  try {
+    const configPath = findDrizzleConfig(options.config);
+    const args = ["--config", configPath];
+    if (options.force) {
+      args.push("--force");
+    }
+    if (options.verbose) {
+      args.push("--verbose");
+    }
+    const result = await runDrizzleKit("push", args);
+    if (result.success) {
+      console.log(`
+  \x1B[32m\u2713\x1B[0m Schema pushed successfully
+`);
+    } else {
+      console.error(`
+  \x1B[31m\u2717\x1B[0m ${result.error}
+`);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(`
+  \x1B[31m\u2717\x1B[0m ${error instanceof Error ? error.message : error}
+`);
+    process.exit(1);
+  }
+}
+async function dbSeed(options = {}) {
+  console.log(`
+  \x1B[36m\u2B21\x1B[0m \x1B[1mRunning database seeders...\x1B[0m`);
+  const cwd = process.cwd();
+  const seedFile = options.file ?? findSeedFile(cwd);
+  if (!seedFile) {
+    console.error(`
+  \x1B[31m\u2717\x1B[0m No seed file found.`);
+    console.log("  Create a seed file at one of these locations:");
+    console.log("    - db/seed.ts");
+    console.log("    - src/db/seed.ts");
+    console.log("    - seeds/index.ts");
+    console.log(`  Or specify a custom path with --file
+`);
+    process.exit(1);
+  }
+  console.log(`  Using seed file: ${seedFile}
+`);
+  try {
+    const runner = existsSync(join6(cwd, "bun.lockb")) ? "bun" : "npx";
+    const runArgs = runner === "bun" ? ["run", seedFile] : ["tsx", seedFile];
+    return new Promise((resolve2) => {
+      const proc = spawn(runner, runArgs, {
+        cwd,
+        stdio: "inherit",
+        shell: true,
+        env: {
+          ...process.env,
+          DB_SEED_RESET: options.reset ? "1" : ""
+        }
+      });
+      proc.on("close", (code) => {
+        if (code === 0) {
+          console.log(`
+  \x1B[32m\u2713\x1B[0m Seeding completed successfully
+`);
+          resolve2();
+        } else {
+          console.error(`
+  \x1B[31m\u2717\x1B[0m Seeding failed with exit code ${code}
+`);
+          process.exit(1);
+        }
+      });
+      proc.on("error", (error) => {
+        console.error(`
+  \x1B[31m\u2717\x1B[0m ${error.message}
+`);
+        process.exit(1);
+      });
+    });
+  } catch (error) {
+    console.error(`
+  \x1B[31m\u2717\x1B[0m ${error instanceof Error ? error.message : error}
+`);
+    process.exit(1);
+  }
+}
+function findSeedFile(cwd) {
+  const locations = [
+    "db/seed.ts",
+    "db/seed.js",
+    "src/db/seed.ts",
+    "src/db/seed.js",
+    "seeds/index.ts",
+    "seeds/index.js",
+    "drizzle/seed.ts",
+    "drizzle/seed.js"
+  ];
+  for (const loc of locations) {
+    const fullPath = join6(cwd, loc);
+    if (existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+function printDbHelp() {
+  console.log(`
+  \x1B[36m\u2B21\x1B[0m \x1B[1mEreo Database Commands\x1B[0m
+
+  \x1B[1mUsage:\x1B[0m
+    ereo db:<command> [options]
+
+  \x1B[1mCommands:\x1B[0m
+    db:migrate              Run pending database migrations
+    db:generate --name <n>  Generate migration from schema changes
+    db:studio               Open Drizzle Studio GUI
+    db:push                 Push schema directly (dev only)
+    db:seed                 Run database seeders
+
+  \x1B[1mMigrate Options:\x1B[0m
+    --config <path>   Path to drizzle config file
+    --verbose         Enable verbose output
+
+  \x1B[1mGenerate Options:\x1B[0m
+    --name <name>     Migration name (required)
+    --config <path>   Path to drizzle config file
+    --out <dir>       Output directory for migrations
+
+  \x1B[1mStudio Options:\x1B[0m
+    --port <port>     Port for Drizzle Studio
+    --config <path>   Path to drizzle config file
+
+  \x1B[1mPush Options:\x1B[0m
+    --config <path>   Path to drizzle config file
+    --force           Skip confirmation prompts
+    --verbose         Enable verbose output
+
+  \x1B[1mSeed Options:\x1B[0m
+    --file <path>     Path to seed file
+    --reset           Reset database before seeding
+
+  \x1B[1mExamples:\x1B[0m
+    ereo db:generate --name add_users_table
+    ereo db:migrate
+    ereo db:studio --port 4000
+    ereo db:push --force
+    ereo db:seed --reset
+`);
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+function printHelp() {
+  console.log(`
+  \x1B[36m\u2B21\x1B[0m \x1B[1mEreo\x1B[0m - React Fullstack Framework
+
+  \x1B[1mUsage:\x1B[0m
+    ereo <command> [options]
+
+  \x1B[1mCommands:\x1B[0m
+    dev         Start development server
+    build       Build for production
+    start       Start production server
+    create      Create new project
+    deploy      Deploy to production
+    db:*        Database commands (db:migrate, db:generate, db:studio, db:push, db:seed)
+
+  \x1B[1mDev Options:\x1B[0m
+    --port, -p  Port number (default: 3000)
+    --host, -h  Host name (default: localhost)
+    --open, -o  Open browser
+
+  \x1B[1mBuild Options:\x1B[0m
+    --outDir    Output directory (default: .ereo)
+    --minify    Enable minification (default: true)
+    --sourcemap Generate sourcemaps (default: true)
+
+  \x1B[1mStart Options:\x1B[0m
+    --port, -p  Port number (default: 3000)
+    --host, -h  Host name (default: 0.0.0.0)
+
+  \x1B[1mCreate Options:\x1B[0m
+    --template, -t  Template (minimal, default, tailwind)
+    --typescript    Use TypeScript (default: true)
+
+  \x1B[1mDeploy Options:\x1B[0m
+    --prod      Deploy to production
+    --dry-run   Preview deployment
+    --name      Project name
+
+  \x1B[1mDatabase Commands:\x1B[0m
+    ereo db:migrate           Run pending migrations
+    ereo db:generate --name   Generate migration from schema
+    ereo db:studio            Open Drizzle Studio
+    ereo db:push              Push schema (dev only)
+    ereo db:seed              Run database seeders
+
+  \x1B[1mExamples:\x1B[0m
+    ereo dev --port 8080
+    ereo build --minify
+    ereo start --port 3001
+    ereo create my-app --template tailwind
+    ereo deploy vercel --prod
+    ereo db:generate --name add_users
+
+  Version: ${VERSION}
+`);
+}
+function parseArgs(args) {
+  const options = {};
+  const positional = [];
+  let command = "";
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (!command && !arg.startsWith("-")) {
+      command = arg;
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      const [key, value] = arg.slice(2).split("=");
+      if (value !== undefined) {
+        options[key] = value;
+      } else if (args[i + 1] && !args[i + 1].startsWith("-")) {
+        options[key] = args[++i];
+      } else {
+        options[key] = true;
+      }
+    } else if (arg.startsWith("-")) {
+      const key = arg.slice(1);
+      if (args[i + 1] && !args[i + 1].startsWith("-")) {
+        options[key] = args[++i];
+      } else {
+        options[key] = true;
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+  return { command, options, positional };
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    printHelp();
+    return;
+  }
+  if (args[0] === "--version" || args[0] === "-v") {
+    console.log(VERSION);
+    return;
+  }
+  const { command, options, positional } = parseArgs(args);
+  try {
+    switch (command) {
+      case "dev": {
+        const devOptions = {
+          port: options.port ? parseInt(options.port) : undefined,
+          host: options.host || options.h,
+          open: !!(options.open || options.o)
+        };
+        await dev(devOptions);
+        break;
+      }
+      case "build": {
+        const buildOptions = {
+          outDir: options.outDir,
+          minify: options.minify === "false" ? false : true,
+          sourcemap: options.sourcemap === "false" ? false : true
+        };
+        await build(buildOptions);
+        break;
+      }
+      case "start": {
+        const startOptions = {
+          port: options.port ? parseInt(options.port) : undefined,
+          host: options.host || options.h
+        };
+        await start(startOptions);
+        break;
+      }
+      case "create": {
+        const projectName = positional[0];
+        if (!projectName) {
+          console.error(`
+  \x1B[31m\u2717\x1B[0m Please provide a project name
+`);
+          console.log(`  Usage: ereo create <project-name> [options]
+`);
+          process.exit(1);
+        }
+        const createOptions = {
+          template: options.template || options.t,
+          typescript: options.typescript !== "false"
+        };
+        await create(projectName, createOptions);
+        break;
+      }
+      case "deploy": {
+        if (options.help || options.h) {
+          printDeployHelp();
+          break;
+        }
+        const target = positional[0];
+        const deployOptions = {
+          target,
+          production: !!(options.prod || options.production),
+          dryRun: !!(options["dry-run"] || options.dryRun),
+          name: options.name,
+          build: options["no-build"] ? false : true
+        };
+        const result = await deploy(deployOptions);
+        if (!result.success) {
+          console.error(`
+  \x1B[31m\u2717\x1B[0m ${result.error}
+`);
+          process.exit(1);
+        }
+        break;
+      }
+      case "db:migrate": {
+        const migrateOptions = {
+          config: options.config,
+          verbose: !!(options.verbose || options.v)
+        };
+        await dbMigrate(migrateOptions);
+        break;
+      }
+      case "db:generate": {
+        const generateOptions = {
+          name: options.name || positional[0],
+          config: options.config,
+          out: options.out
+        };
+        await dbGenerate(generateOptions);
+        break;
+      }
+      case "db:studio": {
+        const studioOptions = {
+          port: options.port ? parseInt(options.port) : undefined,
+          config: options.config,
+          open: options.open !== false
+        };
+        await dbStudio(studioOptions);
+        break;
+      }
+      case "db:push": {
+        const pushOptions = {
+          config: options.config,
+          force: !!(options.force || options.f),
+          verbose: !!(options.verbose || options.v)
+        };
+        await dbPush(pushOptions);
+        break;
+      }
+      case "db:seed": {
+        const seedOptions = {
+          file: options.file,
+          reset: !!(options.reset || options.r)
+        };
+        await dbSeed(seedOptions);
+        break;
+      }
+      case "db":
+      case "db:help": {
+        printDbHelp();
+        break;
+      }
+      default:
+        if (command.startsWith("db:")) {
+          console.error(`
+  \x1B[31m\u2717\x1B[0m Unknown database command: ${command}
+`);
+          printDbHelp();
+          process.exit(1);
+        }
+        console.error(`
+  \x1B[31m\u2717\x1B[0m Unknown command: ${command}
+`);
+        printHelp();
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error(`
+  \x1B[31m\u2717\x1B[0m Error:`, error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+main().catch(console.error);
+export {
+  start,
+  dev,
+  deploy,
+  dbStudio,
+  dbSeed,
+  dbPush,
+  dbMigrate,
+  dbGenerate,
+  create,
+  build
+};