npm - @mars-stack/cli - Versions diffs - 1.0.2 → 2.0.1 - Mend

@mars-stack/cli 1.0.2 → 2.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/dist/index.js +539 -355
package/dist/index.js.map +1 -1
package/package.json +3 -3
package/template/package.json +4 -4
package/template/src/app/(auth)/forgotten-password/page.tsx +18 -0
package/template/src/app/(auth)/register/page.tsx +3 -0
package/template/src/app/(auth)/verify/page.tsx +19 -0
package/template/src/app/(protected)/layout.tsx +18 -0
package/template/src/app/api/auth/forgot/route.ts +7 -1
package/template/src/app/api/auth/signup/route.ts +9 -0
package/template/src/config/app.config.ts +0 -8
package/template/src/config/routes.ts +2 -0

package/dist/index.js CHANGED Viewed

@@ -45,7 +45,7 @@ var init_logger = __esm({
 // src/utils/rollback.ts
 import fs3 from "fs-extra";
-import path3 from "path";
+import path4 from "path";
 import os from "os";
 function createRollbackContext() {
   const manifest = {
@@ -53,14 +53,14 @@ function createRollbackContext() {
     filesModified: [],
     depsInstalled: []
   };
-  const backupDir = path3.join(os.tmpdir(), `mars-rollback-${Date.now()}`);
+  const backupDir = path4.join(os.tmpdir(), `mars-rollback-${Date.now()}`);
   function trackCreatedFile(filePath) {
     manifest.filesCreated.push(filePath);
   }
   async function trackModifiedFile(filePath) {
     if (!await fs3.pathExists(filePath)) return;
     await fs3.ensureDir(backupDir);
-    const backupPath = path3.join(backupDir, `${manifest.filesModified.length}-${path3.basename(filePath)}`);
+    const backupPath = path4.join(backupDir, `${manifest.filesModified.length}-${path4.basename(filePath)}`);
     await fs3.copy(filePath, backupPath);
     manifest.filesModified.push({ path: filePath, backup: backupPath });
   }
@@ -109,9 +109,9 @@ var init_rollback = __esm({
 // src/utils/dependencies.ts
 import fs4 from "fs-extra";
-import path4 from "path";
+import path5 from "path";
 async function addDependencies(projectRoot, deps, dev = false) {
-  const pkgPath = path4.join(projectRoot, "package.json");
+  const pkgPath = path5.join(projectRoot, "package.json");
   if (!await fs4.pathExists(pkgPath)) return;
   const pkg = await fs4.readJson(pkgPath);
   const key = dev ? "devDependencies" : "dependencies";
@@ -124,16 +124,40 @@ var init_dependencies = __esm({
   }
 });
+// src/utils/routes.ts
+import fs5 from "fs-extra";
+import path6 from "path";
+async function registerRoute(projectRoot, key, routePath, ctx) {
+  const routesFile = path6.join(projectRoot, "src", "config", "routes.ts");
+  if (!await fs5.pathExists(routesFile)) return;
+  let content = await fs5.readFile(routesFile, "utf-8");
+  if (content.includes(`${key}:`)) return;
+  if (ctx) {
+    await ctx.trackModifiedFile(routesFile);
+  }
+  content = content.replace(
+    /} as const;/,
+    `  ${key}: '${routePath}',
+} as const;`
+  );
+  await fs5.writeFile(routesFile, content);
+}
+var init_routes = __esm({
+  "src/utils/routes.ts"() {
+    "use strict";
+  }
+});
 // src/generators/features/blog.ts
 var blog_exports = {};
 __export(blog_exports, {
   generateBlog: () => generateBlog
 });
-import fs5 from "fs-extra";
-import path5 from "path";
+import fs6 from "fs-extra";
+import path7 from "path";
 async function generateBlog(projectRoot) {
-  const featureDir = path5.join(projectRoot, "src", "features", "blog");
-  if (await fs5.pathExists(featureDir)) {
+  const featureDir = path7.join(projectRoot, "src", "features", "blog");
+  if (await fs6.pathExists(featureDir)) {
     log.error("Blog feature already exists at src/features/blog/");
     return;
   }
@@ -154,10 +178,10 @@ async function generateBlog(projectRoot) {
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path5.join(projectRoot, filePath);
+      const fullPath = path7.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs5.ensureDir(path5.dirname(fullPath));
-      await fs5.writeFile(fullPath, content);
+      await fs6.ensureDir(path7.dirname(fullPath));
+      await fs6.writeFile(fullPath, content);
       count++;
     }
     await addDependencies(projectRoot, {
@@ -168,6 +192,7 @@ async function generateBlog(projectRoot) {
       "remark-gfm": "^4.0.0"
     });
     await addDependencies(projectRoot, { "@types/mdx": "^2.0.0" }, true);
+    await registerRoute(projectRoot, "blog", "/blog", ctx);
     await setConfigFlag(projectRoot, ctx);
     await ctx.commit();
     log.success(`Generated blog feature with ${count} files`);
@@ -183,12 +208,12 @@ async function generateBlog(projectRoot) {
   }
 }
 async function setConfigFlag(projectRoot, ctx) {
-  const configPath = path5.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs5.pathExists(configPath)) return;
+  const configPath = path7.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs6.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs5.readFile(configPath, "utf-8");
+  const content = await fs6.readFile(configPath, "utf-8");
   const updated = content.replace(/blog:\s*false/, "blog: true");
-  await fs5.writeFile(configPath, updated);
+  await fs6.writeFile(configPath, updated);
 }
 function schemas() {
   return `${STAMP}
@@ -681,6 +706,7 @@ var init_blog = __esm({
     init_logger();
     init_rollback();
     init_dependencies();
+    init_routes();
     GENERATOR_VERSION = "0.1.0";
     STAMP = `// @mars-generated blog@${GENERATOR_VERSION}`;
   }
@@ -706,11 +732,11 @@ var dark_mode_exports = {};
 __export(dark_mode_exports, {
   generateDarkMode: () => generateDarkMode
 });
-import fs6 from "fs-extra";
-import path6 from "path";
+import fs7 from "fs-extra";
+import path8 from "path";
 async function generateDarkMode(projectRoot) {
-  const featureDir = path6.join(projectRoot, "src", "features", "dark-mode");
-  if (await fs6.pathExists(featureDir)) {
+  const featureDir = path8.join(projectRoot, "src", "features", "dark-mode");
+  if (await fs7.pathExists(featureDir)) {
     log.error("Dark mode feature already exists at src/features/dark-mode/");
     return;
   }
@@ -725,10 +751,10 @@ async function generateDarkMode(projectRoot) {
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path6.join(projectRoot, filePath);
+      const fullPath = path8.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs6.ensureDir(path6.dirname(fullPath));
-      await fs6.writeFile(fullPath, content);
+      await fs7.ensureDir(path8.dirname(fullPath));
+      await fs7.writeFile(fullPath, content);
       count++;
     }
     await wireLayout(projectRoot, ctx);
@@ -758,18 +784,18 @@ async function generateDarkMode(projectRoot) {
   }
 }
 async function setConfigFlag2(projectRoot, ctx) {
-  const configPath = path6.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs6.pathExists(configPath)) return;
+  const configPath = path8.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs7.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs6.readFile(configPath, "utf-8");
+  const content = await fs7.readFile(configPath, "utf-8");
   const updated = content.replace(/darkMode:\s*false/, "darkMode: true");
-  await fs6.writeFile(configPath, updated);
+  await fs7.writeFile(configPath, updated);
 }
 async function wireLayout(projectRoot, ctx) {
-  const layoutPath = path6.join(projectRoot, "src", "app", "layout.tsx");
-  if (!await fs6.pathExists(layoutPath)) return;
+  const layoutPath = path8.join(projectRoot, "src", "app", "layout.tsx");
+  if (!await fs7.pathExists(layoutPath)) return;
   await ctx.trackModifiedFile(layoutPath);
-  let content = await fs6.readFile(layoutPath, "utf-8");
+  let content = await fs7.readFile(layoutPath, "utf-8");
   if (!content.includes("getThemeScript")) {
     content = `import { getThemeScript } from '@/features/dark-mode';
 ${content}`;
@@ -783,13 +809,13 @@ ${content}`;
       "$1\n      <head>\n        <script dangerouslySetInnerHTML={{ __html: getThemeScript() }} />\n      </head>\n$2"
     );
   }
-  await fs6.writeFile(layoutPath, content);
+  await fs7.writeFile(layoutPath, content);
 }
 async function wireProviders(projectRoot, ctx) {
-  const providersPath = path6.join(projectRoot, "src", "app", "providers.tsx");
-  if (!await fs6.pathExists(providersPath)) return;
+  const providersPath = path8.join(projectRoot, "src", "app", "providers.tsx");
+  if (!await fs7.pathExists(providersPath)) return;
   await ctx.trackModifiedFile(providersPath);
-  let content = await fs6.readFile(providersPath, "utf-8");
+  let content = await fs7.readFile(providersPath, "utf-8");
   if (content.includes("ThemeProvider")) return;
   content = insertImportAfterDirectives(
     content,
@@ -808,13 +834,13 @@ async function wireProviders(projectRoot, ctx) {
   );`;
     }
   );
-  await fs6.writeFile(providersPath, content);
+  await fs7.writeFile(providersPath, content);
 }
 async function wireProtectedNav(projectRoot, ctx) {
-  const navPath = path6.join(projectRoot, "src", "app", "(protected)", "layout.tsx");
-  if (!await fs6.pathExists(navPath)) return;
+  const navPath = path8.join(projectRoot, "src", "app", "(protected)", "layout.tsx");
+  if (!await fs7.pathExists(navPath)) return;
   await ctx.trackModifiedFile(navPath);
-  let content = await fs6.readFile(navPath, "utf-8");
+  let content = await fs7.readFile(navPath, "utf-8");
   if (content.includes("ThemeToggleSimple")) return;
   content = insertImportAfterDirectives(
     content,
@@ -829,19 +855,19 @@ async function wireProtectedNav(projectRoot, ctx) {
     /(<div className="border-t border-border-default px-4 py-3">\s*\n\s*<UserMenu \/>)/,
     '$1\n              <div className="mt-2">\n                <ThemeToggleSimple />\n              </div>'
   );
-  await fs6.writeFile(navPath, content);
+  await fs7.writeFile(navPath, content);
 }
 async function wireTailwindDarkMode(projectRoot, ctx) {
-  const globalsPath = path6.join(projectRoot, "src", "styles", "globals.css");
-  if (!await fs6.pathExists(globalsPath)) return;
+  const globalsPath = path8.join(projectRoot, "src", "styles", "globals.css");
+  if (!await fs7.pathExists(globalsPath)) return;
   await ctx.trackModifiedFile(globalsPath);
-  let content = await fs6.readFile(globalsPath, "utf-8");
+  let content = await fs7.readFile(globalsPath, "utf-8");
   if (content.includes("@custom-variant dark")) return;
   content = content.replace(
     /@import 'tailwindcss';/,
     "@import 'tailwindcss';\n@custom-variant dark (&:where(.dark, .dark *));"
   );
-  await fs6.writeFile(globalsPath, content);
+  await fs7.writeFile(globalsPath, content);
 }
 function themeProvider() {
   return `${STAMP2}
@@ -1121,19 +1147,19 @@ var init_dark_mode = __esm({
 });
 // src/utils/prisma.ts
-import fs7 from "fs-extra";
-import path7 from "path";
+import fs8 from "fs-extra";
+import path9 from "path";
 async function addUserRelation(projectRoot, field, ctx) {
-  const authPath = path7.join(projectRoot, "prisma", "schema", "auth.prisma");
-  if (!await fs7.pathExists(authPath)) return;
+  const authPath = path9.join(projectRoot, "prisma", "schema", "auth.prisma");
+  if (!await fs8.pathExists(authPath)) return;
   await ctx.trackModifiedFile(authPath);
-  let content = await fs7.readFile(authPath, "utf-8");
+  let content = await fs8.readFile(authPath, "utf-8");
   if (content.includes(field)) return;
   const insertBefore = "  @@index([email])";
   content = content.replace(insertBefore, `  ${field}
 ${insertBefore}`);
-  await fs7.writeFile(authPath, content);
+  await fs8.writeFile(authPath, content);
 }
 var init_prisma = __esm({
   "src/utils/prisma.ts"() {
@@ -1146,11 +1172,11 @@ var notifications_exports = {};
 __export(notifications_exports, {
   generateNotifications: () => generateNotifications
 });
-import fs8 from "fs-extra";
-import path8 from "path";
+import fs9 from "fs-extra";
+import path10 from "path";
 async function generateNotifications(projectRoot) {
-  const featureDir = path8.join(projectRoot, "src", "features", "notifications");
-  if (await fs8.pathExists(featureDir)) {
+  const featureDir = path10.join(projectRoot, "src", "features", "notifications");
+  if (await fs9.pathExists(featureDir)) {
     log.error("Notifications feature already exists at src/features/notifications/");
     return;
   }
@@ -1165,6 +1191,7 @@ async function generateNotifications(projectRoot) {
       "src/features/notifications/components/NotificationBell.tsx": notificationBell(),
       "src/features/notifications/components/NotificationPanel.tsx": notificationPanel(),
       "src/features/notifications/components/index.ts": componentIndex2(),
+      "src/features/notifications/index.ts": featureIndex(),
       "src/app/api/protected/notifications/route.ts": listRoute(),
       "src/app/api/protected/notifications/[id]/read/route.ts": markReadRoute(),
       "src/app/api/protected/notifications/read-all/route.ts": markAllReadRoute(),
@@ -1172,25 +1199,28 @@ async function generateNotifications(projectRoot) {
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path8.join(projectRoot, filePath);
+      const fullPath = path10.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs8.ensureDir(path8.dirname(fullPath));
-      await fs8.writeFile(fullPath, content);
+      await fs9.ensureDir(path10.dirname(fullPath));
+      await fs9.writeFile(fullPath, content);
       count++;
     }
     await addUserRelation(projectRoot, "notifications Notification[]", ctx);
+    await wireProtectedNav2(projectRoot, ctx);
     await setConfigFlag3(projectRoot, ctx);
     await ctx.commit();
-    log.success(`Generated notifications feature with ${count} files`);
+    log.success(`Generated and wired notifications feature (${count} files created)`);
     log.blank();
     log.step("prisma/schema/notification.prisma \u2014 Notification model");
     log.step("src/features/notifications/ \u2014 types, validation, server logic, hooks, components");
     log.step("src/app/api/protected/notifications/ \u2014 CRUD API routes");
     log.blank();
+    log.step("Wired automatically:");
+    log.step("  \u2713 NotificationBell added to navigation bar");
+    log.blank();
     log.warn("Next steps:");
     log.step("1. Run yarn db:push to sync the Prisma schema");
-    log.step("2. Add <NotificationBell /> to your navbar/header");
-    log.step("3. Import createNotification from server to trigger notifications from other features:");
+    log.step("2. Import createNotification from server to trigger notifications from other features:");
     log.step('   import { createNotification } from "@/features/notifications/server"');
     log.blank();
   } catch (error) {
@@ -1198,13 +1228,30 @@ async function generateNotifications(projectRoot) {
     throw error;
   }
 }
+async function wireProtectedNav2(projectRoot, ctx) {
+  const navPath = path10.join(projectRoot, "src", "app", "(protected)", "layout.tsx");
+  if (!await fs9.pathExists(navPath)) return;
+  await ctx.trackModifiedFile(navPath);
+  let content = await fs9.readFile(navPath, "utf-8");
+  if (content.includes("NotificationBell")) return;
+  content = insertImportAfterDirectives(
+    content,
+    `import { NotificationBell } from '@/features/notifications';
+`
+  );
+  content = content.replace(
+    /(<div className="flex items-center gap-3">)\s*\n(\s*)(<div className="hidden md:block">)/,
+    "$1\n$2<NotificationBell />\n$2$3"
+  );
+  await fs9.writeFile(navPath, content);
+}
 async function setConfigFlag3(projectRoot, ctx) {
-  const configPath = path8.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs8.pathExists(configPath)) return;
+  const configPath = path10.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs9.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs8.readFile(configPath, "utf-8");
+  const content = await fs9.readFile(configPath, "utf-8");
   const updated = content.replace(/notifications:\s*false/, "notifications: true");
-  await fs8.writeFile(configPath, updated);
+  await fs9.writeFile(configPath, updated);
 }
 function prismaSchema() {
   return `// Generated by mars generate notifications (notifications@${GENERATOR_VERSION3})
@@ -1681,6 +1728,11 @@ export function NotificationPanel({
 }
 `;
 }
+function featureIndex() {
+  return `${STAMP3}
+export { NotificationBell, NotificationPanel } from './components';
+`;
+}
 function componentIndex2() {
   return `${STAMP3}
 export { NotificationBell } from './NotificationBell';
@@ -1781,6 +1833,7 @@ var GENERATOR_VERSION3, STAMP3;
 var init_notifications = __esm({
   "src/generators/features/notifications.ts"() {
     "use strict";
+    init_client_file_patch();
     init_logger();
     init_rollback();
     init_prisma();
@@ -1794,11 +1847,11 @@ var analytics_exports = {};
 __export(analytics_exports, {
   generateAnalytics: () => generateAnalytics
 });
-import fs9 from "fs-extra";
-import path9 from "path";
+import fs10 from "fs-extra";
+import path11 from "path";
 async function generateAnalytics(projectRoot) {
-  const featureDir = path9.join(projectRoot, "src", "features", "analytics");
-  if (await fs9.pathExists(featureDir)) {
+  const featureDir = path11.join(projectRoot, "src", "features", "analytics");
+  if (await fs10.pathExists(featureDir)) {
     log.error("Analytics feature already exists at src/features/analytics/");
     return;
   }
@@ -1813,21 +1866,25 @@ async function generateAnalytics(projectRoot) {
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path9.join(projectRoot, filePath);
+      const fullPath = path11.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs9.ensureDir(path9.dirname(fullPath));
-      await fs9.writeFile(fullPath, content);
+      await fs10.ensureDir(path11.dirname(fullPath));
+      await fs10.writeFile(fullPath, content);
       count++;
     }
+    await wireProviders2(projectRoot, ctx);
     await setConfigFlag4(projectRoot, ctx);
     await ctx.commit();
-    log.success(`Generated analytics feature with ${count} files`);
+    log.success(`Generated and wired analytics feature (${count} files created)`);
     log.blank();
     log.step("src/features/analytics/ \u2014 types and barrel exports");
     log.step("src/lib/shared/components/providers/AnalyticsProvider.tsx \u2014 provider wrapper");
     log.step("src/lib/shared/utils/analytics.ts \u2014 unified tracking API");
     log.step("src/lib/shared/components/patterns/ConsentBanner.tsx \u2014 cookie consent banner");
     log.blank();
+    log.step("Wired automatically:");
+    log.step("  \u2713 AnalyticsProvider wrapping app in providers.tsx");
+    log.blank();
     log.warn("Install dependencies for your chosen provider:");
     log.step("Vercel:  yarn add @vercel/analytics @vercel/speed-insights");
     log.step("PostHog: yarn add posthog-js");
@@ -1836,20 +1893,46 @@ async function generateAnalytics(projectRoot) {
     log.warn("Next steps:");
     log.step("Set the provider in appConfig.services.analytics.provider");
     log.step("Set required environment variables for the chosen provider");
-    log.step("Add <AnalyticsProvider> and <ConsentBanner /> to your root layout");
     log.blank();
   } catch (error) {
     await ctx.rollback();
     throw error;
   }
 }
+async function wireProviders2(projectRoot, ctx) {
+  const providersPath = path11.join(projectRoot, "src", "app", "providers.tsx");
+  if (!await fs10.pathExists(providersPath)) return;
+  await ctx.trackModifiedFile(providersPath);
+  let content = await fs10.readFile(providersPath, "utf-8");
+  if (content.includes("AnalyticsProvider")) return;
+  content = insertImportAfterDirectives(
+    content,
+    `import { AnalyticsProvider } from '@/lib/shared/components/providers/AnalyticsProvider';
+`
+  );
+  content = content.replace(
+    /return\s+(?:\(\s*)?((?:<\w+[^>]*>)[\s\S]*?\{children\}[\s\S]*?(?:<\/\w+>))\s*(?:\)\s*)?;/,
+    (_match, jsx) => {
+      return `return (
+    <AnalyticsProvider>${jsx}</AnalyticsProvider>
+  );`;
+    }
+  );
+  await fs10.writeFile(providersPath, content);
+  const written = await fs10.readFile(providersPath, "utf-8");
+  if (!written.includes("AnalyticsProvider")) {
+    throw new Error(
+      "wireProviders: AnalyticsProvider was not inserted into providers.tsx \u2014 the return statement pattern did not match. Review the template file structure."
+    );
+  }
+}
 async function setConfigFlag4(projectRoot, ctx) {
-  const configPath = path9.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs9.pathExists(configPath)) return;
+  const configPath = path11.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs10.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs9.readFile(configPath, "utf-8");
+  const content = await fs10.readFile(configPath, "utf-8");
   const updated = content.replace(/analytics:\s*false/, "analytics: true");
-  await fs9.writeFile(configPath, updated);
+  await fs10.writeFile(configPath, updated);
 }
 function types3() {
   return `${STAMP4}
@@ -1872,7 +1955,7 @@ function analyticsProvider() {
   return `${STAMP4}
 'use client';
-import { useEffect, useState } from 'react';
+import { Suspense, useEffect, useState } from 'react';
 import { usePathname, useSearchParams } from 'next/navigation';
 import Script from 'next/script';
 import { appConfig } from '@/config/app.config';
@@ -1895,7 +1978,9 @@ export function AnalyticsProvider({ children }: AnalyticsProviderProps) {
       {provider === 'vercel' && <VercelAnalyticsProvider />}
       {provider === 'posthog' && <PostHogAnalyticsProvider />}
       {provider === 'google' && <GoogleAnalyticsProvider />}
-      <PageViewTracker />
+      <Suspense>
+        <PageViewTracker />
+      </Suspense>
       {children}
     </>
   );
@@ -2059,22 +2144,18 @@ export function trackEvent(
   switch (provider) {
     case 'vercel': {
-      try {
-        const { track } = require('@vercel/analytics');
-        track(eventName, properties);
-      } catch {
-        // @vercel/analytics not available
-      }
+      const vercelSpec = '@vercel/analytics';
+      import(/* webpackIgnore: true */ vercelSpec)
+        .then((mod) => mod.track(eventName, properties))
+        .catch(() => {});
       break;
     }
     case 'posthog': {
-      try {
-        const posthog = require('posthog-js').default;
-        posthog.capture(eventName, properties);
-      } catch {
-        // posthog-js not available
-      }
+      const phSpec = 'posthog-js';
+      import(/* webpackIgnore: true */ phSpec)
+        .then((mod) => mod.default.capture(eventName, properties))
+        .catch(() => {});
       break;
     }
@@ -2105,12 +2186,10 @@ export function identifyUser(
       break;
     case 'posthog': {
-      try {
-        const posthog = require('posthog-js').default;
-        posthog.identify(userId, traits);
-      } catch {
-        // posthog-js not available
-      }
+      const phSpec = 'posthog-js';
+      import(/* webpackIgnore: true */ phSpec)
+        .then((mod) => mod.default.identify(userId, traits))
+        .catch(() => {});
       break;
     }
@@ -2199,6 +2278,7 @@ var GENERATOR_VERSION4, STAMP4;
 var init_analytics = __esm({
   "src/generators/features/analytics.ts"() {
     "use strict";
+    init_client_file_patch();
     init_logger();
     init_rollback();
     GENERATOR_VERSION4 = "0.1.0";
@@ -2211,11 +2291,11 @@ var command_palette_exports = {};
 __export(command_palette_exports, {
   generateCommandPalette: () => generateCommandPalette
 });
-import fs10 from "fs-extra";
-import path10 from "path";
+import fs11 from "fs-extra";
+import path12 from "path";
 async function generateCommandPalette(projectRoot) {
-  const featureDir = path10.join(projectRoot, "src", "features", "command-palette");
-  if (await fs10.pathExists(featureDir)) {
+  const featureDir = path12.join(projectRoot, "src", "features", "command-palette");
+  if (await fs11.pathExists(featureDir)) {
     log.error("Command palette feature already exists at src/features/command-palette/");
     return;
   }
@@ -2229,26 +2309,28 @@ async function generateCommandPalette(projectRoot) {
       "src/features/command-palette/components/CommandPalette.tsx": commandPalette(),
       "src/features/command-palette/components/CommandTrigger.tsx": commandTrigger(),
       "src/features/command-palette/components/index.ts": componentIndex3(),
-      "src/features/command-palette/index.ts": featureIndex()
+      "src/features/command-palette/index.ts": featureIndex2()
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path10.join(projectRoot, filePath);
+      const fullPath = path12.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs10.ensureDir(path10.dirname(fullPath));
-      await fs10.writeFile(fullPath, content);
+      await fs11.ensureDir(path12.dirname(fullPath));
+      await fs11.writeFile(fullPath, content);
       count++;
     }
     await addDependencies(projectRoot, { cmdk: "^1.0.0" });
+    await wireLayout2(projectRoot, ctx);
     await setConfigFlag5(projectRoot, ctx);
     await ctx.commit();
-    log.success(`Generated command palette feature with ${count} files`);
+    log.success(`Generated and wired command palette feature (${count} files created)`);
     log.blank();
     log.step("src/features/command-palette/ \u2014 types, actions, registry, recent, components");
     log.blank();
-    log.warn("Integration steps:");
-    log.step("Add <CommandPalette /> to your protected layout");
-    log.step("Optionally add <CommandTrigger /> to your navbar for discoverability");
+    log.step("Wired automatically:");
+    log.step("  \u2713 CommandPalette overlay mounted in root layout");
+    log.step("  \u2713 Press \u2318K / Ctrl+K to open");
+    log.blank();
     log.step("Register custom actions with registerAction() from any feature");
     log.blank();
   } catch (error) {
@@ -2256,13 +2338,27 @@ async function generateCommandPalette(projectRoot) {
     throw error;
   }
 }
+async function wireLayout2(projectRoot, ctx) {
+  const layoutPath = path12.join(projectRoot, "src", "app", "layout.tsx");
+  if (!await fs11.pathExists(layoutPath)) return;
+  let content = await fs11.readFile(layoutPath, "utf-8");
+  if (content.includes("CommandPalette")) return;
+  await ctx.trackModifiedFile(layoutPath);
+  content = `import { CommandPalette } from '@/features/command-palette';
+${content}`;
+  content = content.replace(
+    /(\s*)(<Providers>[\s\S]*?<\/Providers>)/,
+    "$1$2\n$1<CommandPalette />"
+  );
+  await fs11.writeFile(layoutPath, content);
+}
 async function setConfigFlag5(projectRoot, ctx) {
-  const configPath = path10.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs10.pathExists(configPath)) return;
+  const configPath = path12.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs11.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs10.readFile(configPath, "utf-8");
+  const content = await fs11.readFile(configPath, "utf-8");
   const updated = content.replace(/commandPalette:\s*false/, "commandPalette: true");
-  await fs10.writeFile(configPath, updated);
+  await fs11.writeFile(configPath, updated);
 }
 function types4() {
   return `${STAMP5}
@@ -2652,7 +2748,7 @@ export { CommandPalette } from './CommandPalette';
 export { CommandTrigger } from './CommandTrigger';
 `;
 }
-function featureIndex() {
+function featureIndex2() {
   return `${STAMP5}
 export { CommandPalette, CommandTrigger } from './components';
 export { registerAction, getCustomActions } from './registry';
@@ -2678,11 +2774,11 @@ var onboarding_exports = {};
 __export(onboarding_exports, {
   generateOnboarding: () => generateOnboarding
 });
-import fs11 from "fs-extra";
-import path11 from "path";
+import fs12 from "fs-extra";
+import path13 from "path";
 async function generateOnboarding(projectRoot) {
-  const featureDir = path11.join(projectRoot, "src", "features", "onboarding");
-  if (await fs11.pathExists(featureDir)) {
+  const featureDir = path13.join(projectRoot, "src", "features", "onboarding");
+  if (await fs12.pathExists(featureDir)) {
     log.error("Onboarding feature already exists at src/features/onboarding/");
     return;
   }
@@ -2700,17 +2796,18 @@ async function generateOnboarding(projectRoot) {
       "src/app/(protected)/onboarding/page.tsx": onboardingPage(),
       "src/app/api/protected/onboarding/route.ts": getProgressRoute(),
       "src/app/api/protected/onboarding/step/route.ts": stepActionRoute(),
-      "src/features/onboarding/index.ts": featureIndex2()
+      "src/features/onboarding/index.ts": featureIndex3()
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path11.join(projectRoot, filePath);
+      const fullPath = path13.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs11.ensureDir(path11.dirname(fullPath));
-      await fs11.writeFile(fullPath, content);
+      await fs12.ensureDir(path13.dirname(fullPath));
+      await fs12.writeFile(fullPath, content);
       count++;
     }
     await addUserRelation(projectRoot, "onboardingProgress OnboardingProgress?", ctx);
+    await registerRoute(projectRoot, "onboarding", "/onboarding", ctx);
     await setConfigFlag6(projectRoot, ctx);
     await ctx.commit();
     log.success(`Generated onboarding feature with ${count} files`);
@@ -2731,12 +2828,12 @@ async function generateOnboarding(projectRoot) {
   }
 }
 async function setConfigFlag6(projectRoot, ctx) {
-  const configPath = path11.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs11.pathExists(configPath)) return;
+  const configPath = path13.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs12.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs11.readFile(configPath, "utf-8");
+  const content = await fs12.readFile(configPath, "utf-8");
   const updated = content.replace(/onboarding:\s*false/, "onboarding: true");
-  await fs11.writeFile(configPath, updated);
+  await fs12.writeFile(configPath, updated);
 }
 function prismaSchema2() {
   return `// Generated by mars generate onboarding (onboarding@${GENERATOR_VERSION6})
@@ -3231,7 +3328,7 @@ export const POST = withAuthNoParams(async (request: AuthenticatedRequest) => {
 });
 `;
 }
-function featureIndex2() {
+function featureIndex3() {
   return `${STAMP6}
 export { ONBOARDING_STEPS } from './config';
 export type { OnboardingStep } from './config';
@@ -3252,6 +3349,7 @@ var init_onboarding = __esm({
     init_logger();
     init_rollback();
     init_prisma();
+    init_routes();
     GENERATOR_VERSION6 = "0.1.0";
     STAMP6 = `// @mars-generated onboarding@${GENERATOR_VERSION6}`;
   }
@@ -3262,11 +3360,11 @@ var search_exports = {};
 __export(search_exports, {
   generateSearch: () => generateSearch
 });
-import fs12 from "fs-extra";
-import path12 from "path";
+import fs13 from "fs-extra";
+import path14 from "path";
 async function generateSearch(projectRoot) {
-  const featureDir = path12.join(projectRoot, "src", "features", "search");
-  if (await fs12.pathExists(featureDir)) {
+  const featureDir = path14.join(projectRoot, "src", "features", "search");
+  if (await fs13.pathExists(featureDir)) {
     log.error("Search feature already exists at src/features/search/");
     return;
   }
@@ -3279,25 +3377,30 @@ async function generateSearch(projectRoot) {
       "src/features/search/server/index.ts": serverIndex(),
       "src/features/search/hooks/use-search.ts": useSearchHook(),
       "src/features/search/components/SearchInput.tsx": searchInput(),
+      "src/features/search/components/NavSearch.tsx": navSearch(),
       "src/features/search/components/index.ts": componentIndex5(),
-      "src/features/search/index.ts": featureIndex3(),
+      "src/features/search/index.ts": featureIndex4(),
       "src/app/api/protected/search/route.ts": searchRoute()
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path12.join(projectRoot, filePath);
+      const fullPath = path14.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs12.ensureDir(path12.dirname(fullPath));
-      await fs12.writeFile(fullPath, content);
+      await fs13.ensureDir(path14.dirname(fullPath));
+      await fs13.writeFile(fullPath, content);
       count++;
     }
+    await wireProtectedNav3(projectRoot, ctx);
     await setConfigFlag7(projectRoot, ctx);
     await ctx.commit();
-    log.success(`Generated search feature with ${count} files`);
+    log.success(`Generated and wired search feature (${count} files created)`);
     log.blank();
     log.step("src/features/search/ \u2014 types, validation, server logic, hooks, components");
     log.step("src/app/api/protected/search/ \u2014 authenticated search endpoint");
     log.blank();
+    log.step("Wired automatically:");
+    log.step("  \u2713 NavSearch added to navigation bar");
+    log.blank();
     log.warn("Search uses Postgres full-text search by default (no extra setup).");
     log.blank();
     log.step("For Algolia:  yarn add algoliasearch  + set ALGOLIA_APP_ID, ALGOLIA_API_KEY env vars");
@@ -3311,13 +3414,30 @@ async function generateSearch(projectRoot) {
     throw error;
   }
 }
+async function wireProtectedNav3(projectRoot, ctx) {
+  const navPath = path14.join(projectRoot, "src", "app", "(protected)", "layout.tsx");
+  if (!await fs13.pathExists(navPath)) return;
+  let content = await fs13.readFile(navPath, "utf-8");
+  if (content.includes("NavSearch")) return;
+  await ctx.trackModifiedFile(navPath);
+  content = insertImportAfterDirectives(
+    content,
+    `import { NavSearch } from '@/features/search';
+`
+  );
+  content = content.replace(
+    /(<div className="flex items-center gap-3">)\s*\n(\s*)(<)/,
+    "$1\n$2<NavSearch />\n$2$3"
+  );
+  await fs13.writeFile(navPath, content);
+}
 async function setConfigFlag7(projectRoot, ctx) {
-  const configPath = path12.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs12.pathExists(configPath)) return;
+  const configPath = path14.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs13.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs12.readFile(configPath, "utf-8");
+  const content = await fs13.readFile(configPath, "utf-8");
   const updated = content.replace(/search:\s*false/, "search: true");
-  await fs12.writeFile(configPath, updated);
+  await fs13.writeFile(configPath, updated);
 }
 function types6() {
   return `${STAMP7}
@@ -3587,17 +3707,39 @@ export function SearchInput({
 }
 `;
 }
+function navSearch() {
+  return `${STAMP7}
+'use client';
+import { useState } from 'react';
+import { SearchInput } from './SearchInput';
+export function NavSearch() {
+  const [query, setQuery] = useState('');
+  return (
+    <SearchInput
+      value={query}
+      onQueryChange={setQuery}
+      placeholder="Search\u2026"
+      className="w-48 lg:w-64"
+    />
+  );
+}
+`;
+}
 function componentIndex5() {
   return `${STAMP7}
 export { SearchInput } from './SearchInput';
+export { NavSearch } from './NavSearch';
 `;
 }
-function featureIndex3() {
+function featureIndex4() {
   return `${STAMP7}
 export type { SearchResult, SearchOptions, SearchProvider } from './types';
 export { searchParamsSchema } from './validation/schemas';
 export type { SearchParams } from './validation/schemas';
-export { SearchInput } from './components';
+export { SearchInput, NavSearch } from './components';
 export { useSearch } from './hooks/use-search';
 `;
 }
@@ -3636,6 +3778,7 @@ var GENERATOR_VERSION7, STAMP7;
 var init_search = __esm({
   "src/generators/features/search.ts"() {
     "use strict";
+    init_client_file_patch();
     init_logger();
     init_rollback();
     GENERATOR_VERSION7 = "0.1.0";
@@ -3648,11 +3791,11 @@ var realtime_exports = {};
 __export(realtime_exports, {
   generateRealtime: () => generateRealtime
 });
-import fs13 from "fs-extra";
-import path13 from "path";
+import fs14 from "fs-extra";
+import path15 from "path";
 async function generateRealtime(projectRoot) {
-  const featureDir = path13.join(projectRoot, "src", "features", "realtime");
-  if (await fs13.pathExists(featureDir)) {
+  const featureDir = path15.join(projectRoot, "src", "features", "realtime");
+  if (await fs14.pathExists(featureDir)) {
     log.error("Realtime feature already exists at src/features/realtime/");
     return;
   }
@@ -3664,15 +3807,15 @@ async function generateRealtime(projectRoot) {
       "src/features/realtime/server/sse.ts": sseProvider(),
       "src/features/realtime/hooks/use-event-source.ts": useEventSourceHook(),
       "src/features/realtime/hooks/index.ts": hooksIndex(),
-      "src/features/realtime/index.ts": featureIndex4(),
+      "src/features/realtime/index.ts": featureIndex5(),
       "src/app/api/protected/realtime/stream/route.ts": sseStreamRoute()
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path13.join(projectRoot, filePath);
+      const fullPath = path15.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs13.ensureDir(path13.dirname(fullPath));
-      await fs13.writeFile(fullPath, content);
+      await fs14.ensureDir(path15.dirname(fullPath));
+      await fs14.writeFile(fullPath, content);
       count++;
     }
     await setConfigFlag8(projectRoot, ctx);
@@ -3697,12 +3840,12 @@ async function generateRealtime(projectRoot) {
   }
 }
 async function setConfigFlag8(projectRoot, ctx) {
-  const configPath = path13.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs13.pathExists(configPath)) return;
+  const configPath = path15.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs14.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs13.readFile(configPath, "utf-8");
+  const content = await fs14.readFile(configPath, "utf-8");
   const updated = content.replace(/realtime:\s*false/, "realtime: true");
-  await fs13.writeFile(configPath, updated);
+  await fs14.writeFile(configPath, updated);
 }
 function types7() {
   return `${STAMP8}
@@ -3912,7 +4055,7 @@ function hooksIndex() {
 export { useEventSource } from './use-event-source';
 `;
 }
-function featureIndex4() {
+function featureIndex5() {
   return `${STAMP8}
 export type {
   RealtimeProvider,
@@ -4011,11 +4154,11 @@ var ai_exports = {};
 __export(ai_exports, {
   generateAI: () => generateAI
 });
-import fs14 from "fs-extra";
-import path14 from "path";
+import fs15 from "fs-extra";
+import path16 from "path";
 async function generateAI(projectRoot) {
-  const featureDir = path14.join(projectRoot, "src", "features", "ai");
-  if (await fs14.pathExists(featureDir)) {
+  const featureDir = path16.join(projectRoot, "src", "features", "ai");
+  if (await fs15.pathExists(featureDir)) {
     log.error("AI feature already exists at src/features/ai/");
     return;
   }
@@ -4033,10 +4176,10 @@ async function generateAI(projectRoot) {
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path14.join(projectRoot, filePath);
+      const fullPath = path16.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs14.ensureDir(path14.dirname(fullPath));
-      await fs14.writeFile(fullPath, content);
+      await fs15.ensureDir(path16.dirname(fullPath));
+      await fs15.writeFile(fullPath, content);
       count++;
     }
     await addDependencies(projectRoot, {
@@ -4062,12 +4205,12 @@ async function generateAI(projectRoot) {
   }
 }
 async function setConfigFlag9(projectRoot, ctx) {
-  const configPath = path14.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs14.pathExists(configPath)) return;
+  const configPath = path16.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs15.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs14.readFile(configPath, "utf-8");
+  const content = await fs15.readFile(configPath, "utf-8");
   const updated = content.replace(/ai:\s*false/, "ai: true");
-  await fs14.writeFile(configPath, updated);
+  await fs15.writeFile(configPath, updated);
 }
 function types8() {
   return `${STAMP9}
@@ -4506,11 +4649,11 @@ var cookie_consent_exports = {};
 __export(cookie_consent_exports, {
   generateCookieConsent: () => generateCookieConsent
 });
-import fs15 from "fs-extra";
-import path15 from "path";
+import fs16 from "fs-extra";
+import path17 from "path";
 async function generateCookieConsent(projectRoot) {
-  const featureDir = path15.join(projectRoot, "src", "features", "cookie-consent");
-  if (await fs15.pathExists(featureDir)) {
+  const featureDir = path17.join(projectRoot, "src", "features", "cookie-consent");
+  if (await fs16.pathExists(featureDir)) {
     log.error("Cookie consent feature already exists at src/features/cookie-consent/");
     return;
   }
@@ -4522,27 +4665,29 @@ async function generateCookieConsent(projectRoot) {
       "src/features/cookie-consent/components/CookieConsentBanner.tsx": cookieConsentBanner(),
       "src/features/cookie-consent/components/CookiePreferencesDialog.tsx": cookiePreferencesDialog(),
       "src/features/cookie-consent/components/index.ts": componentsIndex(),
-      "src/features/cookie-consent/index.ts": featureIndex5()
+      "src/features/cookie-consent/index.ts": featureIndex6()
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path15.join(projectRoot, filePath);
+      const fullPath = path17.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs15.ensureDir(path15.dirname(fullPath));
-      await fs15.writeFile(fullPath, content);
+      await fs16.ensureDir(path17.dirname(fullPath));
+      await fs16.writeFile(fullPath, content);
       count++;
     }
+    await wireLayout3(projectRoot, ctx);
     await setConfigFlag10(projectRoot, ctx);
     await ctx.commit();
-    log.success(`Generated cookie consent feature with ${count} files`);
+    log.success(`Generated and wired cookie consent feature (${count} files created)`);
     log.blank();
     log.step("src/features/cookie-consent/types.ts \u2014 ConsentStatus, ConsentPreferences");
     log.step("src/features/cookie-consent/hooks/use-consent.ts \u2014 useConsent hook");
     log.step("src/features/cookie-consent/components/CookieConsentBanner.tsx \u2014 banner");
     log.step("src/features/cookie-consent/components/CookiePreferencesDialog.tsx \u2014 preferences modal");
     log.blank();
-    log.warn("Complete setup:");
-    log.step("Add <CookieConsentBanner /> to your root layout");
+    log.step("Wired automatically:");
+    log.step("  \u2713 CookieConsentBanner mounted in root layout");
+    log.blank();
     log.step("Optionally add <CookiePreferencesDialog /> for granular consent management");
     log.step("Check consent status with useConsent() before loading tracking scripts");
     log.blank();
@@ -4551,13 +4696,27 @@ async function generateCookieConsent(projectRoot) {
     throw error;
   }
 }
+async function wireLayout3(projectRoot, ctx) {
+  const layoutPath = path17.join(projectRoot, "src", "app", "layout.tsx");
+  if (!await fs16.pathExists(layoutPath)) return;
+  let content = await fs16.readFile(layoutPath, "utf-8");
+  if (content.includes("CookieConsentBanner")) return;
+  await ctx.trackModifiedFile(layoutPath);
+  content = `import { CookieConsentBanner } from '@/features/cookie-consent';
+${content}`;
+  content = content.replace(
+    /(\s*)(<Providers>[\s\S]*?<\/Providers>)/,
+    "$1$2\n$1<CookieConsentBanner />"
+  );
+  await fs16.writeFile(layoutPath, content);
+}
 async function setConfigFlag10(projectRoot, ctx) {
-  const configPath = path15.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs15.pathExists(configPath)) return;
+  const configPath = path17.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs16.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs15.readFile(configPath, "utf-8");
+  const content = await fs16.readFile(configPath, "utf-8");
   const updated = content.replace(/cookieConsent:\s*false/, "cookieConsent: true");
-  await fs15.writeFile(configPath, updated);
+  await fs16.writeFile(configPath, updated);
 }
 function types9() {
   return `${STAMP10}
@@ -4819,7 +4978,7 @@ export { CookieConsentBanner } from './CookieConsentBanner';
 export { CookiePreferencesDialog } from './CookiePreferencesDialog';
 `;
 }
-function featureIndex5() {
+function featureIndex6() {
   return `${STAMP10}
 export type { ConsentStatus, ConsentPreferences } from './types';
 export { useConsent } from './hooks/use-consent';
@@ -4842,11 +5001,11 @@ var coming_soon_exports = {};
 __export(coming_soon_exports, {
   generateComingSoon: () => generateComingSoon
 });
-import fs16 from "fs-extra";
-import path16 from "path";
+import fs17 from "fs-extra";
+import path18 from "path";
 async function generateComingSoon(projectRoot) {
-  const featureDir = path16.join(projectRoot, "src", "features", "coming-soon");
-  if (await fs16.pathExists(featureDir)) {
+  const featureDir = path18.join(projectRoot, "src", "features", "coming-soon");
+  if (await fs17.pathExists(featureDir)) {
     log.error("Coming soon feature already exists at src/features/coming-soon/");
     return;
   }
@@ -4863,12 +5022,13 @@ async function generateComingSoon(projectRoot) {
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path16.join(projectRoot, filePath);
+      const fullPath = path18.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs16.ensureDir(path16.dirname(fullPath));
-      await fs16.writeFile(fullPath, content);
+      await fs17.ensureDir(path18.dirname(fullPath));
+      await fs17.writeFile(fullPath, content);
       count++;
     }
+    await registerRoute(projectRoot, "comingSoon", "/coming-soon", ctx);
     await setConfigFlag11(projectRoot, ctx);
     await ctx.commit();
     log.success(`Generated coming soon feature with ${count} files`);
@@ -4887,12 +5047,12 @@ async function generateComingSoon(projectRoot) {
   }
 }
 async function setConfigFlag11(projectRoot, ctx) {
-  const configPath = path16.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs16.pathExists(configPath)) return;
+  const configPath = path18.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs17.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs16.readFile(configPath, "utf-8");
+  const content = await fs17.readFile(configPath, "utf-8");
   const updated = content.replace(/comingSoon:\s*false/, "comingSoon: true");
-  await fs16.writeFile(configPath, updated);
+  await fs17.writeFile(configPath, updated);
 }
 function types10() {
   return `${STAMP11}
@@ -5069,6 +5229,7 @@ var init_coming_soon = __esm({
     "use strict";
     init_logger();
     init_rollback();
+    init_routes();
     GENERATOR_VERSION11 = "0.1.0";
     STAMP11 = `// @mars-generated coming-soon@${GENERATOR_VERSION11}`;
   }
@@ -5079,11 +5240,11 @@ var sentry_exports = {};
 __export(sentry_exports, {
   generateSentry: () => generateSentry
 });
-import fs17 from "fs-extra";
-import path17 from "path";
+import fs18 from "fs-extra";
+import path19 from "path";
 async function generateSentry(projectRoot) {
-  const featureDir = path17.join(projectRoot, "src", "features", "sentry");
-  if (await fs17.pathExists(featureDir)) {
+  const featureDir = path19.join(projectRoot, "src", "features", "sentry");
+  if (await fs18.pathExists(featureDir)) {
     log.error("Sentry feature already exists at src/features/sentry/");
     return;
   }
@@ -5099,24 +5260,27 @@ async function generateSentry(projectRoot) {
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path17.join(projectRoot, filePath);
+      const fullPath = path19.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs17.ensureDir(path17.dirname(fullPath));
-      await fs17.writeFile(fullPath, content);
+      await fs18.ensureDir(path19.dirname(fullPath));
+      await fs18.writeFile(fullPath, content);
       count++;
     }
     await addDependencies(projectRoot, { "@sentry/nextjs": "^8.0.0" });
+    await wireRootLayout(projectRoot, ctx);
     await setConfigFlag12(projectRoot, ctx);
     await ctx.commit();
-    log.success(`Generated sentry feature with ${count} files`);
+    log.success(`Generated and wired sentry feature (${count} files created)`);
     log.blank();
     log.step("src/features/sentry/ \u2014 types, client-init, server-init, ErrorBoundary");
     log.blank();
+    log.step("Wired automatically:");
+    log.step("  \u2713 ErrorBoundary wrapping app content in root layout");
+    log.blank();
     log.warn("Optional: run npx @sentry/wizard@latest -i nextjs for full setup");
     log.blank();
     log.warn("Next steps:");
     log.step("Set NEXT_PUBLIC_SENTRY_DSN and SENTRY_DSN environment variables");
-    log.step("Wrap pages or layouts with <ErrorBoundary> for graceful error handling");
     log.step("Import client-init and server-init in your instrumentation files");
     log.blank();
   } catch (error) {
@@ -5124,13 +5288,27 @@ async function generateSentry(projectRoot) {
     throw error;
   }
 }
+async function wireRootLayout(projectRoot, ctx) {
+  const layoutPath = path19.join(projectRoot, "src", "app", "layout.tsx");
+  if (!await fs18.pathExists(layoutPath)) return;
+  let content = await fs18.readFile(layoutPath, "utf-8");
+  if (content.includes("ErrorBoundary")) return;
+  await ctx.trackModifiedFile(layoutPath);
+  content = `import { ErrorBoundary } from '@/features/sentry';
+${content}`;
+  content = content.replace(
+    /(<Providers>)\{children\}(<\/Providers>)/,
+    "$1<ErrorBoundary>{children}</ErrorBoundary>$2"
+  );
+  await fs18.writeFile(layoutPath, content);
+}
 async function setConfigFlag12(projectRoot, ctx) {
-  const configPath = path17.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs17.pathExists(configPath)) return;
+  const configPath = path19.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs18.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs17.readFile(configPath, "utf-8");
+  const content = await fs18.readFile(configPath, "utf-8");
   const updated = content.replace(/sentry:\s*false/, "sentry: true");
-  await fs17.writeFile(configPath, updated);
+  await fs18.writeFile(configPath, updated);
 }
 function types11() {
   return `${STAMP12}
@@ -5275,11 +5453,11 @@ var feature_flags_exports = {};
 __export(feature_flags_exports, {
   generateFeatureFlags: () => generateFeatureFlags
 });
-import fs18 from "fs-extra";
-import path18 from "path";
+import fs19 from "fs-extra";
+import path20 from "path";
 async function generateFeatureFlags(projectRoot) {
-  const featureDir = path18.join(projectRoot, "src", "features", "feature-flags");
-  if (await fs18.pathExists(featureDir)) {
+  const featureDir = path20.join(projectRoot, "src", "features", "feature-flags");
+  if (await fs19.pathExists(featureDir)) {
     log.error("Feature flags feature already exists at src/features/feature-flags/");
     return;
   }
@@ -5292,16 +5470,16 @@ async function generateFeatureFlags(projectRoot) {
       "src/features/feature-flags/hooks/use-feature-flag.ts": useFeatureFlag(),
       "src/features/feature-flags/components/FeatureGate.tsx": featureGate(),
       "src/features/feature-flags/components/index.ts": componentsIndex3(),
-      "src/features/feature-flags/index.ts": featureIndex6(),
+      "src/features/feature-flags/index.ts": featureIndex7(),
       "src/config/feature-flags.json": featureFlagsJson(),
       "src/app/api/protected/feature-flags/route.ts": apiRoute()
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path18.join(projectRoot, filePath);
+      const fullPath = path20.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs18.ensureDir(path18.dirname(fullPath));
-      await fs18.writeFile(fullPath, content);
+      await fs19.ensureDir(path20.dirname(fullPath));
+      await fs19.writeFile(fullPath, content);
       count++;
     }
     await setConfigFlag13(projectRoot, ctx);
@@ -5321,12 +5499,12 @@ async function generateFeatureFlags(projectRoot) {
   }
 }
 async function setConfigFlag13(projectRoot, ctx) {
-  const configPath = path18.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs18.pathExists(configPath)) return;
+  const configPath = path20.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs19.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs18.readFile(configPath, "utf-8");
+  const content = await fs19.readFile(configPath, "utf-8");
   const updated = content.replace(/featureFlags:\s*false/, "featureFlags: true");
-  await fs18.writeFile(configPath, updated);
+  await fs19.writeFile(configPath, updated);
 }
 function types12() {
   return `${STAMP13}
@@ -5503,7 +5681,7 @@ function componentsIndex3() {
 export { FeatureGate } from './FeatureGate';
 `;
 }
-function featureIndex6() {
+function featureIndex7() {
   return `${STAMP13}
 export { getFlag } from './server';
 export { useFeatureFlag } from './hooks/use-feature-flag';
@@ -5564,27 +5742,43 @@ var init_feature_flags = __esm({
 // src/index.ts
 import { Command } from "commander";
+// src/utils/version.ts
+import { createRequire } from "module";
+import path from "path";
+import { fileURLToPath } from "url";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+function readVersionFromPackageJson(packageDir) {
+  const require2 = createRequire(import.meta.url);
+  const pkg = require2(path.join(packageDir, "package.json"));
+  const v = pkg.version?.trim();
+  return v ? v : "0.0.0";
+}
+function getCliVersion() {
+  const packageRoot = path.resolve(__dirname, "..", "..");
+  return readVersionFromPackageJson(packageRoot);
+}
 // src/commands/create.ts
 init_logger();
-import fs20 from "fs-extra";
-import path20 from "path";
+import fs21 from "fs-extra";
+import path22 from "path";
 import os3 from "os";
 import ora from "ora";
 import pc2 from "picocolors";
 import prompts5 from "prompts";
 // src/utils/template.ts
-import path from "path";
-import { fileURLToPath } from "url";
+import path2 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import fs from "fs-extra";
-var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var __dirname2 = path2.dirname(fileURLToPath2(import.meta.url));
 function getTemplatePath() {
   const candidates = [
     // Built bundle: __dirname = packages/cli/dist/
-    path.resolve(__dirname, "..", "template"),
-    path.resolve(__dirname, "..", "..", "..", "template"),
+    path2.resolve(__dirname2, "..", "template"),
+    path2.resolve(__dirname2, "..", "..", "..", "template"),
     // Source (vitest): __dirname = packages/cli/src/utils/
-    path.resolve(__dirname, "..", "..", "..", "..", "template")
+    path2.resolve(__dirname2, "..", "..", "..", "..", "template")
   ];
   for (const candidate of candidates) {
     if (fs.existsSync(candidate)) {
@@ -5596,7 +5790,7 @@ function getTemplatePath() {
   );
 }
 function resolveProjectPath(projectName) {
-  return path.resolve(process.cwd(), projectName);
+  return path2.resolve(process.cwd(), projectName);
 }
 // src/prompts/project-info.ts
@@ -5946,7 +6140,6 @@ var DESIGN_DIRECTIONS = [
 function getDefaultTheme() {
   return {
     primaryColor: COLOR_PRESETS[0].value,
-    secondaryColor: "amber-400",
     font: FONT_CHOICES[0].value,
     designDirection: DESIGN_DIRECTIONS[0].value
   };
@@ -5987,7 +6180,6 @@ async function promptTheme() {
   if (response.primaryColor === void 0) return null;
   return {
     primaryColor: response.primaryColor,
-    secondaryColor: "amber-400",
     font: response.font,
     designDirection: response.designDirection
   };
@@ -5996,7 +6188,7 @@ async function promptTheme() {
 // src/generators/scaffold.ts
 init_logger();
 import fs2 from "fs-extra";
-import path2 from "path";
+import path3 from "path";
 import { generateBrandCss } from "@mars-stack/ui/utils";
 // src/generators/app-config.ts
@@ -6039,15 +6231,7 @@ function generateAppConfig(config) {
     address: '',
   },
   theme: {
-    primaryColor: '${config.theme.primaryColor}' as string,
-    secondaryColor: '${config.theme.secondaryColor}' as string,
     font: '${config.theme.font}' as string,
-    designDirection: '${config.theme.designDirection}' as
-      | 'modern-saas'
-      | 'minimal'
-      | 'enterprise'
-      | 'creative'
-      | 'dashboard',
   },
   features: {
 ${featureEntries}
@@ -6190,8 +6374,8 @@ async function copyTemplateFiles(templateDir, targetDir) {
   async function walkAndCopy(src, dest) {
     const entries = await fs2.readdir(src, { withFileTypes: true });
     for (const entry of entries) {
-      const srcPath = path2.join(src, entry.name);
-      const destPath = path2.join(dest, entry.name);
+      const srcPath = path3.join(src, entry.name);
+      const destPath = path3.join(dest, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.includes(entry.name)) continue;
         await fs2.ensureDir(destPath);
@@ -6209,8 +6393,8 @@ async function copyTemplateFiles(templateDir, targetDir) {
 function resolveMarsPackageRange(packageName, templateDir) {
   const shortName = packageName.replace("@mars-stack/", "");
   const candidates = [
-    path2.resolve(templateDir, "..", "packages", shortName, "package.json"),
-    path2.resolve(templateDir, "..", "..", "packages", shortName, "package.json")
+    path3.resolve(templateDir, "..", "packages", shortName, "package.json"),
+    path3.resolve(templateDir, "..", "..", "packages", shortName, "package.json")
   ];
   for (const candidate of candidates) {
     if (fs2.existsSync(candidate)) {
@@ -6221,7 +6405,7 @@ function resolveMarsPackageRange(packageName, templateDir) {
       }
     }
   }
-  const templatePkg = fs2.readJsonSync(path2.join(templateDir, "package.json"));
+  const templatePkg = fs2.readJsonSync(path3.join(templateDir, "package.json"));
   const existing = templatePkg.dependencies?.[packageName];
   if (existing && existing !== "*") {
     if (/^[\^~>=]/.test(existing)) return existing;
@@ -6232,7 +6416,7 @@ function resolveMarsPackageRange(packageName, templateDir) {
 }
 function generatePackageJson(config) {
   const templateDir = getTemplatePath();
-  const templatePkg = path2.join(templateDir, "package.json");
+  const templatePkg = path3.join(templateDir, "package.json");
   const pkg = fs2.readJsonSync(templatePkg);
   pkg.name = config.name;
   pkg.version = "0.1.0";
@@ -6432,7 +6616,7 @@ async function pruneDisabledFeatures(features, targetDir) {
     const flagValue = features[feature];
     if (flagValue !== false) continue;
     for (const relativePath of paths) {
-      const fullPath = path2.join(targetDir, relativePath);
+      const fullPath = path3.join(targetDir, relativePath);
       if (await fs2.pathExists(fullPath)) {
         await fs2.remove(fullPath);
         log.step(`Pruned disabled feature path: ${relativePath}`);
@@ -6443,7 +6627,7 @@ async function pruneDisabledFeatures(features, targetDir) {
     }
   }
   if (relationsToRemove.length > 0) {
-    const authPath = path2.join(targetDir, "prisma", "schema", "auth.prisma");
+    const authPath = path3.join(targetDir, "prisma", "schema", "auth.prisma");
     if (await fs2.pathExists(authPath)) {
       let content = await fs2.readFile(authPath, "utf-8");
       for (const field of relationsToRemove) {
@@ -6461,22 +6645,22 @@ async function scaffoldProject(targetDir, config) {
   await fs2.ensureDir(targetDir);
   const fileCount = await copyTemplateFiles(templateDir, targetDir);
   await pruneDisabledFeatures(config.features, targetDir);
-  await fs2.writeFile(path2.join(targetDir, "package.json"), generatePackageJson(config));
+  await fs2.writeFile(path3.join(targetDir, "package.json"), generatePackageJson(config));
   await fs2.writeFile(
-    path2.join(targetDir, "src", "config", "app.config.ts"),
+    path3.join(targetDir, "src", "config", "app.config.ts"),
     generateAppConfig(config)
   );
-  await fs2.writeFile(path2.join(targetDir, "docker-compose.yml"), generateDockerCompose(config));
-  await fs2.writeFile(path2.join(targetDir, "src", "app", "layout.tsx"), generateLayout(config));
-  await fs2.writeFile(path2.join(targetDir, ".env"), generateEnvFile(config));
-  await fs2.writeFile(path2.join(targetDir, ".env.example"), generateEnvExample(config));
-  await fs2.writeFile(path2.join(targetDir, ".gitignore"), generateGitignore());
+  await fs2.writeFile(path3.join(targetDir, "docker-compose.yml"), generateDockerCompose(config));
+  await fs2.writeFile(path3.join(targetDir, "src", "app", "layout.tsx"), generateLayout(config));
+  await fs2.writeFile(path3.join(targetDir, ".env"), generateEnvFile(config));
+  await fs2.writeFile(path3.join(targetDir, ".env.example"), generateEnvExample(config));
+  await fs2.writeFile(path3.join(targetDir, ".gitignore"), generateGitignore());
   await patchGlobalsCssForScaffoldedProject(targetDir, config);
   await generateBrandCssForProject(targetDir, config);
   return { fileCount };
 }
 async function generateBrandCssForProject(targetDir, config) {
-  const brandPath = path2.join(targetDir, "src", "styles", "brand.css");
+  const brandPath = path3.join(targetDir, "src", "styles", "brand.css");
   if (!await fs2.pathExists(brandPath)) return;
   const css = generateBrandCss(config.theme.primaryColor);
   await fs2.writeFile(brandPath, css);
@@ -6489,7 +6673,7 @@ var VALID_DESIGN_DIRECTIONS = [
   "dashboard"
 ];
 async function patchGlobalsCssForScaffoldedProject(targetDir, config) {
-  const globalsPath = path2.join(targetDir, "src", "styles", "globals.css");
+  const globalsPath = path3.join(targetDir, "src", "styles", "globals.css");
   if (!await fs2.pathExists(globalsPath)) return;
   let content = await fs2.readFile(globalsPath, "utf-8");
   content = content.replace(
@@ -6626,13 +6810,13 @@ async function generateSelectedFeatures(projectRoot, features) {
 }
 // src/utils/telemetry.ts
-import fs19 from "fs-extra";
-import path19 from "path";
+import fs20 from "fs-extra";
+import path21 from "path";
 import os2 from "os";
-var RC_PATH = path19.join(os2.homedir(), ".marsrc");
+var RC_PATH = path21.join(os2.homedir(), ".marsrc");
 function isTelemetryEnabled() {
   try {
-    const config = fs19.readJsonSync(RC_PATH);
+    const config = fs20.readJsonSync(RC_PATH);
     return config.enabled === true;
   } catch {
     return false;
@@ -6641,16 +6825,16 @@ function isTelemetryEnabled() {
 function enableTelemetry() {
   const config = loadOrCreateConfig();
   config.enabled = true;
-  fs19.writeJsonSync(RC_PATH, config, { spaces: 2 });
+  fs20.writeJsonSync(RC_PATH, config, { spaces: 2 });
 }
 function disableTelemetry() {
   const config = loadOrCreateConfig();
   config.enabled = false;
-  fs19.writeJsonSync(RC_PATH, config, { spaces: 2 });
+  fs20.writeJsonSync(RC_PATH, config, { spaces: 2 });
 }
 function loadOrCreateConfig() {
   try {
-    return fs19.readJsonSync(RC_PATH);
+    return fs20.readJsonSync(RC_PATH);
   } catch {
     return { enabled: false, anonymousId: crypto.randomUUID() };
   }
@@ -6670,13 +6854,13 @@ function trackEvent(event, properties) {
     },
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const logPath = path19.join(os2.homedir(), ".mars-telemetry.log");
-  fs19.appendFile(logPath, JSON.stringify(payload) + "\n").catch(() => {
+  const logPath = path21.join(os2.homedir(), ".mars-telemetry.log");
+  fs20.appendFile(logPath, JSON.stringify(payload) + "\n").catch(() => {
   });
 }
 // src/commands/create.ts
-var RC_PATH2 = path20.join(os3.homedir(), ".marsrc");
+var RC_PATH2 = path22.join(os3.homedir(), ".marsrc");
 var PROJECT_NAME_REGEX = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
 var MAX_PROJECT_NAME_LENGTH = 214;
 async function createCommand(projectName, options) {
@@ -6703,8 +6887,8 @@ async function createCommand(projectName, options) {
   const projectInfo = useDefaults ? getDefaultProjectInfo(projectName) : await promptProjectInfo(projectName);
   if (!projectInfo) return;
   const targetDir = resolveProjectPath(projectInfo.name);
-  if (await fs20.pathExists(targetDir)) {
-    const entries = await fs20.readdir(targetDir);
+  if (await fs21.pathExists(targetDir)) {
+    const entries = await fs21.readdir(targetDir);
     if (entries.length > 0) {
       log.error(`Directory "${projectInfo.name}" already exists and is not empty.`);
       return;
@@ -6745,7 +6929,7 @@ async function createCommand(projectName, options) {
       log.info("Scaffolding cancelled.");
       process.exit(0);
     }
-    if (!fs20.pathExistsSync(RC_PATH2)) {
+    if (!fs21.pathExistsSync(RC_PATH2)) {
       const { telemetryOptIn } = await prompts5(
         {
           type: "confirm",
@@ -6784,10 +6968,10 @@ async function createCommand(projectName, options) {
   } catch (err) {
     spinner.fail("Failed to scaffold project");
     log.error(err instanceof Error ? err.message : String(err));
-    if (await fs20.pathExists(targetDir)) {
+    if (await fs21.pathExists(targetDir)) {
       const cleanupSpinner = ora("Cleaning up...").start();
       try {
-        await fs20.remove(targetDir);
+        await fs21.remove(targetDir);
         cleanupSpinner.succeed("Cleaned up partial scaffold");
       } catch {
         cleanupSpinner.warn(`Could not clean up ${targetDir}. You may need to remove it manually.`);
@@ -6802,8 +6986,8 @@ function countEnabled(flags) {
 // src/commands/doctor.ts
 init_logger();
-import fs21 from "fs-extra";
-import path21 from "path";
+import fs22 from "fs-extra";
+import path23 from "path";
 import { execSync } from "child_process";
 function commandExists(cmd) {
   try {
@@ -6823,12 +7007,12 @@ function getVersion(cmd) {
 async function checkForUpgrades() {
   log.blank();
   log.title("Upgrade Check");
-  const packageJsonPath = path21.join(process.cwd(), "package.json");
-  if (!fs21.pathExistsSync(packageJsonPath)) {
+  const packageJsonPath = path23.join(process.cwd(), "package.json");
+  if (!fs22.pathExistsSync(packageJsonPath)) {
     log.warn("No package.json found \u2014 skipping upgrade check.");
     return;
   }
-  const packageJson = fs21.readJsonSync(packageJsonPath);
+  const packageJson = fs22.readJsonSync(packageJsonPath);
   const deps = packageJson.dependencies ?? {};
   const devDeps = packageJson.devDependencies ?? {};
   const currentRaw = deps["@mars-stack/core"] ?? devDeps["@mars-stack/core"];
@@ -6890,25 +7074,25 @@ async function doctorCommand(options) {
     },
     {
       name: "package.json exists",
-      check: () => fs21.pathExistsSync(path21.join(process.cwd(), "package.json"))
+      check: () => fs22.pathExistsSync(path23.join(process.cwd(), "package.json"))
     },
     {
       name: ".env file exists",
-      check: () => fs21.pathExistsSync(path21.join(process.cwd(), ".env"))
+      check: () => fs22.pathExistsSync(path23.join(process.cwd(), ".env"))
     },
     {
       name: "Prisma schema exists",
-      check: () => fs21.pathExistsSync(path21.join(process.cwd(), "prisma", "schema")) || fs21.pathExistsSync(path21.join(process.cwd(), "prisma", "schema.prisma"))
+      check: () => fs22.pathExistsSync(path23.join(process.cwd(), "prisma", "schema")) || fs22.pathExistsSync(path23.join(process.cwd(), "prisma", "schema.prisma"))
     },
     {
       name: "node_modules installed",
-      check: () => fs21.pathExistsSync(path21.join(process.cwd(), "node_modules"))
+      check: () => fs22.pathExistsSync(path23.join(process.cwd(), "node_modules"))
     },
     {
       name: "DATABASE_URL set",
       check: () => {
         try {
-          const envContent = fs21.readFileSync(path21.join(process.cwd(), ".env"), "utf-8");
+          const envContent = fs22.readFileSync(path23.join(process.cwd(), ".env"), "utf-8");
           const match = envContent.match(/^DATABASE_URL=(.+)$/m);
           return match ? match[1] !== "" : false;
         } catch {
@@ -6920,7 +7104,7 @@ async function doctorCommand(options) {
       name: "JWT_SECRET set",
       check: () => {
         try {
-          const envContent = fs21.readFileSync(path21.join(process.cwd(), ".env"), "utf-8");
+          const envContent = fs22.readFileSync(path23.join(process.cwd(), ".env"), "utf-8");
           const match = envContent.match(/^JWT_SECRET=(.+)$/m);
           if (!match || !match[1]) return false;
           return match[1].length >= 32 ? true : "set but too short (need >=32 chars)";
@@ -6965,16 +7149,16 @@ async function doctorCommand(options) {
 // src/commands/add.ts
 init_logger();
-import fs23 from "fs-extra";
-import path23 from "path";
+import fs24 from "fs-extra";
+import path25 from "path";
 import pc3 from "picocolors";
 // src/utils/doc-updater.ts
-import fs22 from "fs-extra";
-import path22 from "path";
+import fs23 from "fs-extra";
+import path24 from "path";
 async function appendToDbSchema(projectDir, modelName, fields) {
-  const filePath = path22.join(projectDir, "docs", "generated", "db-schema.md");
-  if (!await fs22.pathExists(filePath)) return;
+  const filePath = path24.join(projectDir, "docs", "generated", "db-schema.md");
+  if (!await fs23.pathExists(filePath)) return;
   const entry = [
     "",
     `### ${modelName}`,
@@ -6984,12 +7168,12 @@ async function appendToDbSchema(projectDir, modelName, fields) {
     ...fields.map((f) => `| ${f} |  |`),
     ""
   ].join("\n");
-  await fs22.appendFile(filePath, entry);
+  await fs23.appendFile(filePath, entry);
 }
 async function updateQualityScore(projectDir, domain, grade) {
-  const filePath = path22.join(projectDir, "docs", "QUALITY_SCORE.md");
-  if (!await fs22.pathExists(filePath)) return;
-  const content = await fs22.readFile(filePath, "utf-8");
+  const filePath = path24.join(projectDir, "docs", "QUALITY_SCORE.md");
+  if (!await fs23.pathExists(filePath)) return;
+  const content = await fs23.readFile(filePath, "utf-8");
   const pattern = new RegExp(`^\\|\\s*${escapeRegex(domain)}\\s*\\|`, "m");
   if (pattern.test(content)) {
     const updated = content.replace(pattern, (match) => {
@@ -6997,11 +7181,11 @@ async function updateQualityScore(projectDir, domain, grade) {
       parts[2] = ` ${grade} `;
       return parts.join("|");
     });
-    await fs22.writeFile(filePath, updated);
+    await fs23.writeFile(filePath, updated);
   } else {
     const row = `| ${domain} | ${grade} |  |
 `;
-    await fs22.appendFile(filePath, row);
+    await fs23.appendFile(filePath, row);
   }
 }
 function escapeRegex(str) {
@@ -7012,8 +7196,8 @@ function escapeRegex(str) {
 init_rollback();
 function ensureInProject() {
   const cwd = process.cwd();
-  const configPath = path23.join(cwd, "src", "config", "app.config.ts");
-  if (!fs23.pathExistsSync(configPath)) {
+  const configPath = path25.join(cwd, "src", "config", "app.config.ts");
+  if (!fs24.pathExistsSync(configPath)) {
     log.error("Not inside a MARS project. Run this command from the project root.");
     process.exit(1);
   }
@@ -7046,8 +7230,8 @@ async function addFeatureCommand(name) {
   const kebab = toKebab(name);
   const pascal = toPascal(name);
   const camel = toCamel(name);
-  const featureDir = path23.join(root, "src", "features", kebab);
-  if (await fs23.pathExists(featureDir)) {
+  const featureDir = path25.join(root, "src", "features", kebab);
+  if (await fs24.pathExists(featureDir)) {
     log.error(`Feature "${kebab}" already exists at src/features/${kebab}/`);
     return;
   }
@@ -7112,9 +7296,9 @@ export type Update${pascal}Input = z.infer<typeof ${camel}Schemas.update>;
     ctx.trackCreatedFile(featureDir);
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path23.join(featureDir, filePath);
-      await fs23.ensureDir(path23.dirname(fullPath));
-      await fs23.writeFile(fullPath, content);
+      const fullPath = path25.join(featureDir, filePath);
+      await fs24.ensureDir(path25.dirname(fullPath));
+      await fs24.writeFile(fullPath, content);
       count++;
     }
     await ctx.commit();
@@ -7135,8 +7319,8 @@ async function addPageCommand(routePath, options) {
   const root = ensureInProject();
   const cleanPath = routePath.startsWith("/") ? routePath.slice(1) : routePath;
   const group = options.protected ? "(protected)" : "(public)";
-  const pageDir = path23.join(root, "src", "app", group, cleanPath);
-  if (await fs23.pathExists(path23.join(pageDir, "page.tsx"))) {
+  const pageDir = path25.join(root, "src", "app", group, cleanPath);
+  if (await fs24.pathExists(path25.join(pageDir, "page.tsx"))) {
     log.error(`Page already exists at src/app/${group}/${cleanPath}/page.tsx`);
     return;
   }
@@ -7184,9 +7368,9 @@ export default function Loading() {
   const ctx = createRollbackContext();
   try {
     ctx.trackCreatedFile(pageDir);
-    await fs23.ensureDir(pageDir);
-    await fs23.writeFile(path23.join(pageDir, "page.tsx"), pageContent);
-    await fs23.writeFile(path23.join(pageDir, "loading.tsx"), loadingContent);
+    await fs24.ensureDir(pageDir);
+    await fs24.writeFile(path25.join(pageDir, "page.tsx"), pageContent);
+    await fs24.writeFile(path25.join(pageDir, "loading.tsx"), loadingContent);
     await ctx.commit();
     log.success(`Created page at ${pc3.bold(`src/app/${group}/${cleanPath}/`)}`);
     trackEvent("add", { type: "page" });
@@ -7203,9 +7387,9 @@ async function addModelCommand(name) {
   const pascal = toPascal(name);
   const camel = toCamel(name);
   const kebab = toKebab(name);
-  const schemaDir = path23.join(root, "prisma", "schema");
-  const schemaFile = path23.join(schemaDir, `${kebab}.prisma`);
-  if (await fs23.pathExists(schemaFile)) {
+  const schemaDir = path25.join(root, "prisma", "schema");
+  const schemaFile = path25.join(schemaDir, `${kebab}.prisma`);
+  if (await fs24.pathExists(schemaFile)) {
     log.error(`Schema file already exists: prisma/schema/${kebab}.prisma`);
     return;
   }
@@ -7223,8 +7407,8 @@ async function addModelCommand(name) {
   const ctx = createRollbackContext();
   try {
     ctx.trackCreatedFile(schemaFile);
-    await fs23.ensureDir(schemaDir);
-    await fs23.writeFile(schemaFile, content);
+    await fs24.ensureDir(schemaDir);
+    await fs24.writeFile(schemaFile, content);
     await ctx.commit();
     log.success(`Created model ${pc3.bold(pascal)} at prisma/schema/${kebab}.prisma`);
     trackEvent("add", { type: "model" });
@@ -7246,9 +7430,9 @@ async function addEmailCommand(name) {
   const kebab = toKebab(name);
   const pascal = toPascal(name);
   const camel = toCamel(name);
-  const templatesDir = path23.join(root, "src", "lib", "core", "email", "templates");
-  const filePath = path23.join(templatesDir, `${kebab}-email.ts`);
-  if (await fs23.pathExists(filePath)) {
+  const templatesDir = path25.join(root, "src", "lib", "core", "email", "templates");
+  const filePath = path25.join(templatesDir, `${kebab}-email.ts`);
+  if (await fs24.pathExists(filePath)) {
     log.error(`Email template already exists: src/lib/core/email/templates/${kebab}-email.ts`);
     return;
   }
@@ -7292,25 +7476,25 @@ export function ${functionName}({ appName, actionUrl, userName }: ${pascal}Email
 }
 `;
   const ctx = createRollbackContext();
-  const indexPath = path23.join(templatesDir, "index.ts");
+  const indexPath = path25.join(templatesDir, "index.ts");
   try {
     ctx.trackCreatedFile(filePath);
-    if (await fs23.pathExists(indexPath)) {
+    if (await fs24.pathExists(indexPath)) {
       await ctx.trackModifiedFile(indexPath);
     } else {
       ctx.trackCreatedFile(indexPath);
     }
-    await fs23.ensureDir(templatesDir);
-    await fs23.writeFile(filePath, content);
+    await fs24.ensureDir(templatesDir);
+    await fs24.writeFile(filePath, content);
     const exportLine = `export { ${functionName} } from './${kebab}-email';
 `;
-    if (await fs23.pathExists(indexPath)) {
-      const existing = await fs23.readFile(indexPath, "utf-8");
+    if (await fs24.pathExists(indexPath)) {
+      const existing = await fs24.readFile(indexPath, "utf-8");
       if (!existing.includes(functionName)) {
-        await fs23.appendFile(indexPath, exportLine);
+        await fs24.appendFile(indexPath, exportLine);
       }
     } else {
-      await fs23.writeFile(indexPath, exportLine);
+      await fs24.writeFile(indexPath, exportLine);
     }
     await ctx.commit();
     log.success(`Created email template ${pc3.bold(kebab)} at src/lib/core/email/templates/${kebab}-email.ts`);
@@ -7333,10 +7517,10 @@ async function addComponentCommand(name, options) {
     log.error(`Invalid type "${type}". Use: ${validTypes.join(", ")}`);
     return;
   }
-  const dir = type === "primitive" ? path23.join(root, "src", "components", "primitives") : path23.join(root, "src", "components", "patterns");
-  await fs23.ensureDir(dir);
-  const filePath = path23.join(dir, `${pascal}.tsx`);
-  if (await fs23.pathExists(filePath)) {
+  const dir = type === "primitive" ? path25.join(root, "src", "components", "primitives") : path25.join(root, "src", "components", "patterns");
+  await fs24.ensureDir(dir);
+  const filePath = path25.join(dir, `${pascal}.tsx`);
+  if (await fs24.pathExists(filePath)) {
     log.error(`Component already exists: ${pascal}.tsx`);
     return;
   }
@@ -7385,9 +7569,9 @@ export function ${pascal}({ children, className }: ${pascal}Props) {
   const ctx = createRollbackContext();
   try {
     ctx.trackCreatedFile(filePath);
-    await fs23.writeFile(filePath, content);
+    await fs24.writeFile(filePath, content);
     await ctx.commit();
-    log.success(`Created ${type} component ${pc3.bold(pascal)} at ${path23.relative(root, filePath)}`);
+    log.success(`Created ${type} component ${pc3.bold(pascal)} at ${path25.relative(root, filePath)}`);
     trackEvent("add", { type: "component", componentType: type });
     log.blank();
     log.warn(`Remember to add the export to the barrel file:`);
@@ -7402,14 +7586,14 @@ export function ${pascal}({ children, className }: ${pascal}Props) {
 // src/commands/configure.ts
 init_logger();
 import { execSync as execSync2 } from "child_process";
-import fs24 from "fs-extra";
-import path24 from "path";
+import fs25 from "fs-extra";
+import path26 from "path";
 import pc4 from "picocolors";
 import prompts6 from "prompts";
 function ensureInProject2() {
   const cwd = process.cwd();
-  const configPath = path24.join(cwd, "src", "config", "app.config.ts");
-  if (!fs24.pathExistsSync(configPath)) {
+  const configPath = path26.join(cwd, "src", "config", "app.config.ts");
+  if (!fs25.pathExistsSync(configPath)) {
     log.error("Not inside a MARS project. Run this command from the project root.");
     process.exit(1);
   }
@@ -7423,8 +7607,8 @@ var PROVIDER_DEPENDENCIES = {
   "storage:s3": ["@aws-sdk/client-s3", "@aws-sdk/s3-request-presigner"]
 };
 function updateAppConfig(projectDir, serviceKey, provider, featureKey) {
-  const configPath = path24.join(projectDir, "src", "config", "app.config.ts");
-  let content = fs24.readFileSync(configPath, "utf-8");
+  const configPath = path26.join(projectDir, "src", "config", "app.config.ts");
+  let content = fs25.readFileSync(configPath, "utf-8");
   if (serviceKey === "auth") {
     const boolValue = provider === "google" ? "true" : "false";
     const featureRegex = new RegExp(`(googleOAuth\\s*:\\s*)(?:true|false)`);
@@ -7439,10 +7623,10 @@ function updateAppConfig(projectDir, serviceKey, provider, featureKey) {
       content = content.replace(featureRegex, `$1true`);
     }
   }
-  fs24.writeFileSync(configPath, content);
+  fs25.writeFileSync(configPath, content);
 }
 function detectPackageManager(projectDir) {
-  if (fs24.existsSync(path24.join(projectDir, "yarn.lock"))) return "yarn";
+  if (fs25.existsSync(path26.join(projectDir, "yarn.lock"))) return "yarn";
   return "npm";
 }
 function installDependencies(projectDir, deps) {
@@ -7552,15 +7736,15 @@ async function configureCommand(service) {
     log.step(`Manually set ${pc4.bold(`services.${serviceConfig.configKey}.provider`)} to ${pc4.bold(`'${provider}'`)} in ${pc4.dim("src/config/app.config.ts")}`);
   }
   if (selectedProvider.envVars.length > 0) {
-    const envPath = path24.join(root, ".env");
-    if (await fs24.pathExists(envPath)) {
-      const envContent = await fs24.readFile(envPath, "utf-8");
+    const envPath = path26.join(root, ".env");
+    if (await fs25.pathExists(envPath)) {
+      const envContent = await fs25.readFile(envPath, "utf-8");
       const missingVars = selectedProvider.envVars.filter(
         (v) => !envContent.includes(v)
       );
       if (missingVars.length > 0) {
         const additions = missingVars.map((v) => `${v}=""`).join("\n");
-        await fs24.appendFile(envPath, `
+        await fs25.appendFile(envPath, `
 # ${selectedService} (${provider})
 ${additions}
 `);
@@ -7589,15 +7773,15 @@ ${additions}
 // src/commands/deploy.ts
 init_logger();
-import fs25 from "fs-extra";
-import path25 from "path";
+import fs26 from "fs-extra";
+import path27 from "path";
 import { execSync as execSync3 } from "child_process";
 import pc5 from "picocolors";
 import prompts7 from "prompts";
 function ensureInProject3() {
   const cwd = process.cwd();
-  const configPath = path25.join(cwd, "src", "config", "app.config.ts");
-  if (!fs25.pathExistsSync(configPath)) {
+  const configPath = path27.join(cwd, "src", "config", "app.config.ts");
+  if (!fs26.pathExistsSync(configPath)) {
     log.error("Not inside a MARS project. Run this command from the project root.");
     process.exit(1);
   }
@@ -7636,8 +7820,8 @@ async function deployCommand() {
       return;
     }
   }
-  const vercelDir = path25.join(root, ".vercel");
-  if (!fs25.existsSync(vercelDir)) {
+  const vercelDir = path27.join(root, ".vercel");
+  if (!fs26.existsSync(vercelDir)) {
     log.step("Linking project to Vercel...");
     try {
       execSync3("vercel link", { cwd: root, stdio: "inherit" });
@@ -7654,8 +7838,8 @@ async function deployCommand() {
   log.blank();
   const requiredVars = ["JWT_SECRET", "DATABASE_URL"];
   log.step(`Core: ${pc5.dim(requiredVars.join(", "))}`);
-  const configPath = path25.join(root, "src", "config", "app.config.ts");
-  const configContent = await fs25.readFile(configPath, "utf-8");
+  const configPath = path27.join(root, "src", "config", "app.config.ts");
+  const configContent = await fs26.readFile(configPath, "utf-8");
   if (configContent.includes("email: { provider: 'sendgrid'")) {
     log.step(`Email (SendGrid): ${pc5.dim("SENDGRID_API_KEY, SENDGRID_FROM_EMAIL")}`);
   } else if (configContent.includes("email: { provider: 'resend'")) {
@@ -7716,8 +7900,8 @@ async function deployCommand() {
 // src/commands/upgrade.ts
 init_logger();
-import fs26 from "fs-extra";
-import path26 from "path";
+import fs27 from "fs-extra";
+import path28 from "path";
 import { execSync as execSync4 } from "child_process";
 var MARS_PACKAGES = ["@mars-stack/core", "@mars-stack/ui"];
 var CHANGELOG_URL = "https://github.com/greaveselliott/mars/blob/main/CHANGELOG.md";
@@ -7740,7 +7924,7 @@ function readCurrentVersion(packageJson, packageName) {
   return version ? version.replace(/^[\^~]/, "") : null;
 }
 function detectPackageManager2(projectDir) {
-  if (fs26.pathExistsSync(path26.join(projectDir, "yarn.lock"))) {
+  if (fs27.pathExistsSync(path28.join(projectDir, "yarn.lock"))) {
     return "yarn";
   }
   return "npm";
@@ -7804,7 +7988,7 @@ function updatePackageJsonVersions(packageJsonPath, packageJson, versions) {
   if (updated.length > 0) {
     packageJson.dependencies = deps;
     packageJson.devDependencies = devDeps;
-    fs26.writeJsonSync(packageJsonPath, packageJson, { spaces: 2 });
+    fs27.writeJsonSync(packageJsonPath, packageJson, { spaces: 2 });
   }
   return updated;
 }
@@ -7814,15 +7998,15 @@ function upgradeCommand(program2) {
   ).option("--dry-run", "Show what would be updated without making changes").action(async (options) => {
     log.title("MARS Upgrade");
     const projectDir = process.cwd();
-    const packageJsonPath = path26.join(projectDir, "package.json");
-    if (!fs26.pathExistsSync(packageJsonPath)) {
+    const packageJsonPath = path28.join(projectDir, "package.json");
+    if (!fs27.pathExistsSync(packageJsonPath)) {
       log.error(
         "No package.json found. Are you in a Mars project directory?"
       );
       process.exitCode = 1;
       return;
     }
-    const packageJson = fs26.readJsonSync(packageJsonPath);
+    const packageJson = fs27.readJsonSync(packageJsonPath);
     const hasMarsPackage = MARS_PACKAGES.some(
       (name) => readCurrentVersion(packageJson, name) !== null
     );
@@ -7918,7 +8102,7 @@ init_sentry();
 init_feature_flags();
 init_logger();
 var program = new Command();
-program.name("mars").description("MARS CLI: scaffold, configure, and maintain SaaS apps").version("0.1.0").option("-v, --verbose", "Enable verbose output for debugging");
+program.name("mars").description("MARS CLI: scaffold, configure, and maintain SaaS apps").version(getCliVersion()).option("-v, --verbose", "Enable verbose output for debugging");
 function isVerbose() {
   return program.opts().verbose === true;
 }