@mars-stack/cli 2.0.0 → 3.0.0

package/dist/index.js

@@ -44,8 +44,8 @@ var init_logger = __esm({
 });
 
 // src/utils/rollback.ts
-import fs3 from "fs-extra";
-import path3 from "path";
+import fs4 from "fs-extra";
+import path4 from "path";
 import os from "os";
 function createRollbackContext() {
   const manifest = {
@@ -53,15 +53,15 @@ 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)}`);
-    await fs3.copy(filePath, backupPath);
+    if (!await fs4.pathExists(filePath)) return;
+    await fs4.ensureDir(backupDir);
+    const backupPath = path4.join(backupDir, `${manifest.filesModified.length}-${path4.basename(filePath)}`);
+    await fs4.copy(filePath, backupPath);
     manifest.filesModified.push({ path: filePath, backup: backupPath });
   }
   function trackInstalledDep(depName) {
@@ -70,13 +70,13 @@ function createRollbackContext() {
   async function rollback() {
     for (const filePath of manifest.filesCreated.reverse()) {
       try {
-        await fs3.remove(filePath);
+        await fs4.remove(filePath);
       } catch {
       }
     }
     for (const { path: originalPath, backup } of manifest.filesModified) {
       try {
-        await fs3.copy(backup, originalPath, { overwrite: true });
+        await fs4.copy(backup, originalPath, { overwrite: true });
       } catch {
       }
     }
@@ -86,9 +86,9 @@ function createRollbackContext() {
     await cleanupBackups();
   }
   async function cleanupBackups() {
-    if (await fs3.pathExists(backupDir)) {
+    if (await fs4.pathExists(backupDir)) {
       try {
-        await fs3.remove(backupDir);
+        await fs4.remove(backupDir);
       } catch {
       }
     }
@@ -108,15 +108,15 @@ var init_rollback = __esm({
 });
 
 // src/utils/dependencies.ts
-import fs4 from "fs-extra";
-import path4 from "path";
+import fs5 from "fs-extra";
+import path5 from "path";
 async function addDependencies(projectRoot, deps, dev = false) {
-  const pkgPath = path4.join(projectRoot, "package.json");
-  if (!await fs4.pathExists(pkgPath)) return;
-  const pkg = await fs4.readJson(pkgPath);
+  const pkgPath = path5.join(projectRoot, "package.json");
+  if (!await fs5.pathExists(pkgPath)) return;
+  const pkg = await fs5.readJson(pkgPath);
   const key = dev ? "devDependencies" : "dependencies";
   pkg[key] = { ...pkg[key], ...deps };
-  await fs4.writeJson(pkgPath, pkg, { spaces: 2 });
+  await fs5.writeJson(pkgPath, pkg, { spaces: 2 });
 }
 var init_dependencies = __esm({
   "src/utils/dependencies.ts"() {
@@ -124,16 +124,40 @@ var init_dependencies = __esm({
   }
 });
 
+// src/utils/routes.ts
+import fs6 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 fs6.pathExists(routesFile)) return;
+  let content = await fs6.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 fs6.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 fs7 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 fs7.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 fs7.ensureDir(path7.dirname(fullPath));
+      await fs7.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 fs7.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs5.readFile(configPath, "utf-8");
+  const content = await fs7.readFile(configPath, "utf-8");
   const updated = content.replace(/blog:\s*false/, "blog: true");
-  await fs5.writeFile(configPath, updated);
+  await fs7.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 fs8 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 fs8.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 fs8.ensureDir(path8.dirname(fullPath));
+      await fs8.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 fs8.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs6.readFile(configPath, "utf-8");
+  const content = await fs8.readFile(configPath, "utf-8");
   const updated = content.replace(/darkMode:\s*false/, "darkMode: true");
-  await fs6.writeFile(configPath, updated);
+  await fs8.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 fs8.pathExists(layoutPath)) return;
   await ctx.trackModifiedFile(layoutPath);
-  let content = await fs6.readFile(layoutPath, "utf-8");
+  let content = await fs8.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 fs8.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 fs8.pathExists(providersPath)) return;
   await ctx.trackModifiedFile(providersPath);
-  let content = await fs6.readFile(providersPath, "utf-8");
+  let content = await fs8.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 fs8.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 fs8.pathExists(navPath)) return;
   await ctx.trackModifiedFile(navPath);
-  let content = await fs6.readFile(navPath, "utf-8");
+  let content = await fs8.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 fs8.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 fs8.pathExists(globalsPath)) return;
   await ctx.trackModifiedFile(globalsPath);
-  let content = await fs6.readFile(globalsPath, "utf-8");
+  let content = await fs8.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 fs8.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 fs9 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 fs9.pathExists(authPath)) return;
   await ctx.trackModifiedFile(authPath);
-  let content = await fs7.readFile(authPath, "utf-8");
+  let content = await fs9.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 fs9.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 fs10 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 fs10.pathExists(featureDir)) {
     log.error("Notifications feature already exists at src/features/notifications/");
     return;
   }
@@ -1173,10 +1199,10 @@ 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 fs10.ensureDir(path10.dirname(fullPath));
+      await fs10.writeFile(fullPath, content);
       count++;
     }
     await addUserRelation(projectRoot, "notifications Notification[]", ctx);
@@ -1203,10 +1229,10 @@ async function generateNotifications(projectRoot) {
   }
 }
 async function wireProtectedNav2(projectRoot, ctx) {
-  const navPath = path8.join(projectRoot, "src", "app", "(protected)", "layout.tsx");
-  if (!await fs8.pathExists(navPath)) return;
+  const navPath = path10.join(projectRoot, "src", "app", "(protected)", "layout.tsx");
+  if (!await fs10.pathExists(navPath)) return;
   await ctx.trackModifiedFile(navPath);
-  let content = await fs8.readFile(navPath, "utf-8");
+  let content = await fs10.readFile(navPath, "utf-8");
   if (content.includes("NotificationBell")) return;
   content = insertImportAfterDirectives(
     content,
@@ -1217,15 +1243,15 @@ async function wireProtectedNav2(projectRoot, ctx) {
     /(<div className="flex items-center gap-3">)\s*\n(\s*)(<div className="hidden md:block">)/,
     "$1\n$2<NotificationBell />\n$2$3"
   );
-  await fs8.writeFile(navPath, content);
+  await fs10.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 fs10.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs8.readFile(configPath, "utf-8");
+  const content = await fs10.readFile(configPath, "utf-8");
   const updated = content.replace(/notifications:\s*false/, "notifications: true");
-  await fs8.writeFile(configPath, updated);
+  await fs10.writeFile(configPath, updated);
 }
 function prismaSchema() {
   return `// Generated by mars generate notifications (notifications@${GENERATOR_VERSION3})
@@ -1821,11 +1847,11 @@ var analytics_exports = {};
 __export(analytics_exports, {
   generateAnalytics: () => generateAnalytics
 });
-import fs9 from "fs-extra";
-import path9 from "path";
+import fs11 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 fs11.pathExists(featureDir)) {
     log.error("Analytics feature already exists at src/features/analytics/");
     return;
   }
@@ -1840,10 +1866,10 @@ 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 fs11.ensureDir(path11.dirname(fullPath));
+      await fs11.writeFile(fullPath, content);
       count++;
     }
     await wireProviders2(projectRoot, ctx);
@@ -1874,10 +1900,10 @@ async function generateAnalytics(projectRoot) {
   }
 }
 async function wireProviders2(projectRoot, ctx) {
-  const providersPath = path9.join(projectRoot, "src", "app", "providers.tsx");
-  if (!await fs9.pathExists(providersPath)) return;
+  const providersPath = path11.join(projectRoot, "src", "app", "providers.tsx");
+  if (!await fs11.pathExists(providersPath)) return;
   await ctx.trackModifiedFile(providersPath);
-  let content = await fs9.readFile(providersPath, "utf-8");
+  let content = await fs11.readFile(providersPath, "utf-8");
   if (content.includes("AnalyticsProvider")) return;
   content = insertImportAfterDirectives(
     content,
@@ -1892,8 +1918,8 @@ async function wireProviders2(projectRoot, ctx) {
   );`;
     }
   );
-  await fs9.writeFile(providersPath, content);
-  const written = await fs9.readFile(providersPath, "utf-8");
+  await fs11.writeFile(providersPath, content);
+  const written = await fs11.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."
@@ -1901,12 +1927,12 @@ async function wireProviders2(projectRoot, ctx) {
   }
 }
 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 fs11.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs9.readFile(configPath, "utf-8");
+  const content = await fs11.readFile(configPath, "utf-8");
   const updated = content.replace(/analytics:\s*false/, "analytics: true");
-  await fs9.writeFile(configPath, updated);
+  await fs11.writeFile(configPath, updated);
 }
 function types3() {
   return `${STAMP4}
@@ -2265,11 +2291,11 @@ var command_palette_exports = {};
 __export(command_palette_exports, {
   generateCommandPalette: () => generateCommandPalette
 });
-import fs10 from "fs-extra";
-import path10 from "path";
+import fs12 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 fs12.pathExists(featureDir)) {
     log.error("Command palette feature already exists at src/features/command-palette/");
     return;
   }
@@ -2287,10 +2313,10 @@ async function generateCommandPalette(projectRoot) {
     };
     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 fs12.ensureDir(path12.dirname(fullPath));
+      await fs12.writeFile(fullPath, content);
       count++;
     }
     await addDependencies(projectRoot, { cmdk: "^1.0.0" });
@@ -2313,26 +2339,26 @@ async function generateCommandPalette(projectRoot) {
   }
 }
 async function wireLayout2(projectRoot, ctx) {
-  const layoutPath = path10.join(projectRoot, "src", "app", "layout.tsx");
-  if (!await fs10.pathExists(layoutPath)) return;
-  await ctx.trackModifiedFile(layoutPath);
-  let content = await fs10.readFile(layoutPath, "utf-8");
+  const layoutPath = path12.join(projectRoot, "src", "app", "layout.tsx");
+  if (!await fs12.pathExists(layoutPath)) return;
+  let content = await fs12.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>\{children\}<\/Providers>)/,
+    /(\s*)(<Providers>[\s\S]*?<\/Providers>)/,
     "$1$2\n$1<CommandPalette />"
   );
-  await fs10.writeFile(layoutPath, content);
+  await fs12.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 fs12.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs10.readFile(configPath, "utf-8");
+  const content = await fs12.readFile(configPath, "utf-8");
   const updated = content.replace(/commandPalette:\s*false/, "commandPalette: true");
-  await fs10.writeFile(configPath, updated);
+  await fs12.writeFile(configPath, updated);
 }
 function types4() {
   return `${STAMP5}
@@ -2748,11 +2774,11 @@ var onboarding_exports = {};
 __export(onboarding_exports, {
   generateOnboarding: () => generateOnboarding
 });
-import fs11 from "fs-extra";
-import path11 from "path";
+import fs13 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 fs13.pathExists(featureDir)) {
     log.error("Onboarding feature already exists at src/features/onboarding/");
     return;
   }
@@ -2774,13 +2800,14 @@ async function generateOnboarding(projectRoot) {
     };
     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 fs13.ensureDir(path13.dirname(fullPath));
+      await fs13.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`);
@@ -2801,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 fs13.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs11.readFile(configPath, "utf-8");
+  const content = await fs13.readFile(configPath, "utf-8");
   const updated = content.replace(/onboarding:\s*false/, "onboarding: true");
-  await fs11.writeFile(configPath, updated);
+  await fs13.writeFile(configPath, updated);
 }
 function prismaSchema2() {
   return `// Generated by mars generate onboarding (onboarding@${GENERATOR_VERSION6})
@@ -3322,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}`;
   }
@@ -3332,11 +3360,11 @@ var search_exports = {};
 __export(search_exports, {
   generateSearch: () => generateSearch
 });
-import fs12 from "fs-extra";
-import path12 from "path";
+import fs14 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 fs14.pathExists(featureDir)) {
     log.error("Search feature already exists at src/features/search/");
     return;
   }
@@ -3349,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": 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 fs14.ensureDir(path14.dirname(fullPath));
+      await fs14.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");
@@ -3381,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 fs14.pathExists(navPath)) return;
+  let content = await fs14.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 fs14.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 fs14.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs12.readFile(configPath, "utf-8");
+  const content = await fs14.readFile(configPath, "utf-8");
   const updated = content.replace(/search:\s*false/, "search: true");
-  await fs12.writeFile(configPath, updated);
+  await fs14.writeFile(configPath, updated);
 }
 function types6() {
   return `${STAMP7}
@@ -3657,9 +3707,31 @@ 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 featureIndex4() {
@@ -3667,7 +3739,7 @@ function featureIndex4() {
 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';
 `;
 }
@@ -3706,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";
@@ -3718,11 +3791,11 @@ var realtime_exports = {};
 __export(realtime_exports, {
   generateRealtime: () => generateRealtime
 });
-import fs13 from "fs-extra";
-import path13 from "path";
+import fs15 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 fs15.pathExists(featureDir)) {
     log.error("Realtime feature already exists at src/features/realtime/");
     return;
   }
@@ -3739,10 +3812,10 @@ async function generateRealtime(projectRoot) {
     };
     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 fs15.ensureDir(path15.dirname(fullPath));
+      await fs15.writeFile(fullPath, content);
       count++;
     }
     await setConfigFlag8(projectRoot, ctx);
@@ -3767,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 fs15.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs13.readFile(configPath, "utf-8");
+  const content = await fs15.readFile(configPath, "utf-8");
   const updated = content.replace(/realtime:\s*false/, "realtime: true");
-  await fs13.writeFile(configPath, updated);
+  await fs15.writeFile(configPath, updated);
 }
 function types7() {
   return `${STAMP8}
@@ -4081,11 +4154,11 @@ var ai_exports = {};
 __export(ai_exports, {
   generateAI: () => generateAI
 });
-import fs14 from "fs-extra";
-import path14 from "path";
+import fs16 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 fs16.pathExists(featureDir)) {
     log.error("AI feature already exists at src/features/ai/");
     return;
   }
@@ -4103,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 fs16.ensureDir(path16.dirname(fullPath));
+      await fs16.writeFile(fullPath, content);
       count++;
     }
     await addDependencies(projectRoot, {
@@ -4132,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 fs16.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs14.readFile(configPath, "utf-8");
+  const content = await fs16.readFile(configPath, "utf-8");
   const updated = content.replace(/ai:\s*false/, "ai: true");
-  await fs14.writeFile(configPath, updated);
+  await fs16.writeFile(configPath, updated);
 }
 function types8() {
   return `${STAMP9}
@@ -4576,11 +4649,11 @@ var cookie_consent_exports = {};
 __export(cookie_consent_exports, {
   generateCookieConsent: () => generateCookieConsent
 });
-import fs15 from "fs-extra";
-import path15 from "path";
+import fs17 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 fs17.pathExists(featureDir)) {
     log.error("Cookie consent feature already exists at src/features/cookie-consent/");
     return;
   }
@@ -4596,10 +4669,10 @@ async function generateCookieConsent(projectRoot) {
     };
     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 fs17.ensureDir(path17.dirname(fullPath));
+      await fs17.writeFile(fullPath, content);
       count++;
     }
     await wireLayout3(projectRoot, ctx);
@@ -4624,26 +4697,26 @@ async function generateCookieConsent(projectRoot) {
   }
 }
 async function wireLayout3(projectRoot, ctx) {
-  const layoutPath = path15.join(projectRoot, "src", "app", "layout.tsx");
-  if (!await fs15.pathExists(layoutPath)) return;
-  await ctx.trackModifiedFile(layoutPath);
-  let content = await fs15.readFile(layoutPath, "utf-8");
+  const layoutPath = path17.join(projectRoot, "src", "app", "layout.tsx");
+  if (!await fs17.pathExists(layoutPath)) return;
+  let content = await fs17.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>\{children\}<\/Providers>)/,
+    /(\s*)(<Providers>[\s\S]*?<\/Providers>)/,
     "$1$2\n$1<CookieConsentBanner />"
   );
-  await fs15.writeFile(layoutPath, content);
+  await fs17.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 fs17.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs15.readFile(configPath, "utf-8");
+  const content = await fs17.readFile(configPath, "utf-8");
   const updated = content.replace(/cookieConsent:\s*false/, "cookieConsent: true");
-  await fs15.writeFile(configPath, updated);
+  await fs17.writeFile(configPath, updated);
 }
 function types9() {
   return `${STAMP10}
@@ -4928,11 +5001,11 @@ var coming_soon_exports = {};
 __export(coming_soon_exports, {
   generateComingSoon: () => generateComingSoon
 });
-import fs16 from "fs-extra";
-import path16 from "path";
+import fs18 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 fs18.pathExists(featureDir)) {
     log.error("Coming soon feature already exists at src/features/coming-soon/");
     return;
   }
@@ -4949,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 fs18.ensureDir(path18.dirname(fullPath));
+      await fs18.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`);
@@ -4973,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 fs18.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs16.readFile(configPath, "utf-8");
+  const content = await fs18.readFile(configPath, "utf-8");
   const updated = content.replace(/comingSoon:\s*false/, "comingSoon: true");
-  await fs16.writeFile(configPath, updated);
+  await fs18.writeFile(configPath, updated);
 }
 function types10() {
   return `${STAMP11}
@@ -5155,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}`;
   }
@@ -5165,11 +5240,11 @@ var sentry_exports = {};
 __export(sentry_exports, {
   generateSentry: () => generateSentry
 });
-import fs17 from "fs-extra";
-import path17 from "path";
+import fs19 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 fs19.pathExists(featureDir)) {
     log.error("Sentry feature already exists at src/features/sentry/");
     return;
   }
@@ -5185,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 fs19.ensureDir(path19.dirname(fullPath));
+      await fs19.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) {
@@ -5210,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 fs19.pathExists(layoutPath)) return;
+  let content = await fs19.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 fs19.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 fs19.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs17.readFile(configPath, "utf-8");
+  const content = await fs19.readFile(configPath, "utf-8");
   const updated = content.replace(/sentry:\s*false/, "sentry: true");
-  await fs17.writeFile(configPath, updated);
+  await fs19.writeFile(configPath, updated);
 }
 function types11() {
   return `${STAMP12}
@@ -5361,11 +5453,11 @@ var feature_flags_exports = {};
 __export(feature_flags_exports, {
   generateFeatureFlags: () => generateFeatureFlags
 });
-import fs18 from "fs-extra";
-import path18 from "path";
+import fs20 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 fs20.pathExists(featureDir)) {
     log.error("Feature flags feature already exists at src/features/feature-flags/");
     return;
   }
@@ -5384,10 +5476,10 @@ async function generateFeatureFlags(projectRoot) {
     };
     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 fs20.ensureDir(path20.dirname(fullPath));
+      await fs20.writeFile(fullPath, content);
       count++;
     }
     await setConfigFlag13(projectRoot, ctx);
@@ -5407,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 fs20.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs18.readFile(configPath, "utf-8");
+  const content = await fs20.readFile(configPath, "utf-8");
   const updated = content.replace(/featureFlags:\s*false/, "featureFlags: true");
-  await fs18.writeFile(configPath, updated);
+  await fs20.writeFile(configPath, updated);
 }
 function types12() {
   return `${STAMP13}
@@ -5650,30 +5742,57 @@ 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";
+import fs from "fs-extra";
+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 candidates = [
+    // Built bundle: __dirname = packages/cli/dist/
+    path.resolve(__dirname, ".."),
+    // Source (vitest): __dirname = packages/cli/src/utils/
+    path.resolve(__dirname, "..", "..")
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(path.join(candidate, "package.json"))) {
+      return readVersionFromPackageJson(candidate);
+    }
+  }
+  return "0.0.0";
+}
+
 // src/commands/create.ts
 init_logger();
-import fs20 from "fs-extra";
-import path20 from "path";
+import fs22 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 fs from "fs-extra";
-var __dirname = path.dirname(fileURLToPath(import.meta.url));
+import path2 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import fs2 from "fs-extra";
+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)) {
+    if (fs2.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -5682,7 +5801,7 @@ function getTemplatePath() {
   );
 }
 function resolveProjectPath(projectName) {
-  return path.resolve(process.cwd(), projectName);
+  return path2.resolve(process.cwd(), projectName);
 }
 
 // src/prompts/project-info.ts
@@ -6032,7 +6151,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
   };
@@ -6073,7 +6191,6 @@ async function promptTheme() {
   if (response.primaryColor === void 0) return null;
   return {
     primaryColor: response.primaryColor,
-    secondaryColor: "amber-400",
     font: response.font,
     designDirection: response.designDirection
   };
@@ -6081,8 +6198,8 @@ async function promptTheme() {
 
 // src/generators/scaffold.ts
 init_logger();
-import fs2 from "fs-extra";
-import path2 from "path";
+import fs3 from "fs-extra";
+import path3 from "path";
 import { generateBrandCss } from "@mars-stack/ui/utils";
 
 // src/generators/app-config.ts
@@ -6125,15 +6242,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}
@@ -6274,17 +6383,17 @@ var IGNORED_FILES = [
 async function copyTemplateFiles(templateDir, targetDir) {
   let fileCount = 0;
   async function walkAndCopy(src, dest) {
-    const entries = await fs2.readdir(src, { withFileTypes: true });
+    const entries = await fs3.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);
+        await fs3.ensureDir(destPath);
         await walkAndCopy(srcPath, destPath);
       } else {
         if (IGNORED_FILES.includes(entry.name)) continue;
-        await fs2.copy(srcPath, destPath);
+        await fs3.copy(srcPath, destPath);
         fileCount++;
       }
     }
@@ -6295,19 +6404,19 @@ 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)) {
-      const pkg = fs2.readJsonSync(candidate);
+    if (fs3.existsSync(candidate)) {
+      const pkg = fs3.readJsonSync(candidate);
       if (typeof pkg.version === "string") {
         const [major, minor] = pkg.version.split(".");
         return `^${major}.${minor}.0`;
       }
     }
   }
-  const templatePkg = fs2.readJsonSync(path2.join(templateDir, "package.json"));
+  const templatePkg = fs3.readJsonSync(path3.join(templateDir, "package.json"));
   const existing = templatePkg.dependencies?.[packageName];
   if (existing && existing !== "*") {
     if (/^[\^~>=]/.test(existing)) return existing;
@@ -6318,8 +6427,8 @@ function resolveMarsPackageRange(packageName, templateDir) {
 }
 function generatePackageJson(config) {
   const templateDir = getTemplatePath();
-  const templatePkg = path2.join(templateDir, "package.json");
-  const pkg = fs2.readJsonSync(templatePkg);
+  const templatePkg = path3.join(templateDir, "package.json");
+  const pkg = fs3.readJsonSync(templatePkg);
   pkg.name = config.name;
   pkg.version = "0.1.0";
   pkg.private = true;
@@ -6518,9 +6627,9 @@ async function pruneDisabledFeatures(features, targetDir) {
     const flagValue = features[feature];
     if (flagValue !== false) continue;
     for (const relativePath of paths) {
-      const fullPath = path2.join(targetDir, relativePath);
-      if (await fs2.pathExists(fullPath)) {
-        await fs2.remove(fullPath);
+      const fullPath = path3.join(targetDir, relativePath);
+      if (await fs3.pathExists(fullPath)) {
+        await fs3.remove(fullPath);
         log.step(`Pruned disabled feature path: ${relativePath}`);
       }
     }
@@ -6529,43 +6638,43 @@ async function pruneDisabledFeatures(features, targetDir) {
     }
   }
   if (relationsToRemove.length > 0) {
-    const authPath = path2.join(targetDir, "prisma", "schema", "auth.prisma");
-    if (await fs2.pathExists(authPath)) {
-      let content = await fs2.readFile(authPath, "utf-8");
+    const authPath = path3.join(targetDir, "prisma", "schema", "auth.prisma");
+    if (await fs3.pathExists(authPath)) {
+      let content = await fs3.readFile(authPath, "utf-8");
       for (const field of relationsToRemove) {
         content = content.replace(new RegExp(`\\s*${field}\\s+\\S+.*\\n`, "g"), "\n");
       }
-      await fs2.writeFile(authPath, content);
+      await fs3.writeFile(authPath, content);
     }
   }
 }
 async function scaffoldProject(targetDir, config) {
   const templateDir = getTemplatePath();
-  if (!await fs2.pathExists(templateDir)) {
+  if (!await fs3.pathExists(templateDir)) {
     throw new Error(`Template directory not found: ${templateDir}`);
   }
-  await fs2.ensureDir(targetDir);
+  await fs3.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(
-    path2.join(targetDir, "src", "config", "app.config.ts"),
+  await fs3.writeFile(path3.join(targetDir, "package.json"), generatePackageJson(config));
+  await fs3.writeFile(
+    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 fs3.writeFile(path3.join(targetDir, "docker-compose.yml"), generateDockerCompose(config));
+  await fs3.writeFile(path3.join(targetDir, "src", "app", "layout.tsx"), generateLayout(config));
+  await fs3.writeFile(path3.join(targetDir, ".env"), generateEnvFile(config));
+  await fs3.writeFile(path3.join(targetDir, ".env.example"), generateEnvExample(config));
+  await fs3.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");
-  if (!await fs2.pathExists(brandPath)) return;
+  const brandPath = path3.join(targetDir, "src", "styles", "brand.css");
+  if (!await fs3.pathExists(brandPath)) return;
   const css = generateBrandCss(config.theme.primaryColor);
-  await fs2.writeFile(brandPath, css);
+  await fs3.writeFile(brandPath, css);
 }
 var VALID_DESIGN_DIRECTIONS = [
   "modern-saas",
@@ -6575,9 +6684,9 @@ var VALID_DESIGN_DIRECTIONS = [
   "dashboard"
 ];
 async function patchGlobalsCssForScaffoldedProject(targetDir, config) {
-  const globalsPath = path2.join(targetDir, "src", "styles", "globals.css");
-  if (!await fs2.pathExists(globalsPath)) return;
-  let content = await fs2.readFile(globalsPath, "utf-8");
+  const globalsPath = path3.join(targetDir, "src", "styles", "globals.css");
+  if (!await fs3.pathExists(globalsPath)) return;
+  let content = await fs3.readFile(globalsPath, "utf-8");
   content = content.replace(
     '@source "../../../node_modules/@mars-stack/ui/dist/**/*.js";',
     '@source "../../node_modules/@mars-stack/ui/dist/**/*.js";'
@@ -6596,7 +6705,7 @@ async function patchGlobalsCssForScaffoldedProject(targetDir, config) {
 ${newImport}`
     );
   }
-  await fs2.writeFile(globalsPath, content);
+  await fs3.writeFile(globalsPath, content);
 }
 
 // src/generators/generate-selected.ts
@@ -6712,13 +6821,13 @@ async function generateSelectedFeatures(projectRoot, features) {
 }
 
 // src/utils/telemetry.ts
-import fs19 from "fs-extra";
-import path19 from "path";
+import fs21 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 = fs21.readJsonSync(RC_PATH);
     return config.enabled === true;
   } catch {
     return false;
@@ -6727,16 +6836,16 @@ function isTelemetryEnabled() {
 function enableTelemetry() {
   const config = loadOrCreateConfig();
   config.enabled = true;
-  fs19.writeJsonSync(RC_PATH, config, { spaces: 2 });
+  fs21.writeJsonSync(RC_PATH, config, { spaces: 2 });
 }
 function disableTelemetry() {
   const config = loadOrCreateConfig();
   config.enabled = false;
-  fs19.writeJsonSync(RC_PATH, config, { spaces: 2 });
+  fs21.writeJsonSync(RC_PATH, config, { spaces: 2 });
 }
 function loadOrCreateConfig() {
   try {
-    return fs19.readJsonSync(RC_PATH);
+    return fs21.readJsonSync(RC_PATH);
   } catch {
     return { enabled: false, anonymousId: crypto.randomUUID() };
   }
@@ -6756,13 +6865,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");
+  fs21.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) {
@@ -6789,8 +6898,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 fs22.pathExists(targetDir)) {
+    const entries = await fs22.readdir(targetDir);
     if (entries.length > 0) {
       log.error(`Directory "${projectInfo.name}" already exists and is not empty.`);
       return;
@@ -6831,7 +6940,7 @@ async function createCommand(projectName, options) {
       log.info("Scaffolding cancelled.");
       process.exit(0);
     }
-    if (!fs20.pathExistsSync(RC_PATH2)) {
+    if (!fs22.pathExistsSync(RC_PATH2)) {
       const { telemetryOptIn } = await prompts5(
         {
           type: "confirm",
@@ -6870,10 +6979,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 fs22.pathExists(targetDir)) {
       const cleanupSpinner = ora("Cleaning up...").start();
       try {
-        await fs20.remove(targetDir);
+        await fs22.remove(targetDir);
         cleanupSpinner.succeed("Cleaned up partial scaffold");
       } catch {
         cleanupSpinner.warn(`Could not clean up ${targetDir}. You may need to remove it manually.`);
@@ -6888,8 +6997,8 @@ function countEnabled(flags) {
 
 // src/commands/doctor.ts
 init_logger();
-import fs21 from "fs-extra";
-import path21 from "path";
+import fs23 from "fs-extra";
+import path23 from "path";
 import { execSync } from "child_process";
 function commandExists(cmd) {
   try {
@@ -6909,12 +7018,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 (!fs23.pathExistsSync(packageJsonPath)) {
     log.warn("No package.json found \u2014 skipping upgrade check.");
     return;
   }
-  const packageJson = fs21.readJsonSync(packageJsonPath);
+  const packageJson = fs23.readJsonSync(packageJsonPath);
   const deps = packageJson.dependencies ?? {};
   const devDeps = packageJson.devDependencies ?? {};
   const currentRaw = deps["@mars-stack/core"] ?? devDeps["@mars-stack/core"];
@@ -6976,25 +7085,25 @@ async function doctorCommand(options) {
     },
     {
       name: "package.json exists",
-      check: () => fs21.pathExistsSync(path21.join(process.cwd(), "package.json"))
+      check: () => fs23.pathExistsSync(path23.join(process.cwd(), "package.json"))
     },
     {
       name: ".env file exists",
-      check: () => fs21.pathExistsSync(path21.join(process.cwd(), ".env"))
+      check: () => fs23.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: () => fs23.pathExistsSync(path23.join(process.cwd(), "prisma", "schema")) || fs23.pathExistsSync(path23.join(process.cwd(), "prisma", "schema.prisma"))
     },
     {
       name: "node_modules installed",
-      check: () => fs21.pathExistsSync(path21.join(process.cwd(), "node_modules"))
+      check: () => fs23.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 = fs23.readFileSync(path23.join(process.cwd(), ".env"), "utf-8");
           const match = envContent.match(/^DATABASE_URL=(.+)$/m);
           return match ? match[1] !== "" : false;
         } catch {
@@ -7006,7 +7115,7 @@ async function doctorCommand(options) {
       name: "JWT_SECRET set",
       check: () => {
         try {
-          const envContent = fs21.readFileSync(path21.join(process.cwd(), ".env"), "utf-8");
+          const envContent = fs23.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)";
@@ -7051,16 +7160,16 @@ async function doctorCommand(options) {
 
 // src/commands/add.ts
 init_logger();
-import fs23 from "fs-extra";
-import path23 from "path";
+import fs25 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 fs24 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 fs24.pathExists(filePath)) return;
   const entry = [
     "",
     `### ${modelName}`,
@@ -7070,12 +7179,12 @@ async function appendToDbSchema(projectDir, modelName, fields) {
     ...fields.map((f) => `| ${f} |  |`),
     ""
   ].join("\n");
-  await fs22.appendFile(filePath, entry);
+  await fs24.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 fs24.pathExists(filePath)) return;
+  const content = await fs24.readFile(filePath, "utf-8");
   const pattern = new RegExp(`^\\|\\s*${escapeRegex(domain)}\\s*\\|`, "m");
   if (pattern.test(content)) {
     const updated = content.replace(pattern, (match) => {
@@ -7083,11 +7192,11 @@ async function updateQualityScore(projectDir, domain, grade) {
       parts[2] = ` ${grade} `;
       return parts.join("|");
     });
-    await fs22.writeFile(filePath, updated);
+    await fs24.writeFile(filePath, updated);
   } else {
     const row = `| ${domain} | ${grade} |  |
 `;
-    await fs22.appendFile(filePath, row);
+    await fs24.appendFile(filePath, row);
   }
 }
 function escapeRegex(str) {
@@ -7098,8 +7207,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 (!fs25.pathExistsSync(configPath)) {
     log.error("Not inside a MARS project. Run this command from the project root.");
     process.exit(1);
   }
@@ -7132,8 +7241,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 fs25.pathExists(featureDir)) {
     log.error(`Feature "${kebab}" already exists at src/features/${kebab}/`);
     return;
   }
@@ -7198,9 +7307,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 fs25.ensureDir(path25.dirname(fullPath));
+      await fs25.writeFile(fullPath, content);
       count++;
     }
     await ctx.commit();
@@ -7221,8 +7330,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 fs25.pathExists(path25.join(pageDir, "page.tsx"))) {
     log.error(`Page already exists at src/app/${group}/${cleanPath}/page.tsx`);
     return;
   }
@@ -7270,9 +7379,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 fs25.ensureDir(pageDir);
+    await fs25.writeFile(path25.join(pageDir, "page.tsx"), pageContent);
+    await fs25.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" });
@@ -7289,9 +7398,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 fs25.pathExists(schemaFile)) {
     log.error(`Schema file already exists: prisma/schema/${kebab}.prisma`);
     return;
   }
@@ -7309,8 +7418,8 @@ async function addModelCommand(name) {
   const ctx = createRollbackContext();
   try {
     ctx.trackCreatedFile(schemaFile);
-    await fs23.ensureDir(schemaDir);
-    await fs23.writeFile(schemaFile, content);
+    await fs25.ensureDir(schemaDir);
+    await fs25.writeFile(schemaFile, content);
     await ctx.commit();
     log.success(`Created model ${pc3.bold(pascal)} at prisma/schema/${kebab}.prisma`);
     trackEvent("add", { type: "model" });
@@ -7332,9 +7441,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 fs25.pathExists(filePath)) {
     log.error(`Email template already exists: src/lib/core/email/templates/${kebab}-email.ts`);
     return;
   }
@@ -7378,25 +7487,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 fs25.pathExists(indexPath)) {
       await ctx.trackModifiedFile(indexPath);
     } else {
       ctx.trackCreatedFile(indexPath);
     }
-    await fs23.ensureDir(templatesDir);
-    await fs23.writeFile(filePath, content);
+    await fs25.ensureDir(templatesDir);
+    await fs25.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 fs25.pathExists(indexPath)) {
+      const existing = await fs25.readFile(indexPath, "utf-8");
       if (!existing.includes(functionName)) {
-        await fs23.appendFile(indexPath, exportLine);
+        await fs25.appendFile(indexPath, exportLine);
       }
     } else {
-      await fs23.writeFile(indexPath, exportLine);
+      await fs25.writeFile(indexPath, exportLine);
     }
     await ctx.commit();
     log.success(`Created email template ${pc3.bold(kebab)} at src/lib/core/email/templates/${kebab}-email.ts`);
@@ -7419,10 +7528,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 fs25.ensureDir(dir);
+  const filePath = path25.join(dir, `${pascal}.tsx`);
+  if (await fs25.pathExists(filePath)) {
     log.error(`Component already exists: ${pascal}.tsx`);
     return;
   }
@@ -7471,9 +7580,9 @@ export function ${pascal}({ children, className }: ${pascal}Props) {
   const ctx = createRollbackContext();
   try {
     ctx.trackCreatedFile(filePath);
-    await fs23.writeFile(filePath, content);
+    await fs25.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:`);
@@ -7488,14 +7597,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 fs26 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 (!fs26.pathExistsSync(configPath)) {
     log.error("Not inside a MARS project. Run this command from the project root.");
     process.exit(1);
   }
@@ -7509,8 +7618,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 = fs26.readFileSync(configPath, "utf-8");
   if (serviceKey === "auth") {
     const boolValue = provider === "google" ? "true" : "false";
     const featureRegex = new RegExp(`(googleOAuth\\s*:\\s*)(?:true|false)`);
@@ -7525,10 +7634,10 @@ function updateAppConfig(projectDir, serviceKey, provider, featureKey) {
       content = content.replace(featureRegex, `$1true`);
     }
   }
-  fs24.writeFileSync(configPath, content);
+  fs26.writeFileSync(configPath, content);
 }
 function detectPackageManager(projectDir) {
-  if (fs24.existsSync(path24.join(projectDir, "yarn.lock"))) return "yarn";
+  if (fs26.existsSync(path26.join(projectDir, "yarn.lock"))) return "yarn";
   return "npm";
 }
 function installDependencies(projectDir, deps) {
@@ -7638,15 +7747,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 fs26.pathExists(envPath)) {
+      const envContent = await fs26.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 fs26.appendFile(envPath, `
 # ${selectedService} (${provider})
 ${additions}
 `);
@@ -7675,15 +7784,15 @@ ${additions}
 
 // src/commands/deploy.ts
 init_logger();
-import fs25 from "fs-extra";
-import path25 from "path";
+import fs27 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 (!fs27.pathExistsSync(configPath)) {
     log.error("Not inside a MARS project. Run this command from the project root.");
     process.exit(1);
   }
@@ -7722,8 +7831,8 @@ async function deployCommand() {
       return;
     }
   }
-  const vercelDir = path25.join(root, ".vercel");
-  if (!fs25.existsSync(vercelDir)) {
+  const vercelDir = path27.join(root, ".vercel");
+  if (!fs27.existsSync(vercelDir)) {
     log.step("Linking project to Vercel...");
     try {
       execSync3("vercel link", { cwd: root, stdio: "inherit" });
@@ -7740,8 +7849,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 fs27.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'")) {
@@ -7802,8 +7911,8 @@ async function deployCommand() {
 
 // src/commands/upgrade.ts
 init_logger();
-import fs26 from "fs-extra";
-import path26 from "path";
+import fs28 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";
@@ -7826,7 +7935,7 @@ function readCurrentVersion(packageJson, packageName) {
   return version ? version.replace(/^[\^~]/, "") : null;
 }
 function detectPackageManager2(projectDir) {
-  if (fs26.pathExistsSync(path26.join(projectDir, "yarn.lock"))) {
+  if (fs28.pathExistsSync(path28.join(projectDir, "yarn.lock"))) {
     return "yarn";
   }
   return "npm";
@@ -7890,7 +7999,7 @@ function updatePackageJsonVersions(packageJsonPath, packageJson, versions) {
   if (updated.length > 0) {
     packageJson.dependencies = deps;
     packageJson.devDependencies = devDeps;
-    fs26.writeJsonSync(packageJsonPath, packageJson, { spaces: 2 });
+    fs28.writeJsonSync(packageJsonPath, packageJson, { spaces: 2 });
   }
   return updated;
 }
@@ -7900,15 +8009,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 (!fs28.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 = fs28.readJsonSync(packageJsonPath);
     const hasMarsPackage = MARS_PACKAGES.some(
       (name) => readCurrentVersion(packageJson, name) !== null
     );
@@ -8004,7 +8113,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;
 }