create-fullstack-scaffold 0.1.0 → 0.1.1

package/dist/cli/index.js

@@ -2,9 +2,13 @@
 import { program } from 'commander';
 import { hc } from 'hono/client';
 import { z } from '@hono/zod-openapi';
-import fs from 'fs';
-import path from 'path';
+import fs, { readdirSync, statSync, existsSync, readFileSync } from 'fs';
+import path2, { join } from 'path';
 import os from 'os';
+import { fileURLToPath, pathToFileURL } from 'url';
+import fs2 from 'fs-extra';
+import chalk from 'chalk';
+import ora from 'ora';
 
 function createRPCClient(baseUrl) {
   return hc(baseUrl);
@@ -136,8 +140,8 @@ function schemaToOptions(schema) {
   }
   return options;
 }
-function pathToApiCall(client, _method, path2) {
-  const pathParts = path2.split("/").filter(Boolean);
+function pathToApiCall(client, _method, path3) {
+  const pathParts = path3.split("/").filter(Boolean);
   let current = client.api;
   for (const part of pathParts) {
     if (part.startsWith("{") && part.endsWith("}")) {
@@ -340,8 +344,8 @@ function registerNotificationCommands(program2) {
     logger2.info(JSON.stringify(data, null, 2));
   });
 }
-var CONFIG_DIR = path.join(os.homedir(), ".biomimic");
-var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+var CONFIG_DIR = path2.join(os.homedir(), ".biomimic");
+var CONFIG_FILE = path2.join(CONFIG_DIR, "config.json");
 function loadConfig() {
   try {
     if (fs.existsSync(CONFIG_FILE)) {
@@ -424,9 +428,2007 @@ function registerModules(program2) {
   registerNotificationCommands(program2);
   registerConfigCommands(program2);
 }
+var tsImportFn;
+async function getTsImport() {
+  if (tsImportFn) return tsImportFn;
+  const { tsImport } = await import('tsx/esm/api');
+  tsImportFn = tsImport;
+  return tsImportFn;
+}
+async function loadManifests(templateDir) {
+  const tsImport = await getTsImport();
+  const serverDir = join(templateDir, "src", "server");
+  const modules = /* @__PURE__ */ new Map();
+  const entries = readdirSync(serverDir);
+  const moduleDirs = entries.filter(
+    (e) => e.startsWith("module-") && statSync(join(serverDir, e)).isDirectory()
+  );
+  const parentURL = pathToFileURL(join(serverDir, "dummy.ts")).href;
+  for (const dir of moduleDirs) {
+    const manifestPath = join(serverDir, dir, "module.ts");
+    if (!existsSync(manifestPath)) continue;
+    try {
+      const mod = await tsImport(manifestPath, { parentURL });
+      const manifest = mod.default;
+      if (!manifest || !manifest.name) {
+        console.error(`\u274C Invalid manifest in ${dir}: missing name`);
+        continue;
+      }
+      modules.set(manifest.name, manifest);
+    } catch (err) {
+      console.error(`\u274C Failed to load manifest from ${dir}:`, err);
+    }
+  }
+  return modules;
+}
+async function loadPresets(templateDir) {
+  const configPath = join(templateDir, "modules.config.ts");
+  if (!existsSync(configPath)) {
+    return [getDefaultPreset()];
+  }
+  try {
+    const tsImport = await getTsImport();
+    const parentURL = pathToFileURL(configPath).href;
+    const mod = await tsImport(configPath, { parentURL });
+    if (mod.TEMPLATE_PRESETS) {
+      return mod.TEMPLATE_PRESETS;
+    }
+  } catch (err) {
+    console.error("\u274C Failed to load presets:", err);
+  }
+  return [getDefaultPreset()];
+}
+function getDefaultPreset() {
+  return {
+    id: "fullstack-admin",
+    name: "Full Admin",
+    description: "All modules included",
+    modules: [
+      "todos",
+      "chat",
+      "notifications",
+      "file",
+      "captcha",
+      "permission",
+      "admin",
+      "order",
+      "ticket",
+      "dispute",
+      "content"
+    ]
+  };
+}
+function resolvePreset(preset, allManifests) {
+  const modules = /* @__PURE__ */ new Map();
+  const toProcess = [...preset.modules];
+  const processed = /* @__PURE__ */ new Set();
+  while (toProcess.length > 0) {
+    const name = toProcess.shift();
+    if (processed.has(name)) continue;
+    processed.add(name);
+    const manifest = allManifests.get(name);
+    if (manifest) {
+      modules.set(name, manifest);
+      for (const dep of manifest.dependsOn) {
+        if (!processed.has(dep)) {
+          toProcess.push(dep);
+        }
+      }
+    }
+  }
+  let hasSSE = false;
+  let hasWebSocket = false;
+  let hasAdmin = false;
+  for (const manifest of modules.values()) {
+    if (manifest.hasSSE) hasSSE = true;
+    if (manifest.hasWebSocket) hasWebSocket = true;
+    if (manifest.adminPages && manifest.adminPages.length > 0) hasAdmin = true;
+    if (manifest.routes.admin && manifest.routes.admin.length > 0) hasAdmin = true;
+  }
+  return {
+    preset,
+    modules,
+    hasAdmin,
+    hasClient: true,
+    hasSSE,
+    hasWebSocket,
+    hasPermission: modules.has("permission"),
+    hasCaptcha: modules.has("captcha")
+  };
+}
+function getDbSchemaFiles(resolved) {
+  const files = [];
+  for (const [, manifest] of resolved.modules) {
+    if (manifest.dbSchemas) {
+      files.push(...manifest.dbSchemas.files);
+    }
+  }
+  return files;
+}
+function getClientPages(resolved) {
+  const pages = [];
+  for (const [, manifest] of resolved.modules) {
+    if (manifest.clientPages) {
+      pages.push(...manifest.clientPages);
+    }
+  }
+  return pages;
+}
+function getAdminPages(resolved) {
+  const pages = [];
+  for (const [, manifest] of resolved.modules) {
+    if (manifest.adminPages) {
+      pages.push(...manifest.adminPages);
+    }
+  }
+  return pages;
+}
+function getDefaultRoute(resolved) {
+  const pages = getClientPages(resolved);
+  if (pages.length > 0) {
+    return pages[0].route;
+  }
+  return "/";
+}
+
+// src/generators/file-filter.ts
+function getExcludePatterns(resolved, allManifests) {
+  const excludes = [];
+  for (const [name, manifest] of allManifests) {
+    if (resolved.modules.has(name)) continue;
+    excludes.push(`src/server/module-${name}`);
+    if (manifest.sharedSchemas) {
+      excludes.push(`src/shared/modules/${manifest.sharedSchemas.path}`);
+      if (manifest.sharedSchemas.additionalPaths) {
+        for (const extra of manifest.sharedSchemas.additionalPaths) {
+          excludes.push(`src/shared/modules/${extra}`);
+        }
+      }
+    }
+    if (manifest.dbSchemas) {
+      for (const file of manifest.dbSchemas.files) {
+        excludes.push(`src/server/db/schema/${file}.ts`);
+      }
+    }
+    if (manifest.clientPages) {
+      for (const page of manifest.clientPages) {
+        excludes.push(`src/client/pages/${page.name}.tsx`);
+        excludes.push(`src/client/pages/__tests__/${page.name}.test.tsx`);
+      }
+    }
+    if (manifest.clientStores) {
+      for (const store of manifest.clientStores) {
+        excludes.push(`src/client/stores/${store}.ts`);
+        excludes.push(`src/client/stores/__tests__/${store}.test.ts`);
+      }
+    }
+    if (manifest.adminPages) {
+      for (const page of manifest.adminPages) {
+        excludes.push(`src/admin/pages/${page.name}.tsx`);
+        excludes.push(`src/admin/pages/__tests__/${page.name}.test.tsx`);
+      }
+    }
+    if (manifest.providesMiddleware) {
+      for (const mw of manifest.providesMiddleware) {
+        excludes.push(`src/server/middleware/${mw.name}.ts`);
+        excludes.push(`src/server/middleware/__tests__/${mw.name}.test.ts`);
+      }
+    }
+    if (name === "notifications") {
+      excludes.push("src/cli/modules/notification");
+    }
+  }
+  if (!resolved.modules.has("admin")) {
+    excludes.push("src/client/components/AuthButton.tsx");
+    excludes.push("src/admin");
+    excludes.push("admin.html");
+    excludes.push("auth-inject.html");
+    excludes.push("src/client/components/__tests__/AuthButton.test.tsx");
+    excludes.push("src/cli");
+    excludes.push("src/server/utils/auth.ts");
+  }
+  if (!resolved.hasPermission) {
+    excludes.push("src/server/utils/permission-utils.ts");
+    excludes.push("src/server/middleware/__tests__/auth-simple.test.ts");
+    excludes.push("src/server/middleware/__tests__/auth.test.ts");
+    excludes.push("src/server/middleware/__tests__/error-response-format.test.ts");
+    excludes.push("src/server/utils/__tests__/auth.test.ts");
+  } else if (!resolved.modules.has("admin")) {
+    excludes.push("src/server/middleware/__tests__/error-response-format.test.ts");
+  }
+  if (!resolved.modules.has("captcha")) {
+    excludes.push("src/server/utils/__tests__/captcha.test.ts");
+  }
+  return excludes;
+}
+function getGeneratedFiles(resolved) {
+  const files = [
+    "src/server/route-registry.ts",
+    "src/server/db/schema/index.ts",
+    "src/client/App.tsx",
+    "src/client/components/Navigation.tsx",
+    "src/shared/modules/index.ts",
+    "src/shared/schemas/index.ts",
+    "src/server/middleware/index.ts",
+    "src/client/components/index.ts"
+  ];
+  if (resolved.modules.has("admin")) {
+    files.push("src/admin/App.tsx");
+    files.push("src/cli/modules/index.ts");
+  }
+  if (!resolved.hasPermission) {
+    files.push("src/server/middleware/auth.ts");
+    files.push("src/server/utils/auth.ts");
+  }
+  if (!resolved.modules.has("admin") && resolved.hasPermission) {
+    files.push("src/server/utils/auth.ts");
+  }
+  files.push("src/server/app.ts");
+  if (!resolved.modules.has("admin")) {
+    files.push("vite.config.ts");
+  }
+  const seedModules = ["order", "ticket", "dispute", "content"];
+  if (seedModules.some((m) => !resolved.modules.has(m)) || !resolved.hasPermission) {
+    files.push("src/server/db/init.ts");
+  }
+  return files;
+}
+
+// src/generators/route-registry.ts
+function generateRouteRegistry(resolved) {
+  const imports = [
+    `import { OpenAPIHono } from '@hono/zod-openapi'`,
+    `import { rateLimitMiddleware } from './middleware/rate-limit'`
+  ];
+  const clientRoutes = [];
+  const adminRoutes = [];
+  const moduleEntries = [...resolved.modules.entries()];
+  for (const [name, manifest] of moduleEntries) {
+    const moduleDir = `module-${name}`;
+    if (manifest.routes.client) {
+      const { importPath, exportName } = manifest.routes.client;
+      imports.push(
+        `import { ${exportName} } from './${moduleDir}/${importPath.replace(/^\.\//, "")}'`
+      );
+      clientRoutes.push(`  .route('/api', ${exportName})`);
+    }
+    if (manifest.routes.admin) {
+      for (const route of manifest.routes.admin) {
+        const { importPath, exportName } = route;
+        imports.push(
+          `import { ${exportName} } from './${moduleDir}/${importPath.replace(/^\.\//, "")}'`
+        );
+        adminRoutes.push(`  .route('/api', ${exportName})`);
+      }
+    }
+  }
+  let content = imports.join("\n") + "\n\n";
+  content += `const apiRateLimit = rateLimitMiddleware({
+`;
+  content += `  windowMs: 60 * 1000,
+`;
+  content += `  max: 100,
+`;
+  content += `})
+
+`;
+  if (clientRoutes.length > 0) {
+    content += `// client API routes
+`;
+    content += `export const clientApiRoutes = new OpenAPIHono()
+`;
+    content += `  .use('*', apiRateLimit)
+`;
+    content += clientRoutes.join("\n") + "\n\n";
+  } else {
+    content += `// No client modules selected
+`;
+    content += `export const clientApiRoutes = new OpenAPIHono()
+
+`;
+  }
+  if (adminRoutes.length > 0) {
+    content += `// admin API routes
+`;
+    content += `export const adminApiRoutes = new OpenAPIHono()
+`;
+    content += adminRoutes.join("\n") + "\n\n";
+  } else {
+    content += `// No admin modules selected
+`;
+    content += `export const adminApiRoutes = new OpenAPIHono()
+
+`;
+  }
+  content += `export type ClientApiRoutes = typeof clientApiRoutes
+`;
+  content += `export type AdminApiRoutes = typeof adminApiRoutes
+`;
+  return content;
+}
+
+// src/generators/client-app.ts
+function generateClientApp(resolved) {
+  const pages = getClientPages(resolved);
+  const defaultRoute = getDefaultRoute(resolved);
+  const imports = [
+    `import { BrowserRouter, Routes, Route, Navigate } from 'react-router-dom'`,
+    `import { Layout } from './Layout'`
+  ];
+  for (const page of pages) {
+    imports.push(`import { ${page.name} } from './pages/${page.name}'`);
+  }
+  const routeElements = [];
+  routeElements.push(
+    `          <Route path="/" element={<Navigate to="${defaultRoute}" replace />} />`
+  );
+  for (const page of pages) {
+    routeElements.push(
+      `          <Route path="${page.route}" element={<${page.name} />} />`
+    );
+  }
+  return `${imports.join("\n")}
+
+export function App() {
+  return (
+    <BrowserRouter>
+      <Layout>
+        <Routes>
+${routeElements.join("\n")}
+        </Routes>
+      </Layout>
+    </BrowserRouter>
+  )
+}
+`;
+}
+
+// src/generators/client-navigation.ts
+var DEFAULT_ICON = "Circle";
+var ICON_MAP = {
+  TodoPage: "CheckCircle",
+  NotificationPage: "Bell",
+  WebSocketPage: "Plug",
+  ContentListPage: "FileText"
+};
+function generateClientNavigation(resolved) {
+  const pages = getClientPages(resolved).filter((p) => !p.route.includes(":"));
+  const iconsNeeded = /* @__PURE__ */ new Set();
+  iconsNeeded.add("Rocket");
+  iconsNeeded.add("Github");
+  for (const page of pages) {
+    const icon = ICON_MAP[page.name] || DEFAULT_ICON;
+    iconsNeeded.add(icon);
+  }
+  const routeKeys = [];
+  const routeEntries = [];
+  for (const page of pages) {
+    const key = page.route.replace(/^\//, "").replace(/\//g, "-");
+    routeKeys.push(`'${key}'`);
+    const icon = ICON_MAP[page.name] || DEFAULT_ICON;
+    const label = key === "todos" ? "Todo List" : key === "notifications" ? "Notifications" : key === "websocket" ? "WebSocket" : key.charAt(0).toUpperCase() + key.slice(1);
+    const safeKey = /^[a-zA-Z0-9_]+$/.test(key) ? key : `'${key}'`;
+    routeEntries.push(`  ${safeKey}: { label: '${label}', icon: ${icon}, path: '${page.route}' },`);
+  }
+  const iconsStr = [...iconsNeeded].join(", ");
+  const authButtonImport = resolved.modules.has("admin") ? `
+import { AuthButton } from './AuthButton'` : "";
+  const authButtonElement = resolved.modules.has("admin") ? `
+          <AuthButton />` : "";
+  return `import { NavLink } from 'react-router-dom'
+import { ${iconsStr} } from 'lucide-react'${authButtonImport}
+
+type RouteKey = ${routeKeys.join(" | ")}
+
+const routes: Record<
+  RouteKey,
+  { label: string; icon: React.FC<{ className?: string }>; path: string }
+> = {
+${routeEntries.join("\n")}
+}
+
+export const Navigation: React.FC = () => {
+  return (
+    <nav className="bg-white border-b border-gray-200 sticky top-0 z-50" data-testid="app-nav">
+      <div className="max-w-6xl mx-auto px-6 h-16 flex items-center justify-between">
+        <div className="flex items-center gap-8">
+          <h1
+            className="text-xl font-bold text-gray-900 flex items-center gap-2"
+            data-testid="app-title"
+          >
+            <Rocket className="w-6 h-6 text-blue-500" />
+            Biomimic App
+          </h1>
+          <div className="flex items-center gap-1">
+            {(Object.keys(routes) as RouteKey[]).map(route => {
+              const Icon = routes[route].icon
+              return (
+                <NavLink
+                  key={route}
+                  to={routes[route].path}
+                  data-testid={\`nav-\${route}-button\`}
+                  className={({ isActive }) =>
+                    \`flex items-center gap-2 px-4 py-2 rounded-lg text-sm font-medium transition-colors \${
+                      isActive ? 'bg-blue-50 text-blue-600' : 'text-gray-600 hover:bg-gray-100'
+                    }\`
+                  }
+                >
+                  <Icon className="w-4 h-4" />
+                  {routes[route].label}
+                </NavLink>
+              )
+            })}
+          </div>
+        </div>
+        <div className="flex items-center gap-4">${authButtonElement}
+          <a
+            href="https://github.com"
+            target="_blank"
+            rel="noopener noreferrer"
+            data-testid="github-link"
+            className="text-gray-400 hover:text-gray-600 transition-colors"
+          >
+            <Github className="w-5 h-5" />
+          </a>
+        </div>
+      </div>
+    </nav>
+  )
+}
+`;
+}
+
+// src/generators/admin-app.ts
+function generateAdminApp(resolved) {
+  if (!resolved.hasAdmin) return null;
+  const pages = getAdminPages(resolved) ?? [];
+  if (pages.length === 0) return null;
+  const publicPages = pages.filter((p) => p.isPublic);
+  const protectedPages = pages.filter((p) => !p.isPublic);
+  const imports = [
+    `import { BrowserRouter, Routes, Route, Navigate } from 'react-router-dom'`,
+    `import { ConfigProvider } from 'antd'`,
+    `import { Layout } from './layouts/Layout'`
+  ];
+  for (const page of pages) {
+    imports.push(`import { ${page.name} } from './pages/${page.name}'`);
+  }
+  const captchaImport = resolved.hasCaptcha ? ", CaptchaModal" : "";
+  imports.push(`import { ProtectedRoute${captchaImport} } from './components'`);
+  const protectedRouteElements = protectedPages.map(
+    (p) => `                    <Route path="${p.route}" element={<${p.name} />} />`
+  );
+  const defaultProtectedRoute = protectedPages.length > 0 ? protectedPages[0].route : "/";
+  const captchaElement = resolved.hasCaptcha ? `
+        <CaptchaModal />` : "";
+  const publicRouteLines = publicPages.map(
+    (p) => `          <Route path="${p.route}" element={<${p.name} />} />`
+  );
+  return `${imports.join("\n")}
+
+export const App: React.FC = () => {
+  return (
+    <ConfigProvider
+      theme={{
+        token: {
+          colorPrimary: '#1890ff',
+        },
+      }}
+    >
+      <BrowserRouter basename="/admin">
+        <Routes>
+${publicRouteLines.join("\n")}
+          <Route
+            path="/*"
+            element={
+              <ProtectedRoute>
+                <Layout>
+                  <Routes>
+                    <Route path="/" element={<Navigate to="${defaultProtectedRoute}" replace />} />
+${protectedRouteElements.join("\n")}
+                    <Route path="/system/monitor" element={<div className="p-6"><h2 className="text-xl font-semibold">System Monitor</h2><p className="text-gray-500 mt-2">Coming soon...</p></div>} />
+                  </Routes>
+                </Layout>
+              </ProtectedRoute>
+            }
+          />
+        </Routes>${captchaElement}
+      </BrowserRouter>
+    </ConfigProvider>
+  )
+}
+`;
+}
+
+// src/generators/db-schema-barrel.ts
+function generateDbSchemaBarrel(resolved) {
+  const files = getDbSchemaFiles(resolved);
+  const exports$1 = files.map((f) => `export * from './${f}'`);
+  return exports$1.join("\n") + "\n";
+}
+
+// src/generators/db-init.ts
+var SEED_MODULES = [
+  {
+    module: "order",
+    importLine: "import { seedOrdersIfEmpty } from '../module-order/services/order-service'",
+    call: "seedOrdersIfEmpty()"
+  },
+  {
+    module: "ticket",
+    importLine: "import { seedTicketsIfEmpty } from '../module-ticket/services/ticket-service'",
+    call: "seedTicketsIfEmpty()"
+  },
+  {
+    module: "dispute",
+    importLine: "import { seedDisputesIfEmpty } from '../module-dispute/services/dispute-service'",
+    call: "seedDisputesIfEmpty()"
+  },
+  {
+    module: "content",
+    importLine: "import { seedContentsIfEmpty } from '../module-content/services/content-service'",
+    call: "seedContentsIfEmpty()"
+  }
+];
+var INITIAL_PERMISSIONS = `const initialPermissions = [
+  {
+    id: 'perm_user_view',
+    code: 'user:view',
+    name: '\u67E5\u770B\u7528\u6237',
+    label: '\u67E5\u770B\u7528\u6237',
+    category: 'user',
+    sortOrder: 1,
+  },
+  {
+    id: 'perm_user_create',
+    code: 'user:create',
+    name: '\u521B\u5EFA\u7528\u6237',
+    label: '\u521B\u5EFA\u7528\u6237',
+    category: 'user',
+    sortOrder: 2,
+  },
+  {
+    id: 'perm_user_edit',
+    code: 'user:edit',
+    name: '\u7F16\u8F91\u7528\u6237',
+    label: '\u7F16\u8F91\u7528\u6237',
+    category: 'user',
+    sortOrder: 3,
+  },
+  {
+    id: 'perm_user_delete',
+    code: 'user:delete',
+    name: '\u5220\u9664\u7528\u6237',
+    label: '\u5220\u9664\u7528\u6237',
+    category: 'user',
+    sortOrder: 4,
+  },
+  {
+    id: 'perm_content_view',
+    code: 'content:view',
+    name: '\u67E5\u770B\u5185\u5BB9',
+    label: '\u67E5\u770B\u5185\u5BB9',
+    category: 'content',
+    sortOrder: 1,
+  },
+  {
+    id: 'perm_content_create',
+    code: 'content:create',
+    name: '\u521B\u5EFA\u5185\u5BB9',
+    label: '\u521B\u5EFA\u5185\u5BB9',
+    category: 'content',
+    sortOrder: 2,
+  },
+  {
+    id: 'perm_content_edit',
+    code: 'content:edit',
+    name: '\u7F16\u8F91\u5185\u5BB9',
+    label: '\u7F16\u8F91\u5185\u5BB9',
+    category: 'content',
+    sortOrder: 3,
+  },
+  {
+    id: 'perm_content_delete',
+    code: 'content:delete',
+    name: '\u5220\u9664\u5185\u5BB9',
+    label: '\u5220\u9664\u5185\u5BB9',
+    category: 'content',
+    sortOrder: 4,
+  },
+  {
+    id: 'perm_system_settings',
+    code: 'system:settings',
+    name: '\u7CFB\u7EDF\u8BBE\u7F6E',
+    label: '\u7CFB\u7EDF\u8BBE\u7F6E',
+    category: 'system',
+    sortOrder: 1,
+  },
+  {
+    id: 'perm_system_logs',
+    code: 'system:logs',
+    name: '\u7CFB\u7EDF\u65E5\u5FD7',
+    label: '\u7CFB\u7EDF\u65E5\u5FD7',
+    category: 'system',
+    sortOrder: 2,
+  },
+  {
+    id: 'perm_system_monitor',
+    code: 'system:monitor',
+    name: '\u7CFB\u7EDF\u76D1\u63A7',
+    label: '\u7CFB\u7EDF\u76D1\u63A7',
+    category: 'system',
+    sortOrder: 3,
+  },
+  {
+    id: 'perm_data_export',
+    code: 'data:export',
+    name: '\u6570\u636E\u5BFC\u51FA',
+    label: '\u6570\u636E\u5BFC\u51FA',
+    category: 'data',
+    sortOrder: 1,
+  },
+  {
+    id: 'perm_data_import',
+    code: 'data:import',
+    name: '\u6570\u636E\u5BFC\u5165',
+    label: '\u6570\u636E\u5BFC\u5165',
+    category: 'data',
+    sortOrder: 2,
+  },
+  {
+    id: 'perm_order_view',
+    code: 'order:view',
+    name: '\u67E5\u770B\u8BA2\u5355',
+    label: '\u67E5\u770B\u8BA2\u5355',
+    category: 'order',
+    sortOrder: 1,
+  },
+  {
+    id: 'perm_order_create',
+    code: 'order:create',
+    name: '\u521B\u5EFA\u8BA2\u5355',
+    label: '\u521B\u5EFA\u8BA2\u5355',
+    category: 'order',
+    sortOrder: 2,
+  },
+  {
+    id: 'perm_order_edit',
+    code: 'order:edit',
+    name: '\u7F16\u8F91\u8BA2\u5355',
+    label: '\u7F16\u8F91\u8BA2\u5355',
+    category: 'order',
+    sortOrder: 3,
+  },
+  {
+    id: 'perm_order_delete',
+    code: 'order:delete',
+    name: '\u5220\u9664\u8BA2\u5355',
+    label: '\u5220\u9664\u8BA2\u5355',
+    category: 'order',
+    sortOrder: 4,
+  },
+  {
+    id: 'perm_order_process',
+    code: 'order:process',
+    name: '\u5904\u7406\u8BA2\u5355',
+    label: '\u5904\u7406\u8BA2\u5355',
+    category: 'order',
+    sortOrder: 5,
+  },
+  {
+    id: 'perm_ticket_view',
+    code: 'ticket:view',
+    name: '\u67E5\u770B\u5DE5\u5355',
+    label: '\u67E5\u770B\u5DE5\u5355',
+    category: 'ticket',
+    sortOrder: 1,
+  },
+  {
+    id: 'perm_ticket_create',
+    code: 'ticket:create',
+    name: '\u521B\u5EFA\u5DE5\u5355',
+    label: '\u521B\u5EFA\u5DE5\u5355',
+    category: 'ticket',
+    sortOrder: 2,
+  },
+  {
+    id: 'perm_ticket_edit',
+    code: 'ticket:edit',
+    name: '\u7F16\u8F91\u5DE5\u5355',
+    label: '\u7F16\u8F91\u5DE5\u5355',
+    category: 'ticket',
+    sortOrder: 3,
+  },
+  {
+    id: 'perm_ticket_delete',
+    code: 'ticket:delete',
+    name: '\u5220\u9664\u5DE5\u5355',
+    label: '\u5220\u9664\u5DE5\u5355',
+    category: 'ticket',
+    sortOrder: 4,
+  },
+  {
+    id: 'perm_ticket_reply',
+    code: 'ticket:reply',
+    name: '\u56DE\u590D\u5DE5\u5355',
+    label: '\u56DE\u590D\u5DE5\u5355',
+    category: 'ticket',
+    sortOrder: 5,
+  },
+  {
+    id: 'perm_ticket_close',
+    code: 'ticket:close',
+    name: '\u5173\u95ED\u5DE5\u5355',
+    label: '\u5173\u95ED\u5DE5\u5355',
+    category: 'ticket',
+    sortOrder: 6,
+  },
+  {
+    id: 'perm_dispute_view',
+    code: 'dispute:view',
+    name: '\u67E5\u770B\u4E89\u8BAE',
+    label: '\u67E5\u770B\u4E89\u8BAE',
+    category: 'dispute',
+    sortOrder: 1,
+  },
+  {
+    id: 'perm_dispute_create',
+    code: 'dispute:create',
+    name: '\u521B\u5EFA\u4E89\u8BAE',
+    label: '\u521B\u5EFA\u4E89\u8BAE',
+    category: 'dispute',
+    sortOrder: 2,
+  },
+  {
+    id: 'perm_dispute_edit',
+    code: 'dispute:edit',
+    name: '\u7F16\u8F91\u4E89\u8BAE',
+    label: '\u7F16\u8F91\u4E89\u8BAE',
+    category: 'dispute',
+    sortOrder: 3,
+  },
+  {
+    id: 'perm_dispute_delete',
+    code: 'dispute:delete',
+    name: '\u5220\u9664\u4E89\u8BAE',
+    label: '\u5220\u9664\u4E89\u8BAE',
+    category: 'dispute',
+    sortOrder: 4,
+  },
+  {
+    id: 'perm_dispute_resolve',
+    code: 'dispute:resolve',
+    name: '\u89E3\u51B3\u4E89\u8BAE',
+    label: '\u89E3\u51B3\u4E89\u8BAE',
+    category: 'dispute',
+    sortOrder: 5,
+  },
+  {
+    id: 'perm_role_view',
+    code: 'role:view',
+    name: '\u67E5\u770B\u89D2\u8272',
+    label: '\u67E5\u770B\u89D2\u8272',
+    category: 'role',
+    sortOrder: 1,
+  },
+  {
+    id: 'perm_role_create',
+    code: 'role:create',
+    name: '\u521B\u5EFA\u89D2\u8272',
+    label: '\u521B\u5EFA\u89D2\u8272',
+    category: 'role',
+    sortOrder: 2,
+  },
+  {
+    id: 'perm_role_edit',
+    code: 'role:edit',
+    name: '\u7F16\u8F91\u89D2\u8272',
+    label: '\u7F16\u8F91\u89D2\u8272',
+    category: 'role',
+    sortOrder: 3,
+  },
+  {
+    id: 'perm_role_delete',
+    code: 'role:delete',
+    name: '\u5220\u9664\u89D2\u8272',
+    label: '\u5220\u9664\u89D2\u8272',
+    category: 'role',
+    sortOrder: 4,
+  },
+]`;
+var INITIAL_ROLES = `const initialRoles = [
+  {
+    id: 'role_super_admin',
+    code: 'super_admin',
+    name: '\u8D85\u7EA7\u7BA1\u7406\u5458',
+    label: '\u8D85\u7EA7\u7BA1\u7406\u5458',
+    isSystem: true,
+    sortOrder: 1,
+  },
+  {
+    id: 'role_customer_service',
+    code: 'customer_service',
+    name: '\u5BA2\u670D\u4EBA\u5458',
+    label: '\u5BA2\u670D\u4EBA\u5458',
+    isSystem: true,
+    sortOrder: 2,
+  },
+  {
+    id: 'role_user',
+    code: 'user',
+    name: '\u666E\u901A\u7528\u6237',
+    label: '\u666E\u901A\u7528\u6237',
+    isSystem: true,
+    sortOrder: 3,
+  },
+]`;
+var INITIAL_ROLE_PERMISSIONS = `const initialRolePermissions = [
+  { roleId: 'role_super_admin', permissionId: 'perm_user_view' },
+  { roleId: 'role_super_admin', permissionId: 'perm_user_create' },
+  { roleId: 'role_super_admin', permissionId: 'perm_user_edit' },
+  { roleId: 'role_super_admin', permissionId: 'perm_user_delete' },
+  { roleId: 'role_super_admin', permissionId: 'perm_content_view' },
+  { roleId: 'role_super_admin', permissionId: 'perm_content_create' },
+  { roleId: 'role_super_admin', permissionId: 'perm_content_edit' },
+  { roleId: 'role_super_admin', permissionId: 'perm_content_delete' },
+  { roleId: 'role_super_admin', permissionId: 'perm_system_settings' },
+  { roleId: 'role_super_admin', permissionId: 'perm_system_logs' },
+  { roleId: 'role_super_admin', permissionId: 'perm_system_monitor' },
+  { roleId: 'role_super_admin', permissionId: 'perm_data_export' },
+  { roleId: 'role_super_admin', permissionId: 'perm_data_import' },
+  { roleId: 'role_super_admin', permissionId: 'perm_order_view' },
+  { roleId: 'role_super_admin', permissionId: 'perm_order_create' },
+  { roleId: 'role_super_admin', permissionId: 'perm_order_edit' },
+  { roleId: 'role_super_admin', permissionId: 'perm_order_delete' },
+  { roleId: 'role_super_admin', permissionId: 'perm_order_process' },
+  { roleId: 'role_super_admin', permissionId: 'perm_ticket_view' },
+  { roleId: 'role_super_admin', permissionId: 'perm_ticket_create' },
+  { roleId: 'role_super_admin', permissionId: 'perm_ticket_edit' },
+  { roleId: 'role_super_admin', permissionId: 'perm_ticket_delete' },
+  { roleId: 'role_super_admin', permissionId: 'perm_ticket_reply' },
+  { roleId: 'role_super_admin', permissionId: 'perm_ticket_close' },
+  { roleId: 'role_super_admin', permissionId: 'perm_dispute_view' },
+  { roleId: 'role_super_admin', permissionId: 'perm_dispute_create' },
+  { roleId: 'role_super_admin', permissionId: 'perm_dispute_edit' },
+  { roleId: 'role_super_admin', permissionId: 'perm_dispute_delete' },
+  { roleId: 'role_super_admin', permissionId: 'perm_dispute_resolve' },
+  { roleId: 'role_customer_service', permissionId: 'perm_content_view' },
+  { roleId: 'role_customer_service', permissionId: 'perm_order_view' },
+  { roleId: 'role_customer_service', permissionId: 'perm_order_create' },
+  { roleId: 'role_customer_service', permissionId: 'perm_order_edit' },
+  { roleId: 'role_customer_service', permissionId: 'perm_order_delete' },
+  { roleId: 'role_customer_service', permissionId: 'perm_order_process' },
+  { roleId: 'role_customer_service', permissionId: 'perm_ticket_view' },
+  { roleId: 'role_customer_service', permissionId: 'perm_ticket_create' },
+  { roleId: 'role_customer_service', permissionId: 'perm_ticket_edit' },
+  { roleId: 'role_customer_service', permissionId: 'perm_ticket_delete' },
+  { roleId: 'role_customer_service', permissionId: 'perm_ticket_reply' },
+  { roleId: 'role_customer_service', permissionId: 'perm_ticket_close' },
+  { roleId: 'role_customer_service', permissionId: 'perm_dispute_view' },
+  { roleId: 'role_customer_service', permissionId: 'perm_dispute_create' },
+  { roleId: 'role_customer_service', permissionId: 'perm_dispute_edit' },
+  { roleId: 'role_customer_service', permissionId: 'perm_dispute_delete' },
+  { roleId: 'role_customer_service', permissionId: 'perm_dispute_resolve' },
+  { roleId: 'role_customer_service', permissionId: 'perm_data_export' },
+  { roleId: 'role_customer_service', permissionId: 'perm_system_logs' },
+  { roleId: 'role_user', permissionId: 'perm_content_view' },
+  { roleId: 'role_user', permissionId: 'perm_order_view' },
+]`;
+function generateDbInit(resolved) {
+  const activeSeeds = SEED_MODULES.filter((s) => resolved.modules.has(s.module));
+  if (!resolved.hasPermission) {
+    return generateMinimalDbInit();
+  }
+  return generateFullDbInit(activeSeeds);
+}
+function generateMinimalDbInit() {
+  return `import { getDb } from './driver'
+import { logger } from '../utils/logger'
+
+const log = logger.db()
+
+export async function initializeDatabase() {
+  await getDb()
+
+  log.info({}, 'Initializing database...')
+  log.info({}, 'Database initialization complete!')
+}
+`;
+}
+function generateFullDbInit(activeSeeds) {
+  const seedImports = activeSeeds.map((s) => s.importLine).join("\n");
+  const seedCalls = activeSeeds.map((s) => `    ${s.call}(),`).join("\n");
+  const seedBlock = activeSeeds.length > 0 ? `
+  log.info({}, 'Seeding module data...')
+  await Promise.all([
+${seedCalls}
+  ])
+  log.info({}, 'Module data seeding complete!')` : "";
+  return `import { getDb } from './driver'
+import { permissions, roles, rolePermissions } from './schema'
+import { logger } from '../utils/logger'
+${seedImports}
+
+const log = logger.db()
+
+${INITIAL_PERMISSIONS}
+
+${INITIAL_ROLES}
+
+${INITIAL_ROLE_PERMISSIONS}
+
+export async function initializeDatabase() {
+  const db = await getDb()
+
+  log.info({}, 'Initializing database...')
+
+  const existingPermissions = await db.select().from(permissions)
+  if (existingPermissions.length === 0) {
+    log.info({}, 'Inserting initial permissions...')
+    await db.insert(permissions).values(
+      initialPermissions.map(p => ({
+        ...p,
+        description: null,
+        isActive: true,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      }))
+    )
+  }
+
+  const existingRoles = await db.select().from(roles)
+  if (existingRoles.length === 0) {
+    log.info({}, 'Inserting initial roles...')
+    await db.insert(roles).values(
+      initialRoles.map(r => ({
+        ...r,
+        description: null,
+        isActive: true,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      }))
+    )
+  }
+
+  const existingRolePermissions = await db.select().from(rolePermissions)
+  if (existingRolePermissions.length === 0) {
+    log.info({}, 'Inserting initial role permissions...')
+    await db.insert(rolePermissions).values(
+      initialRolePermissions.map(rp => ({
+        ...rp,
+        createdAt: new Date(),
+      }))
+    )
+  }
+
+  log.info({}, 'Database initialization complete!')${seedBlock}
+}
+`;
+}
+
+// src/generators/server-app.ts
+function generateServerApp(resolved) {
+  const useRealtime = resolved.hasSSE || resolved.hasWebSocket;
+  const useAuditLog = resolved.hasPermission;
+  const useCaptcha = resolved.hasCaptcha;
+  const useFileRoutes = resolved.modules.has("file");
+  const imports = [
+    `import { OpenAPIHono } from '@hono/zod-openapi'`,
+    ``,
+    `import { HTTPException } from 'hono/http-exception'`,
+    `import type { ContentfulStatusCode } from 'hono/utils/http-status'`,
+    `import { ZodError } from 'zod'`,
+    `import type { AppBindings, CreateAppOptions } from './types/bindings'`,
+    `import { AppError } from './utils/app-error'`,
+    `import { autoRegisterRealtime } from './core/realtime-scanner'`,
+    `import { corsMiddleware, loggerMiddleware, errorHandlerMiddleware } from './middleware'`
+  ];
+  if (useRealtime) {
+    imports.push(`import { realtimeEnvMiddleware } from './middleware/realtime-env'`);
+  }
+  if (useAuditLog) {
+    imports.push(`import { auditLogMiddleware } from './middleware/audit-log'`);
+  }
+  if (useCaptcha) {
+    imports.push(`import { captchaMiddleware } from './middleware/captcha'`);
+  }
+  imports.push(
+    `import { createModuleLoggerSync } from './utils/logger'`,
+    `import { adminApiRoutes, clientApiRoutes } from './route-registry'`
+  );
+  if (useFileRoutes) {
+    imports.push(`import { fileRoutes } from './module-file/routes/file-routes'`);
+  }
+  const middlewareChain = [
+    `.use('*', errorHandlerMiddleware())`,
+    `.use('*', loggerMiddleware())`,
+    `.use('*', corsMiddleware())`
+  ];
+  if (useRealtime) {
+    middlewareChain.push(`.use('*', realtimeEnvMiddleware())`);
+  }
+  if (useAuditLog) {
+    middlewareChain.push(`.use('/api/*', auditLogMiddleware())`);
+  }
+  if (useCaptcha) {
+    middlewareChain.push(
+      `.use(
+      '/api/admin/*',
+      captchaMiddleware({
+        maxRequests: 20,
+        windowMs: 60000,
+      })
+    )`
+    );
+  }
+  const routes = [`.route('/', clientApiRoutes)`, `.route('/', adminApiRoutes)`];
+  if (useFileRoutes) {
+    routes.push(`.route('/files', fileRoutes)`);
+  }
+  const indent = "    ";
+  const chain = [...middlewareChain, ...routes].join(`
+${indent}`);
+  return `${imports.join("\n")}
+
+export { type AppBindings, type CreateAppOptions } from './types/bindings'
+
+export function createApp<T extends AppBindings = AppBindings>(_options: CreateAppOptions = {}) {
+  const app = new OpenAPIHono<{ Bindings: T }>()
+    ${chain}
+    .get('/health', async c => {
+      try {
+        const { getDb } = await import('./db')
+        await getDb()
+        return c.json({ status: 'ok', timestamp: new Date().toISOString(), db: 'connected' })
+      } catch {
+        return c.json({ status: 'ok', timestamp: new Date().toISOString(), db: 'not configured' })
+      }
+    })
+    .post('/api/__test__/cleanup', async c => {
+      try {
+        const { cleanupTestDatabase } = await import('./db/test-setup')
+        await cleanupTestDatabase()
+        return c.json({ success: true as const, message: 'Database cleaned up' })
+      } catch (error) {
+        console.error('Error during database cleanup:', error)
+        return c.json({ success: false as const, message: 'Failed to cleanup database' }, 500)
+      }
+    })
+
+  autoRegisterRealtime(app as unknown as Parameters<typeof autoRegisterRealtime>[0])
+
+  app.onError((err, c) => {
+    const log = createModuleLoggerSync('api')
+    c.res.headers.set('Content-Type', 'application/json')
+
+    if (AppError.isAppError(err)) {
+      return c.json(
+        {
+          success: false as const,
+          error: err.message,
+          status: err.statusCode,
+          details: err.details,
+        },
+        err.statusCode as ContentfulStatusCode
+      )
+    }
+
+    if (err instanceof HTTPException) {
+      return c.json(
+        { success: false as const, error: err.message, status: err.status },
+        err.status as ContentfulStatusCode
+      )
+    }
+
+    if (err instanceof ZodError) {
+      const details = err.issues.map(issue => ({
+        field: issue.path.join('.'),
+        message: issue.message,
+      }))
+      return c.json(
+        { success: false as const, error: 'Validation failed', status: 400, details },
+        400
+      )
+    }
+
+    log.error({ err, path: c.req.path }, 'Unhandled error')
+    return c.json(
+      { success: false as const, error: err.message || 'Internal server error', status: 500 },
+      500
+    )
+  })
+
+  return app
+}
+export type AdminApiType = typeof adminApiRoutes
+export type ClientApiType = typeof clientApiRoutes
+export type AppType = ReturnType<typeof createApp>
+`;
+}
+
+// src/generators/shared-modules-index.ts
+var MODULE_EXPORTS = {
+  chat: {
+    namedExports: ["ChatProtocolSchema", "type ChatProtocol"]
+  },
+  todos: {
+    namedExports: [
+      "TodoSchema",
+      "TodoStatusSchema",
+      "CreateTodoSchema",
+      "UpdateTodoSchema",
+      "TodoIdSchema",
+      "type Todo",
+      "type TodoStatus",
+      "type CreateTodoInput",
+      "type UpdateTodoInput"
+    ]
+  },
+  files: {
+    namedExports: [
+      "FileDownloadSchema",
+      "PrivateFileQuerySchema",
+      "PublicFileUrlSchema",
+      "PrivateFileUrlSchema",
+      "GenerateUrlRequestSchema",
+      "FileUrlResponseSchema",
+      "EmptySchema"
+    ]
+  },
+  notifications: {
+    namedExports: [
+      "NotificationSchema",
+      "NotificationTypeSchema",
+      "CreateNotificationSchema",
+      "NotificationListQuerySchema",
+      "SSEEventSchema",
+      "AppSSEProtocolSchema",
+      "type AppNotification",
+      "type NotificationType",
+      "type CreateNotificationInput",
+      "type NotificationListQuery",
+      "type SSEEvent",
+      "type AppSSEProtocol"
+    ]
+  },
+  admin: {
+    namedExports: [
+      "SystemStatsSchema",
+      "HealthCheckSchema",
+      "RecentActivityItemSchema",
+      "RecentActivitySchema",
+      "AuthUserSchema",
+      "ClearTodosResultSchema",
+      "type SystemStats",
+      "type HealthCheck",
+      "type RecentActivityItem",
+      "type AuthUserResponse",
+      "type ClearTodosResult"
+    ]
+  },
+  permission: {
+    namedExports: [
+      "RoleEnum",
+      "RoleInfoSchema",
+      "PermissionInfoSchema",
+      "UserPermissionsSchema",
+      "RoleListSchema",
+      "PermissionListSchema",
+      "Role",
+      "Permission",
+      "ROLE_PERMISSIONS",
+      "ROLE_LABELS",
+      "PERMISSION_LABELS",
+      "PERMISSION_CATEGORIES",
+      "getPermissionsByRole",
+      "hasPermission",
+      "hasAnyPermission",
+      "hasAllPermissions",
+      "type RoleType",
+      "type RoleInfo",
+      "type PermissionInfo",
+      "type UserPermissions"
+    ]
+  }
+};
+function generateSharedModulesIndex(resolved) {
+  const lines = [];
+  const moduleOrder = ["chat", "todos", "file", "notifications", "admin", "permission"];
+  for (const moduleName of moduleOrder) {
+    if (!resolved.modules.has(moduleName)) continue;
+    const manifest = resolved.modules.get(moduleName);
+    const exportKey = manifest.sharedSchemas?.path ?? moduleName;
+    const exports$1 = MODULE_EXPORTS[exportKey];
+    if (!exports$1) continue;
+    lines.push(`export {
+  ${exports$1.namedExports.join(",\n  ")},
+} from './${exportKey}'`);
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/generators/shared-schemas-index.ts
+var MODULE_EXPORTS2 = {
+  chat: {
+    namedExports: [
+      "ChatProtocolSchema",
+      "WebSocketStatusSchema",
+      "type ChatProtocol",
+      "type WebSocketStatus"
+    ]
+  },
+  file: {
+    namedExports: [
+      "FileDownloadSchema",
+      "PrivateFileQuerySchema",
+      "PublicFileUrlSchema",
+      "PrivateFileUrlSchema",
+      "GenerateUrlRequestSchema",
+      "FileUrlResponseSchema",
+      "EmptySchema",
+      "UploadResultSchema",
+      "UploadFileBodySchema"
+    ]
+  },
+  todos: {
+    namedExports: [
+      "TodoSchema",
+      "TodoStatusSchema",
+      "CreateTodoSchema",
+      "UpdateTodoSchema",
+      "TodoIdSchema",
+      "TodoIdResponseSchema",
+      "TodoAttachmentSchema",
+      "TodoAttachmentListSchema",
+      "TodoWithAttachmentsSchema",
+      "UploadFileSchema",
+      "AttachmentIdResponseSchema",
+      "type Todo",
+      "type TodoStatus",
+      "type CreateTodoInput",
+      "type UpdateTodoInput",
+      "type TodoIdResponse",
+      "type TodoAttachment",
+      "type TodoWithAttachments"
+    ]
+  },
+  notifications: {
+    namedExports: [
+      "NotificationSchema",
+      "NotificationTypeSchema",
+      "CreateNotificationSchema",
+      "NotificationListQuerySchema",
+      "SSEEventSchema",
+      "AppSSEProtocolSchema",
+      "UnreadCountSchema",
+      "NotificationIdSchema",
+      "UnreadCountEventSchema",
+      "type AppNotification",
+      "type NotificationType",
+      "type CreateNotificationInput",
+      "type NotificationListQuery",
+      "type SSEEvent",
+      "type AppSSEProtocol",
+      "type UnreadCount",
+      "type NotificationId",
+      "type UnreadCountEvent"
+    ]
+  }
+};
+function generateSharedSchemasIndex(resolved) {
+  const header = `// Re-export interfaces from implementation files
+export type { WSClient, WSProtocol, WSStatus } from '../core/ws-client'
+export type { SSEClient, SSEProtocol } from '../core/sse-client'
+
+// Re-export core
+export {
+  ApiSuccessSchema,
+  ApiErrorSchema,
+  ApiResponseSchema,
+  type ApiSuccess,
+  type ApiError,
+  type ApiResponse,
+  type RpcMethod,
+  type EventName,
+  type RpcInput,
+  type RpcOutput,
+  type EventPayload,
+  createWSClient,
+  createSSEClient,
+} from '../core'
+
+// Re-export modules
+`;
+  const moduleLines = [];
+  const moduleOrder = ["chat", "file", "todos", "notifications"];
+  for (const moduleName of moduleOrder) {
+    if (!resolved.modules.has(moduleName)) continue;
+    const exports$1 = MODULE_EXPORTS2[moduleName];
+    if (!exports$1) continue;
+    const manifest = resolved.modules.get(moduleName);
+    const importPath = manifest.sharedSchemas?.path ?? moduleName;
+    moduleLines.push(
+      `export {
+  ${exports$1.namedExports.join(",\n  ")},
+} from '../modules/${importPath}'`
+    );
+  }
+  return header + moduleLines.join("\n") + "\n";
+}
+
+// src/generators/middleware-index.ts
+function generateMiddlewareIndex(resolved) {
+  const lines = [];
+  lines.push(`export { corsMiddleware, createCorsMiddleware, type CorsOptions } from './cors'`);
+  lines.push(
+    `export { loggerMiddleware, createLoggerMiddleware, type LoggerOptions } from './logger'`
+  );
+  lines.push(
+    `export {
+  errorHandlerMiddleware,
+  createErrorHandlerMiddleware,
+  type ErrorHandlerOptions,
+} from './error-handler'`
+  );
+  if (resolved.hasPermission) {
+    lines.push(
+      `export {
+  authMiddleware,
+  requireSuperAdminMiddleware,
+  requireCustomerServiceMiddleware,
+  requirePermissionsMiddleware,
+  type AuthUser,
+  type AuthMiddlewareOptions,
+} from './auth'`
+    );
+  }
+  if (resolved.hasCaptcha) {
+    lines.push(
+      `export {
+  captchaMiddleware,
+  markCaptchaVerifiedMiddleware,
+  clearCaptchaSessionMiddleware,
+  type CaptchaConfig,
+} from './captcha'`
+    );
+  }
+  if (resolved.hasPermission) {
+    lines.push(`export { permissionMiddleware } from './permission'`);
+  }
+  lines.push(`export { rateLimitMiddleware, type RateLimitOptions } from './rate-limit'`);
+  if (resolved.hasPermission) {
+    lines.push(`export { getAuthUser } from '../utils/auth'`);
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/generators/auth-middleware.ts
+function generateAuthMiddleware(_resolved) {
+  return `import type { MiddlewareHandler } from 'hono'
+import { createModuleLoggerSync } from '../utils/logger'
+
+export type UserRole = 'user' | 'admin'
+
+export interface AuthUser {
+  id: string
+  username: string
+  email: string
+  role: UserRole
+  avatar?: string
+}
+
+export interface AuthMiddlewareOptions {
+  requiredRole?: UserRole
+}
+
+declare module 'hono' {
+  interface ContextVariableMap {
+    authUser: AuthUser
+  }
+}
+
+const DEV_USER: AuthUser = {
+  id: 'dev-user-1',
+  username: 'devuser',
+  email: 'dev@example.com',
+  role: 'admin',
+  avatar: 'https://api.dicebear.com/7.x/avataaars/svg?seed=dev',
+}
+
+function extractToken(authHeader: string | undefined): string | null {
+  if (!authHeader) return null
+  if (!authHeader.startsWith('Bearer ')) return null
+  return authHeader.slice(7)
+}
+
+export function authMiddleware(_options: AuthMiddlewareOptions = {}): MiddlewareHandler {
+  const log = createModuleLoggerSync('auth')
+
+  return async (c, next) => {
+    const token = extractToken(c.req.header('Authorization'))
+
+    if (!token) {
+      c.set('authUser', { ...DEV_USER, id: 'anonymous' })
+      log.info({ path: c.req.path }, 'Anonymous access')
+      await next()
+      return
+    }
+
+    c.set('authUser', DEV_USER)
+    log.info({ userId: DEV_USER.id, path: c.req.path }, 'Dev user authenticated')
+    await next()
+  }
+}
+
+export function requireSuperAdminMiddleware(): MiddlewareHandler {
+  return authMiddleware()
+}
+
+export function requireCustomerServiceMiddleware(): MiddlewareHandler {
+  return authMiddleware()
+}
+
+export function requirePermissionsMiddleware(): MiddlewareHandler {
+  return authMiddleware()
+}
+`;
+}
+
+// src/generators/auth-utils.ts
+function generateAuthUtils(resolved) {
+  if (!resolved.hasPermission) {
+    return `import type { Context } from 'hono'
+import type { AuthUser } from '../middleware/auth'
+
+export function getAuthUser(c: Context): AuthUser {
+  return c.get('authUser')
+}
+`;
+  }
+  return `import type { Context } from 'hono'
+import type { AuthUser } from '../middleware/auth'
+import { Role } from '@shared/modules/permission'
+
+interface MockUser {
+  id: string
+  username: string
+  email: string
+  role: string
+  status: string
+  avatar: string
+  createdAt: string
+  updatedAt: string
+}
+
+const mockUsers: MockUser[] = [
+  {
+    id: '1',
+    username: 'superadmin',
+    email: 'superadmin@example.com',
+    role: Role.SUPER_ADMIN,
+    status: 'active',
+    avatar: 'https://api.dicebear.com/7.x/avataaars/svg?seed=superadmin',
+    createdAt: '2024-01-01T00:00:00Z',
+    updatedAt: '2024-01-01T00:00:00Z',
+  },
+  {
+    id: '2',
+    username: 'customerservice',
+    email: 'customerservice@example.com',
+    role: Role.CUSTOMER_SERVICE,
+    status: 'active',
+    avatar: 'https://api.dicebear.com/7.x/avataaars/svg?seed=customerservice',
+    createdAt: '2024-01-02T00:00:00Z',
+    updatedAt: '2024-01-02T00:00:00Z',
+  },
+  {
+    id: '3',
+    username: 'user1',
+    email: 'user1@example.com',
+    role: Role.USER,
+    status: 'active',
+    avatar: 'https://api.dicebear.com/7.x/avataaars/svg?seed=user1',
+    createdAt: '2024-01-03T00:00:00Z',
+    updatedAt: '2024-01-03T00:00:00Z',
+  },
+]
+
+const mockTokens: Map<string, string> = new Map([
+  ['super-admin-token', '1'],
+  ['customer-service-token', '2'],
+  ['user-token', '3'],
+])
+
+export function getAuthUser(c: Context): AuthUser {
+  return c.get('authUser')
+}
+
+export function verifyToken(token: string): MockUser | null {
+  const userId = mockTokens.get(token)
+
+  if (!userId) {
+    return null
+  }
+
+  return mockUsers.find(u => u.id === userId) || null
+}
+
+export function getMockUsers(): MockUser[] {
+  return mockUsers
+}
+
+export function getMockTokens(): Map<string, string> {
+  return mockTokens
+}
+`;
+}
+
+// src/generators/client-components-index.ts
+function generateClientComponentsIndex(resolved) {
+  const lines = [];
+  lines.push(`export { StatusBadge, type ColorScheme } from './StatusBadge'`);
+  lines.push(`export { LoadingSpinner } from './LoadingSpinner'`);
+  lines.push(`export { EmptyState } from './EmptyState'`);
+  if (resolved.modules.has("chat") || resolved.modules.has("notifications")) {
+    lines.push(`export { ConnectionStatus } from './ConnectionStatus'`);
+  }
+  if (resolved.modules.has("chat")) {
+    lines.push(`export { MessageCard } from './MessageCard'`);
+  }
+  if (resolved.modules.has("admin")) {
+    lines.push(`export { AuthButton } from './AuthButton'`);
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/generators/cli-modules-index.ts
+function generateCliModulesIndex(resolved) {
+  const modules = [];
+  const registrations = [];
+  if (resolved.modules.has("todos")) {
+    modules.push("import { registerTodoCommands } from './todo'");
+    registrations.push("registerTodoCommands(program)");
+  }
+  if (resolved.modules.has("notifications")) {
+    modules.push(
+      "import { registerNotificationCommands } from './notification'"
+    );
+    registrations.push("registerNotificationCommands(program)");
+  }
+  modules.push("import { registerConfigCommands } from './config'");
+  registrations.push("registerConfigCommands(program)");
+  const imports = `import type { Command } from 'commander'
+${modules.join("\n")}`;
+  const exports$1 = modules.map((m) => {
+    const match = m.match(/\{ (\w+) \}/);
+    return match ? match[1] : "";
+  }).filter(Boolean);
+  return `${imports}
+
+export function registerModules(program: Command) {
+${registrations.map((r) => `  ${r}`).join("\n")}
+}
+
+export { ${exports$1.join(", ")} }
+`;
+}
+
+// src/generators/package-json.ts
+var MODULE_PACKAGES = {
+  admin: ["bcryptjs"]
+};
+var ADMIN_PANEL_PACKAGES = ["antd"];
+var CLI_PACKAGES = ["commander"];
+var UNUSED_PACKAGES = ["lodash-es", "chalk", "mysql2"];
+function filterPackageJson(pkg, resolved) {
+  const result = { ...pkg };
+  const packagesToRemove = new Set(UNUSED_PACKAGES);
+  for (const [module, packages] of Object.entries(MODULE_PACKAGES)) {
+    if (!resolved.modules.has(module)) {
+      for (const pkg2 of packages) {
+        packagesToRemove.add(pkg2);
+      }
+    }
+  }
+  if (!resolved.modules.has("admin")) {
+    for (const pkg2 of ADMIN_PANEL_PACKAGES) {
+      packagesToRemove.add(pkg2);
+    }
+  }
+  if (!resolved.modules.has("admin")) {
+    for (const pkg2 of CLI_PACKAGES) {
+      packagesToRemove.add(pkg2);
+    }
+  }
+  if (result.dependencies && typeof result.dependencies === "object") {
+    const deps = { ...result.dependencies };
+    for (const pkg2 of packagesToRemove) {
+      delete deps[pkg2];
+    }
+    result.dependencies = deps;
+  }
+  if (result.devDependencies && typeof result.devDependencies === "object") {
+    const devDeps = { ...result.devDependencies };
+    if (!resolved.modules.has("admin")) {
+      delete devDeps["@testing-library/user-event"];
+    }
+    result.devDependencies = devDeps;
+  }
+  return result;
+}
+function generateViteConfig(resolved, templateDir) {
+  const originalPath = join(templateDir, "vite.config.ts");
+  let content = readFileSync(originalPath, "utf-8");
+  if (!resolved.modules.has("admin")) {
+    content = content.replace(
+      /,\n\s*admin:\s*path\.resolve\(__dirname,\s*['"]admin\.html['"]\)/,
+      ""
+    );
+  }
+  return content;
+}
+
+// src/commands/create.ts
+var __filename$1 = fileURLToPath(import.meta.url);
+var __dirname$1 = path2.dirname(__filename$1);
+var TEMPLATE_PROJECT_NAME = "biomimic-todo-app";
+var TEMPLATE_DB_NAME = "biomimic-todo-db";
+var ScaffoldError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ScaffoldError";
+  }
+};
+function validateProjectName(name) {
+  if (!name || name.trim().length === 0) {
+    throw new ScaffoldError("Project name cannot be empty");
+  }
+  const validNameRegex = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+  if (!validNameRegex.test(name)) {
+    throw new ScaffoldError(
+      `Invalid project name "${name}". Use lowercase letters, numbers, hyphens, and underscores only.`
+    );
+  }
+  if (name.length > 214) {
+    throw new ScaffoldError("Project name must be 214 characters or less");
+  }
+  if (name.includes("..") || name.includes("/") || name.includes("\\")) {
+    throw new ScaffoldError("Project name cannot contain path separators");
+  }
+}
+function parseGitignore(content) {
+  const negatePatterns = [];
+  const includePatterns = content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map((line) => {
+    if (line.startsWith("!")) {
+      negatePatterns.push(line.slice(1));
+      return null;
+    }
+    return line;
+  }).filter((line) => line !== null).map((pattern) => pattern.replace(/\/$/, "")).map((pattern) => pattern.replace(/^\*\./, "")).map((pattern) => pattern.replace(/^\/+/, "")).filter((pattern) => !pattern.includes("*"));
+  return [...includePatterns, ...negatePatterns.map((p) => `!${p}`)];
+}
+function generateDbName(projectName) {
+  const sanitized = projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return `${sanitized}-db`;
+}
+async function updateWranglerToml(targetDir, projectName) {
+  const wranglerPath = path2.join(targetDir, "wrangler.toml");
+  if (!await fs2.pathExists(wranglerPath)) {
+    return;
+  }
+  let content = await fs2.readFile(wranglerPath, "utf-8");
+  const dbName = generateDbName(projectName);
+  content = content.replace(
+    new RegExp(`^name = "${TEMPLATE_PROJECT_NAME}"`, "m"),
+    `name = "${projectName}"`
+  );
+  content = content.replace(
+    new RegExp(`database_name = "${TEMPLATE_DB_NAME}"`, "g"),
+    `database_name = "${dbName}"`
+  );
+  content = content.replace(
+    /database_id = "[^"]+"/,
+    `database_id = ""  # TODO: Run 'wrangler d1 create ${dbName}' and paste the ID here`
+  );
+  await fs2.writeFile(wranglerPath, content);
+}
+async function updatePackageJson(targetDir, projectName, resolved) {
+  const pkgJsonPath = path2.join(targetDir, "package.json");
+  if (!await fs2.pathExists(pkgJsonPath)) {
+    return;
+  }
+  let pkgJson = await fs2.readJson(pkgJsonPath);
+  pkgJson = filterPackageJson(pkgJson, resolved);
+  pkgJson.name = projectName;
+  if (pkgJson.bin) {
+    delete pkgJson.bin;
+  }
+  await fs2.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
+}
+async function updatePackageLockJson(targetDir, projectName) {
+  const lockFilePath = path2.join(targetDir, "package-lock.json");
+  if (!await fs2.pathExists(lockFilePath)) {
+    return;
+  }
+  const lockFile = await fs2.readJson(lockFilePath);
+  if (lockFile.name === TEMPLATE_PROJECT_NAME) {
+    lockFile.name = projectName;
+  }
+  if (lockFile.packages?.[""]?.name === TEMPLATE_PROJECT_NAME) {
+    lockFile.packages[""].name = projectName;
+  }
+  await fs2.writeJson(lockFilePath, lockFile, { spaces: 2 });
+}
+async function updateReadme(targetDir, projectName) {
+  const readmePath = path2.join(targetDir, "README.md");
+  if (!await fs2.pathExists(readmePath)) {
+    return;
+  }
+  let content = await fs2.readFile(readmePath, "utf-8");
+  content = content.replace(/^# (.+)$/m, `# ${projectName}`);
+  await fs2.writeFile(readmePath, content);
+}
+async function createProject(projectNameOrOptions, useCurrentDir = false, preset) {
+  let projectName;
+  let currentDir;
+  let presetId;
+  let outputDir;
+  let dryRun;
+  if (typeof projectNameOrOptions === "string") {
+    projectName = projectNameOrOptions;
+    currentDir = useCurrentDir;
+    presetId = preset;
+    dryRun = false;
+  } else {
+    projectName = projectNameOrOptions.projectName;
+    currentDir = projectNameOrOptions.currentDir;
+    presetId = projectNameOrOptions.preset;
+    outputDir = projectNameOrOptions.outputDir;
+    dryRun = projectNameOrOptions.dryRun ?? false;
+  }
+  if (!currentDir) {
+    validateProjectName(projectName);
+  }
+  const templateDir = path2.join(__dirname$1, "../../template");
+  let targetDir;
+  if (currentDir) {
+    targetDir = process.cwd();
+    projectName = path2.basename(targetDir);
+  } else if (outputDir) {
+    targetDir = path2.resolve(outputDir);
+    if (await fs2.pathExists(targetDir)) {
+      throw new ScaffoldError(`Directory ${outputDir} already exists`);
+    }
+  } else {
+    targetDir = path2.resolve(process.cwd(), projectName);
+    if (await fs2.pathExists(targetDir)) {
+      throw new ScaffoldError(`Directory ${projectName} already exists`);
+    }
+  }
+  try {
+    const manifestSpinner = ora("Loading module manifests...").start();
+    const allManifests = await loadManifests(templateDir);
+    const presets = await loadPresets(templateDir);
+    const selectedPresetId = presetId || "fullstack-admin";
+    const selectedPreset = presets.find((p) => p.id === selectedPresetId);
+    if (!selectedPreset) {
+      throw new ScaffoldError(
+        `Unknown preset: ${selectedPresetId}. Available: ${presets.map((p) => p.id).join(", ")}`
+      );
+    }
+    const resolved = resolvePreset(selectedPreset, allManifests);
+    manifestSpinner.succeed(
+      chalk.green(`Using preset: ${selectedPreset.name} (${resolved.modules.size} modules)`)
+    );
+    if (dryRun) {
+      const resolvedModuleNames = [...resolved.modules.keys()];
+      const generatedFiles2 = getGeneratedFiles(resolved);
+      console.log("");
+      console.log(chalk.blue("\u{1F4CB} Dry Run - Files that would be generated:\n"));
+      for (const file of generatedFiles2) {
+        console.log(`  ${chalk.green("\u2713")} ${file}`);
+      }
+      const gitignorePath2 = path2.join(templateDir, ".gitignore");
+      let ignorePatterns2 = [];
+      if (await fs2.pathExists(gitignorePath2)) {
+        const gitignoreContent = await fs2.readFile(gitignorePath2, "utf-8");
+        ignorePatterns2 = parseGitignore(gitignoreContent);
+      }
+      ignorePatterns2.push("node_modules", ".wrangler");
+      const excludePatterns2 = getExcludePatterns(resolved, allManifests);
+      let templateFileCount = 0;
+      const templateFiles = await fs2.readdir(templateDir, { recursive: true });
+      for (const file of templateFiles) {
+        const relative = String(file);
+        if (!relative) continue;
+        const negated = ignorePatterns2.filter((p) => p.startsWith("!"));
+        const gitIgnored = ignorePatterns2.filter(
+          (p) => !p.startsWith("!") && relative.startsWith(p)
+        );
+        if (gitIgnored.length > 0) {
+          const allowed = negated.some((p) => relative === p.slice(1));
+          if (!allowed) continue;
+        }
+        const normalizedRelative = relative.replace(/\\/g, "/");
+        let excluded = false;
+        for (const pattern of excludePatterns2) {
+          const normalizedPattern = pattern.replace(/\\/g, "/");
+          if (normalizedRelative === normalizedPattern || normalizedRelative.startsWith(normalizedPattern + "/")) {
+            excluded = true;
+            break;
+          }
+        }
+        if (!excluded) templateFileCount++;
+      }
+      console.log("");
+      console.log(chalk.blue("\u{1F4C1} Template files that would be copied:\n"));
+      console.log(`  ${chalk.green("\u2713")} ${templateFileCount} template files`);
+      console.log("");
+      console.log(chalk.yellow(`  Total generated files: ${generatedFiles2.length}`));
+      console.log(chalk.yellow(`  Preset: ${selectedPreset.name}`));
+      console.log(chalk.yellow(`  Modules: ${resolvedModuleNames.join(", ")}`));
+      console.log("");
+      return;
+    }
+    if (!currentDir) {
+      const dirSpinner = ora("Creating project directory...").start();
+      await fs2.ensureDir(targetDir);
+      dirSpinner.succeed(chalk.green("Project directory created"));
+    }
+    const copySpinner = ora("Copying template files...").start();
+    const gitignorePath = path2.join(templateDir, ".gitignore");
+    let ignorePatterns = [];
+    if (await fs2.pathExists(gitignorePath)) {
+      const gitignoreContent = await fs2.readFile(gitignorePath, "utf-8");
+      ignorePatterns = parseGitignore(gitignoreContent);
+    }
+    ignorePatterns.push("node_modules", ".wrangler");
+    const excludePatterns = getExcludePatterns(resolved, allManifests);
+    await fs2.copy(templateDir, targetDir, {
+      filter: (src) => {
+        const relative = path2.relative(templateDir, src);
+        if (relative === "") return true;
+        const negated = ignorePatterns.filter((p) => p.startsWith("!"));
+        const gitIgnored = ignorePatterns.filter((p) => !p.startsWith("!") && relative.startsWith(p));
+        if (gitIgnored.length > 0) {
+          const allowed = negated.some((p) => relative === p.slice(1));
+          if (!allowed) return false;
+        }
+        const normalizedRelative = relative.replace(/\\/g, "/");
+        for (const pattern of excludePatterns) {
+          const normalizedPattern = pattern.replace(/\\/g, "/");
+          if (normalizedRelative === normalizedPattern || normalizedRelative.startsWith(normalizedPattern + "/")) {
+            return false;
+          }
+        }
+        return true;
+      },
+      dereference: false
+    });
+    copySpinner.succeed(chalk.green("Template files copied"));
+    const genSpinner = ora("Generating module-specific files...").start();
+    const routeRegistryContent = generateRouteRegistry(resolved);
+    await fs2.writeFile(path2.join(targetDir, "src/server/route-registry.ts"), routeRegistryContent);
+    const dbSchemaContent = generateDbSchemaBarrel(resolved);
+    await fs2.writeFile(path2.join(targetDir, "src/server/db/schema/index.ts"), dbSchemaContent);
+    const clientAppContent = generateClientApp(resolved);
+    await fs2.writeFile(path2.join(targetDir, "src/client/App.tsx"), clientAppContent);
+    const clientNavContent = generateClientNavigation(resolved);
+    await fs2.writeFile(
+      path2.join(targetDir, "src/client/components/Navigation.tsx"),
+      clientNavContent
+    );
+    if (resolved.modules.has("admin")) {
+      const adminAppContent = generateAdminApp(resolved);
+      if (adminAppContent) {
+        await fs2.ensureDir(path2.join(targetDir, "src/admin"));
+        await fs2.writeFile(path2.join(targetDir, "src/admin/App.tsx"), adminAppContent);
+      }
+    }
+    const serverAppContent = generateServerApp(resolved);
+    await fs2.writeFile(path2.join(targetDir, "src/server/app.ts"), serverAppContent);
+    const generatedFiles = getGeneratedFiles(resolved);
+    if (generatedFiles.includes("src/server/db/init.ts")) {
+      const dbInitContent = generateDbInit(resolved);
+      await fs2.writeFile(path2.join(targetDir, "src/server/db/init.ts"), dbInitContent);
+    }
+    const sharedModulesContent = generateSharedModulesIndex(resolved);
+    await fs2.writeFile(path2.join(targetDir, "src/shared/modules/index.ts"), sharedModulesContent);
+    const sharedSchemasContent = generateSharedSchemasIndex(resolved);
+    await fs2.writeFile(path2.join(targetDir, "src/shared/schemas/index.ts"), sharedSchemasContent);
+    const middlewareIndexContent = generateMiddlewareIndex(resolved);
+    await fs2.writeFile(
+      path2.join(targetDir, "src/server/middleware/index.ts"),
+      middlewareIndexContent
+    );
+    if (generatedFiles.includes("src/server/middleware/auth.ts")) {
+      const authMiddlewareContent = generateAuthMiddleware(resolved);
+      await fs2.writeFile(
+        path2.join(targetDir, "src/server/middleware/auth.ts"),
+        authMiddlewareContent
+      );
+    }
+    if (generatedFiles.includes("src/server/utils/auth.ts")) {
+      const authUtilsContent = generateAuthUtils(resolved);
+      await fs2.writeFile(path2.join(targetDir, "src/server/utils/auth.ts"), authUtilsContent);
+    }
+    const clientComponentsContent = generateClientComponentsIndex(resolved);
+    await fs2.writeFile(
+      path2.join(targetDir, "src/client/components/index.ts"),
+      clientComponentsContent
+    );
+    if (resolved.modules.has("admin")) {
+      const cliModulesContent = generateCliModulesIndex(resolved);
+      await fs2.writeFile(path2.join(targetDir, "src/cli/modules/index.ts"), cliModulesContent);
+    }
+    if (generatedFiles.includes("vite.config.ts")) {
+      const viteConfigContent = generateViteConfig(resolved, templateDir);
+      await fs2.writeFile(path2.join(targetDir, "vite.config.ts"), viteConfigContent);
+    }
+    genSpinner.succeed(chalk.green("Module-specific files generated"));
+    const pkgSpinner = ora("Configuring package.json...").start();
+    await updatePackageJson(targetDir, projectName, resolved);
+    pkgSpinner.succeed(chalk.green("package.json configured"));
+    const lockSpinner = ora("Configuring package-lock.json...").start();
+    await updatePackageLockJson(targetDir, projectName);
+    lockSpinner.succeed(chalk.green("package-lock.json configured"));
+    const wranglerSpinner = ora("Configuring wrangler.toml...").start();
+    await updateWranglerToml(targetDir, projectName);
+    wranglerSpinner.succeed(chalk.green("wrangler.toml configured"));
+    const readmeSpinner = ora("Configuring README.md...").start();
+    await updateReadme(targetDir, projectName);
+    readmeSpinner.succeed(chalk.green("README.md configured"));
+    console.log("");
+    console.log(chalk.green("  \u2713 Project created successfully!"));
+    console.log(chalk.gray(`   Preset: ${selectedPreset.name}`));
+    console.log(chalk.gray(`   Modules: ${[...resolved.modules.keys()].join(", ")}`));
+    console.log("");
+    console.log(chalk.cyan("  Next steps:"));
+    if (!currentDir && !outputDir) {
+      console.log(chalk.white(`    cd ${projectName}`));
+    }
+    console.log(chalk.white("    npm install"));
+    console.log(chalk.white("    npm run dev"));
+    console.log("");
+    console.log(chalk.yellow("  \u26A0\uFE0F  Cloudflare Setup:"));
+    console.log(
+      chalk.white(`    1. Create D1 database: wrangler d1 create ${generateDbName(projectName)}`)
+    );
+    console.log(chalk.white("    2. Copy the database ID to wrangler.toml"));
+    console.log(chalk.white("    3. Deploy: npm run deploy:cf"));
+    console.log("");
+    console.log(chalk.gray("  Happy coding! \u{1F41F}"));
+    console.log("");
+  } catch (error) {
+    if (error instanceof ScaffoldError) throw error;
+    throw new ScaffoldError(`Error creating project: ${error}`);
+  }
+}
 
 // src/cli/index.ts
-program.name("biomimic").description("Biomimic CLI - RPC service & code generation tools").version("0.1.0").option("-v, --verbose", "Enable verbose output").option("-u, --url <url>", "Server URL", "http://localhost:3010").hook("preAction", (thisCommand) => {
+var MODULE_COMMANDS = ["todo", "notification", "config"];
+program.name("create-fullstack-scaffold").description("Create a new fullstack scaffolded project").version("0.1.1").argument("[project-name]", "Name of the project to create").option("-v, --verbose", "Enable verbose output").option("-u, --url <url>", "Server URL", "http://localhost:3010").option("-p, --preset <preset>", "Template preset to use", "fullstack-admin").option("-d, --dry-run", "Preview files without creating them").option("--current-dir", "Scaffold in the current directory").action(async (projectName, cmdOptions) => {
+  if (projectName && !MODULE_COMMANDS.includes(projectName)) {
+    const isCurrentDir = cmdOptions.currentDir === true || projectName === ".";
+    createLogger({ verbose: cmdOptions.verbose });
+    const options = {
+      projectName: isCurrentDir ? "." : projectName,
+      currentDir: isCurrentDir,
+      preset: cmdOptions.preset,
+      dryRun: cmdOptions.dryRun
+    };
+    await createProject(options).catch((err) => {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    });
+    return;
+  }
+  if (!projectName) {
+    program.outputHelp();
+    process.exit(1);
+  }
+});
+program.hook("preAction", (thisCommand) => {
   const options = thisCommand.opts();
   createLogger({ verbose: options.verbose });
   if (options.url) {