@mars-stack/cli 2.0.1 → 3.0.0

package/dist/index.js

@@ -44,7 +44,7 @@ var init_logger = __esm({
 });
 
 // src/utils/rollback.ts
-import fs3 from "fs-extra";
+import fs4 from "fs-extra";
 import path4 from "path";
 import os from "os";
 function createRollbackContext() {
@@ -58,10 +58,10 @@ function createRollbackContext() {
     manifest.filesCreated.push(filePath);
   }
   async function trackModifiedFile(filePath) {
-    if (!await fs3.pathExists(filePath)) return;
-    await fs3.ensureDir(backupDir);
+    if (!await fs4.pathExists(filePath)) return;
+    await fs4.ensureDir(backupDir);
     const backupPath = path4.join(backupDir, `${manifest.filesModified.length}-${path4.basename(filePath)}`);
-    await fs3.copy(filePath, backupPath);
+    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 fs5 from "fs-extra";
 import path5 from "path";
 async function addDependencies(projectRoot, deps, dev = false) {
   const pkgPath = path5.join(projectRoot, "package.json");
-  if (!await fs4.pathExists(pkgPath)) return;
-  const pkg = await fs4.readJson(pkgPath);
+  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"() {
@@ -125,12 +125,12 @@ var init_dependencies = __esm({
 });
 
 // src/utils/routes.ts
-import fs5 from "fs-extra";
+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 fs5.pathExists(routesFile)) return;
-  let content = await fs5.readFile(routesFile, "utf-8");
+  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);
@@ -140,7 +140,7 @@ async function registerRoute(projectRoot, key, routePath, ctx) {
     `  ${key}: '${routePath}',
 } as const;`
   );
-  await fs5.writeFile(routesFile, content);
+  await fs6.writeFile(routesFile, content);
 }
 var init_routes = __esm({
   "src/utils/routes.ts"() {
@@ -153,11 +153,11 @@ var blog_exports = {};
 __export(blog_exports, {
   generateBlog: () => generateBlog
 });
-import fs6 from "fs-extra";
+import fs7 from "fs-extra";
 import path7 from "path";
 async function generateBlog(projectRoot) {
   const featureDir = path7.join(projectRoot, "src", "features", "blog");
-  if (await fs6.pathExists(featureDir)) {
+  if (await fs7.pathExists(featureDir)) {
     log.error("Blog feature already exists at src/features/blog/");
     return;
   }
@@ -180,8 +180,8 @@ async function generateBlog(projectRoot) {
     for (const [filePath, content] of Object.entries(files)) {
       const fullPath = path7.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs6.ensureDir(path7.dirname(fullPath));
-      await fs6.writeFile(fullPath, content);
+      await fs7.ensureDir(path7.dirname(fullPath));
+      await fs7.writeFile(fullPath, content);
       count++;
     }
     await addDependencies(projectRoot, {
@@ -209,11 +209,11 @@ async function generateBlog(projectRoot) {
 }
 async function setConfigFlag(projectRoot, ctx) {
   const configPath = path7.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs6.pathExists(configPath)) return;
+  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(/blog:\s*false/, "blog: true");
-  await fs6.writeFile(configPath, updated);
+  await fs7.writeFile(configPath, updated);
 }
 function schemas() {
   return `${STAMP}
@@ -732,11 +732,11 @@ var dark_mode_exports = {};
 __export(dark_mode_exports, {
   generateDarkMode: () => generateDarkMode
 });
-import fs7 from "fs-extra";
+import fs8 from "fs-extra";
 import path8 from "path";
 async function generateDarkMode(projectRoot) {
   const featureDir = path8.join(projectRoot, "src", "features", "dark-mode");
-  if (await fs7.pathExists(featureDir)) {
+  if (await fs8.pathExists(featureDir)) {
     log.error("Dark mode feature already exists at src/features/dark-mode/");
     return;
   }
@@ -753,8 +753,8 @@ async function generateDarkMode(projectRoot) {
     for (const [filePath, content] of Object.entries(files)) {
       const fullPath = path8.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs7.ensureDir(path8.dirname(fullPath));
-      await fs7.writeFile(fullPath, content);
+      await fs8.ensureDir(path8.dirname(fullPath));
+      await fs8.writeFile(fullPath, content);
       count++;
     }
     await wireLayout(projectRoot, ctx);
@@ -785,17 +785,17 @@ async function generateDarkMode(projectRoot) {
 }
 async function setConfigFlag2(projectRoot, ctx) {
   const configPath = path8.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs7.pathExists(configPath)) return;
+  if (!await fs8.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs7.readFile(configPath, "utf-8");
+  const content = await fs8.readFile(configPath, "utf-8");
   const updated = content.replace(/darkMode:\s*false/, "darkMode: true");
-  await fs7.writeFile(configPath, updated);
+  await fs8.writeFile(configPath, updated);
 }
 async function wireLayout(projectRoot, ctx) {
   const layoutPath = path8.join(projectRoot, "src", "app", "layout.tsx");
-  if (!await fs7.pathExists(layoutPath)) return;
+  if (!await fs8.pathExists(layoutPath)) return;
   await ctx.trackModifiedFile(layoutPath);
-  let content = await fs7.readFile(layoutPath, "utf-8");
+  let content = await fs8.readFile(layoutPath, "utf-8");
   if (!content.includes("getThemeScript")) {
     content = `import { getThemeScript } from '@/features/dark-mode';
 ${content}`;
@@ -809,13 +809,13 @@ ${content}`;
       "$1\n      <head>\n        <script dangerouslySetInnerHTML={{ __html: getThemeScript() }} />\n      </head>\n$2"
     );
   }
-  await fs7.writeFile(layoutPath, content);
+  await fs8.writeFile(layoutPath, content);
 }
 async function wireProviders(projectRoot, ctx) {
   const providersPath = path8.join(projectRoot, "src", "app", "providers.tsx");
-  if (!await fs7.pathExists(providersPath)) return;
+  if (!await fs8.pathExists(providersPath)) return;
   await ctx.trackModifiedFile(providersPath);
-  let content = await fs7.readFile(providersPath, "utf-8");
+  let content = await fs8.readFile(providersPath, "utf-8");
   if (content.includes("ThemeProvider")) return;
   content = insertImportAfterDirectives(
     content,
@@ -834,13 +834,13 @@ async function wireProviders(projectRoot, ctx) {
   );`;
     }
   );
-  await fs7.writeFile(providersPath, content);
+  await fs8.writeFile(providersPath, content);
 }
 async function wireProtectedNav(projectRoot, ctx) {
   const navPath = path8.join(projectRoot, "src", "app", "(protected)", "layout.tsx");
-  if (!await fs7.pathExists(navPath)) return;
+  if (!await fs8.pathExists(navPath)) return;
   await ctx.trackModifiedFile(navPath);
-  let content = await fs7.readFile(navPath, "utf-8");
+  let content = await fs8.readFile(navPath, "utf-8");
   if (content.includes("ThemeToggleSimple")) return;
   content = insertImportAfterDirectives(
     content,
@@ -855,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 fs7.writeFile(navPath, content);
+  await fs8.writeFile(navPath, content);
 }
 async function wireTailwindDarkMode(projectRoot, ctx) {
   const globalsPath = path8.join(projectRoot, "src", "styles", "globals.css");
-  if (!await fs7.pathExists(globalsPath)) return;
+  if (!await fs8.pathExists(globalsPath)) return;
   await ctx.trackModifiedFile(globalsPath);
-  let content = await fs7.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 fs7.writeFile(globalsPath, content);
+  await fs8.writeFile(globalsPath, content);
 }
 function themeProvider() {
   return `${STAMP2}
@@ -1147,19 +1147,19 @@ var init_dark_mode = __esm({
 });
 
 // src/utils/prisma.ts
-import fs8 from "fs-extra";
+import fs9 from "fs-extra";
 import path9 from "path";
 async function addUserRelation(projectRoot, field, ctx) {
   const authPath = path9.join(projectRoot, "prisma", "schema", "auth.prisma");
-  if (!await fs8.pathExists(authPath)) return;
+  if (!await fs9.pathExists(authPath)) return;
   await ctx.trackModifiedFile(authPath);
-  let content = await fs8.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 fs8.writeFile(authPath, content);
+  await fs9.writeFile(authPath, content);
 }
 var init_prisma = __esm({
   "src/utils/prisma.ts"() {
@@ -1172,11 +1172,11 @@ var notifications_exports = {};
 __export(notifications_exports, {
   generateNotifications: () => generateNotifications
 });
-import fs9 from "fs-extra";
+import fs10 from "fs-extra";
 import path10 from "path";
 async function generateNotifications(projectRoot) {
   const featureDir = path10.join(projectRoot, "src", "features", "notifications");
-  if (await fs9.pathExists(featureDir)) {
+  if (await fs10.pathExists(featureDir)) {
     log.error("Notifications feature already exists at src/features/notifications/");
     return;
   }
@@ -1201,8 +1201,8 @@ async function generateNotifications(projectRoot) {
     for (const [filePath, content] of Object.entries(files)) {
       const fullPath = path10.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs9.ensureDir(path10.dirname(fullPath));
-      await fs9.writeFile(fullPath, content);
+      await fs10.ensureDir(path10.dirname(fullPath));
+      await fs10.writeFile(fullPath, content);
       count++;
     }
     await addUserRelation(projectRoot, "notifications Notification[]", ctx);
@@ -1230,9 +1230,9 @@ async function generateNotifications(projectRoot) {
 }
 async function wireProtectedNav2(projectRoot, ctx) {
   const navPath = path10.join(projectRoot, "src", "app", "(protected)", "layout.tsx");
-  if (!await fs9.pathExists(navPath)) return;
+  if (!await fs10.pathExists(navPath)) return;
   await ctx.trackModifiedFile(navPath);
-  let content = await fs9.readFile(navPath, "utf-8");
+  let content = await fs10.readFile(navPath, "utf-8");
   if (content.includes("NotificationBell")) return;
   content = insertImportAfterDirectives(
     content,
@@ -1243,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 fs9.writeFile(navPath, content);
+  await fs10.writeFile(navPath, content);
 }
 async function setConfigFlag3(projectRoot, ctx) {
   const configPath = path10.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs9.pathExists(configPath)) return;
+  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(/notifications:\s*false/, "notifications: true");
-  await fs9.writeFile(configPath, updated);
+  await fs10.writeFile(configPath, updated);
 }
 function prismaSchema() {
   return `// Generated by mars generate notifications (notifications@${GENERATOR_VERSION3})
@@ -1847,11 +1847,11 @@ var analytics_exports = {};
 __export(analytics_exports, {
   generateAnalytics: () => generateAnalytics
 });
-import fs10 from "fs-extra";
+import fs11 from "fs-extra";
 import path11 from "path";
 async function generateAnalytics(projectRoot) {
   const featureDir = path11.join(projectRoot, "src", "features", "analytics");
-  if (await fs10.pathExists(featureDir)) {
+  if (await fs11.pathExists(featureDir)) {
     log.error("Analytics feature already exists at src/features/analytics/");
     return;
   }
@@ -1868,8 +1868,8 @@ async function generateAnalytics(projectRoot) {
     for (const [filePath, content] of Object.entries(files)) {
       const fullPath = path11.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs10.ensureDir(path11.dirname(fullPath));
-      await fs10.writeFile(fullPath, content);
+      await fs11.ensureDir(path11.dirname(fullPath));
+      await fs11.writeFile(fullPath, content);
       count++;
     }
     await wireProviders2(projectRoot, ctx);
@@ -1901,9 +1901,9 @@ async function generateAnalytics(projectRoot) {
 }
 async function wireProviders2(projectRoot, ctx) {
   const providersPath = path11.join(projectRoot, "src", "app", "providers.tsx");
-  if (!await fs10.pathExists(providersPath)) return;
+  if (!await fs11.pathExists(providersPath)) return;
   await ctx.trackModifiedFile(providersPath);
-  let content = await fs10.readFile(providersPath, "utf-8");
+  let content = await fs11.readFile(providersPath, "utf-8");
   if (content.includes("AnalyticsProvider")) return;
   content = insertImportAfterDirectives(
     content,
@@ -1918,8 +1918,8 @@ async function wireProviders2(projectRoot, ctx) {
   );`;
     }
   );
-  await fs10.writeFile(providersPath, content);
-  const written = await fs10.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."
@@ -1928,11 +1928,11 @@ async function wireProviders2(projectRoot, ctx) {
 }
 async function setConfigFlag4(projectRoot, ctx) {
   const configPath = path11.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs10.pathExists(configPath)) return;
+  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(/analytics:\s*false/, "analytics: true");
-  await fs10.writeFile(configPath, updated);
+  await fs11.writeFile(configPath, updated);
 }
 function types3() {
   return `${STAMP4}
@@ -2291,11 +2291,11 @@ var command_palette_exports = {};
 __export(command_palette_exports, {
   generateCommandPalette: () => generateCommandPalette
 });
-import fs11 from "fs-extra";
+import fs12 from "fs-extra";
 import path12 from "path";
 async function generateCommandPalette(projectRoot) {
   const featureDir = path12.join(projectRoot, "src", "features", "command-palette");
-  if (await fs11.pathExists(featureDir)) {
+  if (await fs12.pathExists(featureDir)) {
     log.error("Command palette feature already exists at src/features/command-palette/");
     return;
   }
@@ -2315,8 +2315,8 @@ async function generateCommandPalette(projectRoot) {
     for (const [filePath, content] of Object.entries(files)) {
       const fullPath = path12.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs11.ensureDir(path12.dirname(fullPath));
-      await fs11.writeFile(fullPath, content);
+      await fs12.ensureDir(path12.dirname(fullPath));
+      await fs12.writeFile(fullPath, content);
       count++;
     }
     await addDependencies(projectRoot, { cmdk: "^1.0.0" });
@@ -2340,8 +2340,8 @@ async function generateCommandPalette(projectRoot) {
 }
 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 (!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';
@@ -2350,15 +2350,15 @@ ${content}`;
     /(\s*)(<Providers>[\s\S]*?<\/Providers>)/,
     "$1$2\n$1<CommandPalette />"
   );
-  await fs11.writeFile(layoutPath, content);
+  await fs12.writeFile(layoutPath, content);
 }
 async function setConfigFlag5(projectRoot, ctx) {
   const configPath = path12.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs11.pathExists(configPath)) return;
+  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(/commandPalette:\s*false/, "commandPalette: true");
-  await fs11.writeFile(configPath, updated);
+  await fs12.writeFile(configPath, updated);
 }
 function types4() {
   return `${STAMP5}
@@ -2774,11 +2774,11 @@ var onboarding_exports = {};
 __export(onboarding_exports, {
   generateOnboarding: () => generateOnboarding
 });
-import fs12 from "fs-extra";
+import fs13 from "fs-extra";
 import path13 from "path";
 async function generateOnboarding(projectRoot) {
   const featureDir = path13.join(projectRoot, "src", "features", "onboarding");
-  if (await fs12.pathExists(featureDir)) {
+  if (await fs13.pathExists(featureDir)) {
     log.error("Onboarding feature already exists at src/features/onboarding/");
     return;
   }
@@ -2802,8 +2802,8 @@ async function generateOnboarding(projectRoot) {
     for (const [filePath, content] of Object.entries(files)) {
       const fullPath = path13.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs12.ensureDir(path13.dirname(fullPath));
-      await fs12.writeFile(fullPath, content);
+      await fs13.ensureDir(path13.dirname(fullPath));
+      await fs13.writeFile(fullPath, content);
       count++;
     }
     await addUserRelation(projectRoot, "onboardingProgress OnboardingProgress?", ctx);
@@ -2829,11 +2829,11 @@ async function generateOnboarding(projectRoot) {
 }
 async function setConfigFlag6(projectRoot, ctx) {
   const configPath = path13.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs12.pathExists(configPath)) return;
+  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(/onboarding:\s*false/, "onboarding: true");
-  await fs12.writeFile(configPath, updated);
+  await fs13.writeFile(configPath, updated);
 }
 function prismaSchema2() {
   return `// Generated by mars generate onboarding (onboarding@${GENERATOR_VERSION6})
@@ -3360,11 +3360,11 @@ var search_exports = {};
 __export(search_exports, {
   generateSearch: () => generateSearch
 });
-import fs13 from "fs-extra";
+import fs14 from "fs-extra";
 import path14 from "path";
 async function generateSearch(projectRoot) {
   const featureDir = path14.join(projectRoot, "src", "features", "search");
-  if (await fs13.pathExists(featureDir)) {
+  if (await fs14.pathExists(featureDir)) {
     log.error("Search feature already exists at src/features/search/");
     return;
   }
@@ -3386,8 +3386,8 @@ async function generateSearch(projectRoot) {
     for (const [filePath, content] of Object.entries(files)) {
       const fullPath = path14.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs13.ensureDir(path14.dirname(fullPath));
-      await fs13.writeFile(fullPath, content);
+      await fs14.ensureDir(path14.dirname(fullPath));
+      await fs14.writeFile(fullPath, content);
       count++;
     }
     await wireProtectedNav3(projectRoot, ctx);
@@ -3416,8 +3416,8 @@ async function generateSearch(projectRoot) {
 }
 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 (!await fs14.pathExists(navPath)) return;
+  let content = await fs14.readFile(navPath, "utf-8");
   if (content.includes("NavSearch")) return;
   await ctx.trackModifiedFile(navPath);
   content = insertImportAfterDirectives(
@@ -3429,15 +3429,15 @@ async function wireProtectedNav3(projectRoot, ctx) {
     /(<div className="flex items-center gap-3">)\s*\n(\s*)(<)/,
     "$1\n$2<NavSearch />\n$2$3"
   );
-  await fs13.writeFile(navPath, content);
+  await fs14.writeFile(navPath, content);
 }
 async function setConfigFlag7(projectRoot, ctx) {
   const configPath = path14.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs13.pathExists(configPath)) return;
+  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(/search:\s*false/, "search: true");
-  await fs13.writeFile(configPath, updated);
+  await fs14.writeFile(configPath, updated);
 }
 function types6() {
   return `${STAMP7}
@@ -3791,11 +3791,11 @@ var realtime_exports = {};
 __export(realtime_exports, {
   generateRealtime: () => generateRealtime
 });
-import fs14 from "fs-extra";
+import fs15 from "fs-extra";
 import path15 from "path";
 async function generateRealtime(projectRoot) {
   const featureDir = path15.join(projectRoot, "src", "features", "realtime");
-  if (await fs14.pathExists(featureDir)) {
+  if (await fs15.pathExists(featureDir)) {
     log.error("Realtime feature already exists at src/features/realtime/");
     return;
   }
@@ -3814,8 +3814,8 @@ async function generateRealtime(projectRoot) {
     for (const [filePath, content] of Object.entries(files)) {
       const fullPath = path15.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs14.ensureDir(path15.dirname(fullPath));
-      await fs14.writeFile(fullPath, content);
+      await fs15.ensureDir(path15.dirname(fullPath));
+      await fs15.writeFile(fullPath, content);
       count++;
     }
     await setConfigFlag8(projectRoot, ctx);
@@ -3841,11 +3841,11 @@ async function generateRealtime(projectRoot) {
 }
 async function setConfigFlag8(projectRoot, ctx) {
   const configPath = path15.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs14.pathExists(configPath)) return;
+  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(/realtime:\s*false/, "realtime: true");
-  await fs14.writeFile(configPath, updated);
+  await fs15.writeFile(configPath, updated);
 }
 function types7() {
   return `${STAMP8}
@@ -4154,11 +4154,11 @@ var ai_exports = {};
 __export(ai_exports, {
   generateAI: () => generateAI
 });
-import fs15 from "fs-extra";
+import fs16 from "fs-extra";
 import path16 from "path";
 async function generateAI(projectRoot) {
   const featureDir = path16.join(projectRoot, "src", "features", "ai");
-  if (await fs15.pathExists(featureDir)) {
+  if (await fs16.pathExists(featureDir)) {
     log.error("AI feature already exists at src/features/ai/");
     return;
   }
@@ -4178,8 +4178,8 @@ async function generateAI(projectRoot) {
     for (const [filePath, content] of Object.entries(files)) {
       const fullPath = path16.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs15.ensureDir(path16.dirname(fullPath));
-      await fs15.writeFile(fullPath, content);
+      await fs16.ensureDir(path16.dirname(fullPath));
+      await fs16.writeFile(fullPath, content);
       count++;
     }
     await addDependencies(projectRoot, {
@@ -4206,11 +4206,11 @@ async function generateAI(projectRoot) {
 }
 async function setConfigFlag9(projectRoot, ctx) {
   const configPath = path16.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs15.pathExists(configPath)) return;
+  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(/ai:\s*false/, "ai: true");
-  await fs15.writeFile(configPath, updated);
+  await fs16.writeFile(configPath, updated);
 }
 function types8() {
   return `${STAMP9}
@@ -4649,11 +4649,11 @@ var cookie_consent_exports = {};
 __export(cookie_consent_exports, {
   generateCookieConsent: () => generateCookieConsent
 });
-import fs16 from "fs-extra";
+import fs17 from "fs-extra";
 import path17 from "path";
 async function generateCookieConsent(projectRoot) {
   const featureDir = path17.join(projectRoot, "src", "features", "cookie-consent");
-  if (await fs16.pathExists(featureDir)) {
+  if (await fs17.pathExists(featureDir)) {
     log.error("Cookie consent feature already exists at src/features/cookie-consent/");
     return;
   }
@@ -4671,8 +4671,8 @@ async function generateCookieConsent(projectRoot) {
     for (const [filePath, content] of Object.entries(files)) {
       const fullPath = path17.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs16.ensureDir(path17.dirname(fullPath));
-      await fs16.writeFile(fullPath, content);
+      await fs17.ensureDir(path17.dirname(fullPath));
+      await fs17.writeFile(fullPath, content);
       count++;
     }
     await wireLayout3(projectRoot, ctx);
@@ -4698,8 +4698,8 @@ async function generateCookieConsent(projectRoot) {
 }
 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 (!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';
@@ -4708,15 +4708,15 @@ ${content}`;
     /(\s*)(<Providers>[\s\S]*?<\/Providers>)/,
     "$1$2\n$1<CookieConsentBanner />"
   );
-  await fs16.writeFile(layoutPath, content);
+  await fs17.writeFile(layoutPath, content);
 }
 async function setConfigFlag10(projectRoot, ctx) {
   const configPath = path17.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs16.pathExists(configPath)) return;
+  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(/cookieConsent:\s*false/, "cookieConsent: true");
-  await fs16.writeFile(configPath, updated);
+  await fs17.writeFile(configPath, updated);
 }
 function types9() {
   return `${STAMP10}
@@ -5001,11 +5001,11 @@ var coming_soon_exports = {};
 __export(coming_soon_exports, {
   generateComingSoon: () => generateComingSoon
 });
-import fs17 from "fs-extra";
+import fs18 from "fs-extra";
 import path18 from "path";
 async function generateComingSoon(projectRoot) {
   const featureDir = path18.join(projectRoot, "src", "features", "coming-soon");
-  if (await fs17.pathExists(featureDir)) {
+  if (await fs18.pathExists(featureDir)) {
     log.error("Coming soon feature already exists at src/features/coming-soon/");
     return;
   }
@@ -5024,8 +5024,8 @@ async function generateComingSoon(projectRoot) {
     for (const [filePath, content] of Object.entries(files)) {
       const fullPath = path18.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs17.ensureDir(path18.dirname(fullPath));
-      await fs17.writeFile(fullPath, content);
+      await fs18.ensureDir(path18.dirname(fullPath));
+      await fs18.writeFile(fullPath, content);
       count++;
     }
     await registerRoute(projectRoot, "comingSoon", "/coming-soon", ctx);
@@ -5048,11 +5048,11 @@ async function generateComingSoon(projectRoot) {
 }
 async function setConfigFlag11(projectRoot, ctx) {
   const configPath = path18.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs17.pathExists(configPath)) return;
+  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(/comingSoon:\s*false/, "comingSoon: true");
-  await fs17.writeFile(configPath, updated);
+  await fs18.writeFile(configPath, updated);
 }
 function types10() {
   return `${STAMP11}
@@ -5240,11 +5240,11 @@ var sentry_exports = {};
 __export(sentry_exports, {
   generateSentry: () => generateSentry
 });
-import fs18 from "fs-extra";
+import fs19 from "fs-extra";
 import path19 from "path";
 async function generateSentry(projectRoot) {
   const featureDir = path19.join(projectRoot, "src", "features", "sentry");
-  if (await fs18.pathExists(featureDir)) {
+  if (await fs19.pathExists(featureDir)) {
     log.error("Sentry feature already exists at src/features/sentry/");
     return;
   }
@@ -5262,8 +5262,8 @@ async function generateSentry(projectRoot) {
     for (const [filePath, content] of Object.entries(files)) {
       const fullPath = path19.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs18.ensureDir(path19.dirname(fullPath));
-      await fs18.writeFile(fullPath, content);
+      await fs19.ensureDir(path19.dirname(fullPath));
+      await fs19.writeFile(fullPath, content);
       count++;
     }
     await addDependencies(projectRoot, { "@sentry/nextjs": "^8.0.0" });
@@ -5290,8 +5290,8 @@ async function generateSentry(projectRoot) {
 }
 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 (!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';
@@ -5300,15 +5300,15 @@ ${content}`;
     /(<Providers>)\{children\}(<\/Providers>)/,
     "$1<ErrorBoundary>{children}</ErrorBoundary>$2"
   );
-  await fs18.writeFile(layoutPath, content);
+  await fs19.writeFile(layoutPath, content);
 }
 async function setConfigFlag12(projectRoot, ctx) {
   const configPath = path19.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs18.pathExists(configPath)) return;
+  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(/sentry:\s*false/, "sentry: true");
-  await fs18.writeFile(configPath, updated);
+  await fs19.writeFile(configPath, updated);
 }
 function types11() {
   return `${STAMP12}
@@ -5453,11 +5453,11 @@ var feature_flags_exports = {};
 __export(feature_flags_exports, {
   generateFeatureFlags: () => generateFeatureFlags
 });
-import fs19 from "fs-extra";
+import fs20 from "fs-extra";
 import path20 from "path";
 async function generateFeatureFlags(projectRoot) {
   const featureDir = path20.join(projectRoot, "src", "features", "feature-flags");
-  if (await fs19.pathExists(featureDir)) {
+  if (await fs20.pathExists(featureDir)) {
     log.error("Feature flags feature already exists at src/features/feature-flags/");
     return;
   }
@@ -5478,8 +5478,8 @@ async function generateFeatureFlags(projectRoot) {
     for (const [filePath, content] of Object.entries(files)) {
       const fullPath = path20.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs19.ensureDir(path20.dirname(fullPath));
-      await fs19.writeFile(fullPath, content);
+      await fs20.ensureDir(path20.dirname(fullPath));
+      await fs20.writeFile(fullPath, content);
       count++;
     }
     await setConfigFlag13(projectRoot, ctx);
@@ -5500,11 +5500,11 @@ async function generateFeatureFlags(projectRoot) {
 }
 async function setConfigFlag13(projectRoot, ctx) {
   const configPath = path20.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs19.pathExists(configPath)) return;
+  if (!await fs20.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs19.readFile(configPath, "utf-8");
+  const content = await fs20.readFile(configPath, "utf-8");
   const updated = content.replace(/featureFlags:\s*false/, "featureFlags: true");
-  await fs19.writeFile(configPath, updated);
+  await fs20.writeFile(configPath, updated);
 }
 function types12() {
   return `${STAMP13}
@@ -5746,6 +5746,7 @@ import { Command } from "commander";
 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);
@@ -5754,13 +5755,23 @@ function readVersionFromPackageJson(packageDir) {
   return v ? v : "0.0.0";
 }
 function getCliVersion() {
-  const packageRoot = path.resolve(__dirname, "..", "..");
-  return readVersionFromPackageJson(packageRoot);
+  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 fs21 from "fs-extra";
+import fs22 from "fs-extra";
 import path22 from "path";
 import os3 from "os";
 import ora from "ora";
@@ -5770,7 +5781,7 @@ import prompts5 from "prompts";
 // src/utils/template.ts
 import path2 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import fs from "fs-extra";
+import fs2 from "fs-extra";
 var __dirname2 = path2.dirname(fileURLToPath2(import.meta.url));
 function getTemplatePath() {
   const candidates = [
@@ -5781,7 +5792,7 @@ function getTemplatePath() {
     path2.resolve(__dirname2, "..", "..", "..", "..", "template")
   ];
   for (const candidate of candidates) {
-    if (fs.existsSync(candidate)) {
+    if (fs2.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -6187,7 +6198,7 @@ async function promptTheme() {
 
 // src/generators/scaffold.ts
 init_logger();
-import fs2 from "fs-extra";
+import fs3 from "fs-extra";
 import path3 from "path";
 import { generateBrandCss } from "@mars-stack/ui/utils";
 
@@ -6372,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 = 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++;
       }
     }
@@ -6397,15 +6408,15 @@ function resolveMarsPackageRange(packageName, templateDir) {
     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(path3.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;
@@ -6417,7 +6428,7 @@ function resolveMarsPackageRange(packageName, templateDir) {
 function generatePackageJson(config) {
   const templateDir = getTemplatePath();
   const templatePkg = path3.join(templateDir, "package.json");
-  const pkg = fs2.readJsonSync(templatePkg);
+  const pkg = fs3.readJsonSync(templatePkg);
   pkg.name = config.name;
   pkg.version = "0.1.0";
   pkg.private = true;
@@ -6617,8 +6628,8 @@ async function pruneDisabledFeatures(features, targetDir) {
     if (flagValue !== false) continue;
     for (const relativePath of paths) {
       const fullPath = path3.join(targetDir, relativePath);
-      if (await fs2.pathExists(fullPath)) {
-        await fs2.remove(fullPath);
+      if (await fs3.pathExists(fullPath)) {
+        await fs3.remove(fullPath);
         log.step(`Pruned disabled feature path: ${relativePath}`);
       }
     }
@@ -6628,42 +6639,42 @@ async function pruneDisabledFeatures(features, targetDir) {
   }
   if (relationsToRemove.length > 0) {
     const authPath = path3.join(targetDir, "prisma", "schema", "auth.prisma");
-    if (await fs2.pathExists(authPath)) {
-      let content = await fs2.readFile(authPath, "utf-8");
+    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(path3.join(targetDir, "package.json"), generatePackageJson(config));
-  await fs2.writeFile(
+  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(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 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 = path3.join(targetDir, "src", "styles", "brand.css");
-  if (!await fs2.pathExists(brandPath)) return;
+  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",
@@ -6674,8 +6685,8 @@ var VALID_DESIGN_DIRECTIONS = [
 ];
 async function patchGlobalsCssForScaffoldedProject(targetDir, config) {
   const globalsPath = path3.join(targetDir, "src", "styles", "globals.css");
-  if (!await fs2.pathExists(globalsPath)) return;
-  let content = await fs2.readFile(globalsPath, "utf-8");
+  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";'
@@ -6694,7 +6705,7 @@ async function patchGlobalsCssForScaffoldedProject(targetDir, config) {
 ${newImport}`
     );
   }
-  await fs2.writeFile(globalsPath, content);
+  await fs3.writeFile(globalsPath, content);
 }
 
 // src/generators/generate-selected.ts
@@ -6810,13 +6821,13 @@ async function generateSelectedFeatures(projectRoot, features) {
 }
 
 // src/utils/telemetry.ts
-import fs20 from "fs-extra";
+import fs21 from "fs-extra";
 import path21 from "path";
 import os2 from "os";
 var RC_PATH = path21.join(os2.homedir(), ".marsrc");
 function isTelemetryEnabled() {
   try {
-    const config = fs20.readJsonSync(RC_PATH);
+    const config = fs21.readJsonSync(RC_PATH);
     return config.enabled === true;
   } catch {
     return false;
@@ -6825,16 +6836,16 @@ function isTelemetryEnabled() {
 function enableTelemetry() {
   const config = loadOrCreateConfig();
   config.enabled = true;
-  fs20.writeJsonSync(RC_PATH, config, { spaces: 2 });
+  fs21.writeJsonSync(RC_PATH, config, { spaces: 2 });
 }
 function disableTelemetry() {
   const config = loadOrCreateConfig();
   config.enabled = false;
-  fs20.writeJsonSync(RC_PATH, config, { spaces: 2 });
+  fs21.writeJsonSync(RC_PATH, config, { spaces: 2 });
 }
 function loadOrCreateConfig() {
   try {
-    return fs20.readJsonSync(RC_PATH);
+    return fs21.readJsonSync(RC_PATH);
   } catch {
     return { enabled: false, anonymousId: crypto.randomUUID() };
   }
@@ -6855,7 +6866,7 @@ function trackEvent(event, properties) {
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
   const logPath = path21.join(os2.homedir(), ".mars-telemetry.log");
-  fs20.appendFile(logPath, JSON.stringify(payload) + "\n").catch(() => {
+  fs21.appendFile(logPath, JSON.stringify(payload) + "\n").catch(() => {
   });
 }
 
@@ -6887,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 fs21.pathExists(targetDir)) {
-    const entries = await fs21.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;
@@ -6929,7 +6940,7 @@ async function createCommand(projectName, options) {
       log.info("Scaffolding cancelled.");
       process.exit(0);
     }
-    if (!fs21.pathExistsSync(RC_PATH2)) {
+    if (!fs22.pathExistsSync(RC_PATH2)) {
       const { telemetryOptIn } = await prompts5(
         {
           type: "confirm",
@@ -6968,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 fs21.pathExists(targetDir)) {
+    if (await fs22.pathExists(targetDir)) {
       const cleanupSpinner = ora("Cleaning up...").start();
       try {
-        await fs21.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.`);
@@ -6986,7 +6997,7 @@ function countEnabled(flags) {
 
 // src/commands/doctor.ts
 init_logger();
-import fs22 from "fs-extra";
+import fs23 from "fs-extra";
 import path23 from "path";
 import { execSync } from "child_process";
 function commandExists(cmd) {
@@ -7008,11 +7019,11 @@ async function checkForUpgrades() {
   log.blank();
   log.title("Upgrade Check");
   const packageJsonPath = path23.join(process.cwd(), "package.json");
-  if (!fs22.pathExistsSync(packageJsonPath)) {
+  if (!fs23.pathExistsSync(packageJsonPath)) {
     log.warn("No package.json found \u2014 skipping upgrade check.");
     return;
   }
-  const packageJson = fs22.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"];
@@ -7074,25 +7085,25 @@ async function doctorCommand(options) {
     },
     {
       name: "package.json exists",
-      check: () => fs22.pathExistsSync(path23.join(process.cwd(), "package.json"))
+      check: () => fs23.pathExistsSync(path23.join(process.cwd(), "package.json"))
     },
     {
       name: ".env file exists",
-      check: () => fs22.pathExistsSync(path23.join(process.cwd(), ".env"))
+      check: () => fs23.pathExistsSync(path23.join(process.cwd(), ".env"))
     },
     {
       name: "Prisma schema exists",
-      check: () => fs22.pathExistsSync(path23.join(process.cwd(), "prisma", "schema")) || fs22.pathExistsSync(path23.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: () => fs22.pathExistsSync(path23.join(process.cwd(), "node_modules"))
+      check: () => fs23.pathExistsSync(path23.join(process.cwd(), "node_modules"))
     },
     {
       name: "DATABASE_URL set",
       check: () => {
         try {
-          const envContent = fs22.readFileSync(path23.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 {
@@ -7104,7 +7115,7 @@ async function doctorCommand(options) {
       name: "JWT_SECRET set",
       check: () => {
         try {
-          const envContent = fs22.readFileSync(path23.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)";
@@ -7149,16 +7160,16 @@ async function doctorCommand(options) {
 
 // src/commands/add.ts
 init_logger();
-import fs24 from "fs-extra";
+import fs25 from "fs-extra";
 import path25 from "path";
 import pc3 from "picocolors";
 
 // src/utils/doc-updater.ts
-import fs23 from "fs-extra";
+import fs24 from "fs-extra";
 import path24 from "path";
 async function appendToDbSchema(projectDir, modelName, fields) {
   const filePath = path24.join(projectDir, "docs", "generated", "db-schema.md");
-  if (!await fs23.pathExists(filePath)) return;
+  if (!await fs24.pathExists(filePath)) return;
   const entry = [
     "",
     `### ${modelName}`,
@@ -7168,12 +7179,12 @@ async function appendToDbSchema(projectDir, modelName, fields) {
     ...fields.map((f) => `| ${f} |  |`),
     ""
   ].join("\n");
-  await fs23.appendFile(filePath, entry);
+  await fs24.appendFile(filePath, entry);
 }
 async function updateQualityScore(projectDir, domain, grade) {
   const filePath = path24.join(projectDir, "docs", "QUALITY_SCORE.md");
-  if (!await fs23.pathExists(filePath)) return;
-  const content = await fs23.readFile(filePath, "utf-8");
+  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) => {
@@ -7181,11 +7192,11 @@ async function updateQualityScore(projectDir, domain, grade) {
       parts[2] = ` ${grade} `;
       return parts.join("|");
     });
-    await fs23.writeFile(filePath, updated);
+    await fs24.writeFile(filePath, updated);
   } else {
     const row = `| ${domain} | ${grade} |  |
 `;
-    await fs23.appendFile(filePath, row);
+    await fs24.appendFile(filePath, row);
   }
 }
 function escapeRegex(str) {
@@ -7197,7 +7208,7 @@ init_rollback();
 function ensureInProject() {
   const cwd = process.cwd();
   const configPath = path25.join(cwd, "src", "config", "app.config.ts");
-  if (!fs24.pathExistsSync(configPath)) {
+  if (!fs25.pathExistsSync(configPath)) {
     log.error("Not inside a MARS project. Run this command from the project root.");
     process.exit(1);
   }
@@ -7231,7 +7242,7 @@ async function addFeatureCommand(name) {
   const pascal = toPascal(name);
   const camel = toCamel(name);
   const featureDir = path25.join(root, "src", "features", kebab);
-  if (await fs24.pathExists(featureDir)) {
+  if (await fs25.pathExists(featureDir)) {
     log.error(`Feature "${kebab}" already exists at src/features/${kebab}/`);
     return;
   }
@@ -7297,8 +7308,8 @@ export type Update${pascal}Input = z.infer<typeof ${camel}Schemas.update>;
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
       const fullPath = path25.join(featureDir, filePath);
-      await fs24.ensureDir(path25.dirname(fullPath));
-      await fs24.writeFile(fullPath, content);
+      await fs25.ensureDir(path25.dirname(fullPath));
+      await fs25.writeFile(fullPath, content);
       count++;
     }
     await ctx.commit();
@@ -7320,7 +7331,7 @@ async function addPageCommand(routePath, options) {
   const cleanPath = routePath.startsWith("/") ? routePath.slice(1) : routePath;
   const group = options.protected ? "(protected)" : "(public)";
   const pageDir = path25.join(root, "src", "app", group, cleanPath);
-  if (await fs24.pathExists(path25.join(pageDir, "page.tsx"))) {
+  if (await fs25.pathExists(path25.join(pageDir, "page.tsx"))) {
     log.error(`Page already exists at src/app/${group}/${cleanPath}/page.tsx`);
     return;
   }
@@ -7368,9 +7379,9 @@ export default function Loading() {
   const ctx = createRollbackContext();
   try {
     ctx.trackCreatedFile(pageDir);
-    await fs24.ensureDir(pageDir);
-    await fs24.writeFile(path25.join(pageDir, "page.tsx"), pageContent);
-    await fs24.writeFile(path25.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" });
@@ -7389,7 +7400,7 @@ async function addModelCommand(name) {
   const kebab = toKebab(name);
   const schemaDir = path25.join(root, "prisma", "schema");
   const schemaFile = path25.join(schemaDir, `${kebab}.prisma`);
-  if (await fs24.pathExists(schemaFile)) {
+  if (await fs25.pathExists(schemaFile)) {
     log.error(`Schema file already exists: prisma/schema/${kebab}.prisma`);
     return;
   }
@@ -7407,8 +7418,8 @@ async function addModelCommand(name) {
   const ctx = createRollbackContext();
   try {
     ctx.trackCreatedFile(schemaFile);
-    await fs24.ensureDir(schemaDir);
-    await fs24.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" });
@@ -7432,7 +7443,7 @@ async function addEmailCommand(name) {
   const camel = toCamel(name);
   const templatesDir = path25.join(root, "src", "lib", "core", "email", "templates");
   const filePath = path25.join(templatesDir, `${kebab}-email.ts`);
-  if (await fs24.pathExists(filePath)) {
+  if (await fs25.pathExists(filePath)) {
     log.error(`Email template already exists: src/lib/core/email/templates/${kebab}-email.ts`);
     return;
   }
@@ -7479,22 +7490,22 @@ export function ${functionName}({ appName, actionUrl, userName }: ${pascal}Email
   const indexPath = path25.join(templatesDir, "index.ts");
   try {
     ctx.trackCreatedFile(filePath);
-    if (await fs24.pathExists(indexPath)) {
+    if (await fs25.pathExists(indexPath)) {
       await ctx.trackModifiedFile(indexPath);
     } else {
       ctx.trackCreatedFile(indexPath);
     }
-    await fs24.ensureDir(templatesDir);
-    await fs24.writeFile(filePath, content);
+    await fs25.ensureDir(templatesDir);
+    await fs25.writeFile(filePath, content);
     const exportLine = `export { ${functionName} } from './${kebab}-email';
 `;
-    if (await fs24.pathExists(indexPath)) {
-      const existing = await fs24.readFile(indexPath, "utf-8");
+    if (await fs25.pathExists(indexPath)) {
+      const existing = await fs25.readFile(indexPath, "utf-8");
       if (!existing.includes(functionName)) {
-        await fs24.appendFile(indexPath, exportLine);
+        await fs25.appendFile(indexPath, exportLine);
       }
     } else {
-      await fs24.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`);
@@ -7518,9 +7529,9 @@ async function addComponentCommand(name, options) {
     return;
   }
   const dir = type === "primitive" ? path25.join(root, "src", "components", "primitives") : path25.join(root, "src", "components", "patterns");
-  await fs24.ensureDir(dir);
+  await fs25.ensureDir(dir);
   const filePath = path25.join(dir, `${pascal}.tsx`);
-  if (await fs24.pathExists(filePath)) {
+  if (await fs25.pathExists(filePath)) {
     log.error(`Component already exists: ${pascal}.tsx`);
     return;
   }
@@ -7569,7 +7580,7 @@ export function ${pascal}({ children, className }: ${pascal}Props) {
   const ctx = createRollbackContext();
   try {
     ctx.trackCreatedFile(filePath);
-    await fs24.writeFile(filePath, content);
+    await fs25.writeFile(filePath, content);
     await ctx.commit();
     log.success(`Created ${type} component ${pc3.bold(pascal)} at ${path25.relative(root, filePath)}`);
     trackEvent("add", { type: "component", componentType: type });
@@ -7586,14 +7597,14 @@ export function ${pascal}({ children, className }: ${pascal}Props) {
 // src/commands/configure.ts
 init_logger();
 import { execSync as execSync2 } from "child_process";
-import fs25 from "fs-extra";
+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 = path26.join(cwd, "src", "config", "app.config.ts");
-  if (!fs25.pathExistsSync(configPath)) {
+  if (!fs26.pathExistsSync(configPath)) {
     log.error("Not inside a MARS project. Run this command from the project root.");
     process.exit(1);
   }
@@ -7608,7 +7619,7 @@ var PROVIDER_DEPENDENCIES = {
 };
 function updateAppConfig(projectDir, serviceKey, provider, featureKey) {
   const configPath = path26.join(projectDir, "src", "config", "app.config.ts");
-  let content = fs25.readFileSync(configPath, "utf-8");
+  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)`);
@@ -7623,10 +7634,10 @@ function updateAppConfig(projectDir, serviceKey, provider, featureKey) {
       content = content.replace(featureRegex, `$1true`);
     }
   }
-  fs25.writeFileSync(configPath, content);
+  fs26.writeFileSync(configPath, content);
 }
 function detectPackageManager(projectDir) {
-  if (fs25.existsSync(path26.join(projectDir, "yarn.lock"))) return "yarn";
+  if (fs26.existsSync(path26.join(projectDir, "yarn.lock"))) return "yarn";
   return "npm";
 }
 function installDependencies(projectDir, deps) {
@@ -7737,14 +7748,14 @@ async function configureCommand(service) {
   }
   if (selectedProvider.envVars.length > 0) {
     const envPath = path26.join(root, ".env");
-    if (await fs25.pathExists(envPath)) {
-      const envContent = await fs25.readFile(envPath, "utf-8");
+    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 fs25.appendFile(envPath, `
+        await fs26.appendFile(envPath, `
 # ${selectedService} (${provider})
 ${additions}
 `);
@@ -7773,7 +7784,7 @@ ${additions}
 
 // src/commands/deploy.ts
 init_logger();
-import fs26 from "fs-extra";
+import fs27 from "fs-extra";
 import path27 from "path";
 import { execSync as execSync3 } from "child_process";
 import pc5 from "picocolors";
@@ -7781,7 +7792,7 @@ import prompts7 from "prompts";
 function ensureInProject3() {
   const cwd = process.cwd();
   const configPath = path27.join(cwd, "src", "config", "app.config.ts");
-  if (!fs26.pathExistsSync(configPath)) {
+  if (!fs27.pathExistsSync(configPath)) {
     log.error("Not inside a MARS project. Run this command from the project root.");
     process.exit(1);
   }
@@ -7821,7 +7832,7 @@ async function deployCommand() {
     }
   }
   const vercelDir = path27.join(root, ".vercel");
-  if (!fs26.existsSync(vercelDir)) {
+  if (!fs27.existsSync(vercelDir)) {
     log.step("Linking project to Vercel...");
     try {
       execSync3("vercel link", { cwd: root, stdio: "inherit" });
@@ -7839,7 +7850,7 @@ async function deployCommand() {
   const requiredVars = ["JWT_SECRET", "DATABASE_URL"];
   log.step(`Core: ${pc5.dim(requiredVars.join(", "))}`);
   const configPath = path27.join(root, "src", "config", "app.config.ts");
-  const configContent = await fs26.readFile(configPath, "utf-8");
+  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'")) {
@@ -7900,7 +7911,7 @@ async function deployCommand() {
 
 // src/commands/upgrade.ts
 init_logger();
-import fs27 from "fs-extra";
+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"];
@@ -7924,7 +7935,7 @@ function readCurrentVersion(packageJson, packageName) {
   return version ? version.replace(/^[\^~]/, "") : null;
 }
 function detectPackageManager2(projectDir) {
-  if (fs27.pathExistsSync(path28.join(projectDir, "yarn.lock"))) {
+  if (fs28.pathExistsSync(path28.join(projectDir, "yarn.lock"))) {
     return "yarn";
   }
   return "npm";
@@ -7988,7 +7999,7 @@ function updatePackageJsonVersions(packageJsonPath, packageJson, versions) {
   if (updated.length > 0) {
     packageJson.dependencies = deps;
     packageJson.devDependencies = devDeps;
-    fs27.writeJsonSync(packageJsonPath, packageJson, { spaces: 2 });
+    fs28.writeJsonSync(packageJsonPath, packageJson, { spaces: 2 });
   }
   return updated;
 }
@@ -7999,14 +8010,14 @@ function upgradeCommand(program2) {
     log.title("MARS Upgrade");
     const projectDir = process.cwd();
     const packageJsonPath = path28.join(projectDir, "package.json");
-    if (!fs27.pathExistsSync(packageJsonPath)) {
+    if (!fs28.pathExistsSync(packageJsonPath)) {
       log.error(
         "No package.json found. Are you in a Mars project directory?"
       );
       process.exitCode = 1;
       return;
     }
-    const packageJson = fs27.readJsonSync(packageJsonPath);
+    const packageJson = fs28.readJsonSync(packageJsonPath);
     const hasMarsPackage = MARS_PACKAGES.some(
       (name) => readCurrentVersion(packageJson, name) !== null
     );