@nextsparkjs/cli 0.1.0-beta.3 → 0.1.0-beta.5

package/dist/cli.js

@@ -1,8 +1,17 @@
 #!/usr/bin/env node
+import {
+  __require,
+  addPlugin,
+  addPluginCommand,
+  fetchPackage,
+  installTheme,
+  runPostinstall,
+  validateTheme
+} from "./chunk-ALB2C27N.js";
 
 // src/cli.ts
 import { Command } from "commander";
-import chalk6 from "chalk";
+import chalk15 from "chalk";
 
 // src/commands/dev.ts
 import { spawn } from "child_process";
@@ -107,21 +116,46 @@ async function devCommand(options) {
 
 // src/commands/build.ts
 import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { join } from "path";
 import chalk2 from "chalk";
 import ora2 from "ora";
+function loadProjectEnv(projectRoot) {
+  const envPath = join(projectRoot, ".env");
+  const envVars = {};
+  if (existsSync2(envPath)) {
+    const content = readFileSync(envPath, "utf-8");
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("#")) {
+        const [key, ...valueParts] = trimmed.split("=");
+        if (key && valueParts.length > 0) {
+          let value = valueParts.join("=");
+          if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+            value = value.slice(1, -1);
+          }
+          envVars[key] = value;
+        }
+      }
+    }
+  }
+  return envVars;
+}
 async function buildCommand(options) {
   const spinner = ora2("Preparing production build...").start();
   try {
     const coreDir = getCoreDir();
     const projectRoot = getProjectRoot();
     spinner.succeed("Core package found");
+    const projectEnv = loadProjectEnv(projectRoot);
     if (options.registry) {
       spinner.start("Generating registries...");
-      await new Promise((resolve2, reject) => {
-        const registryProcess = spawn2("node", ["scripts/registry-build.js"], {
+      await new Promise((resolve4, reject) => {
+        const registryProcess = spawn2("node", ["scripts/build/registry.mjs"], {
           cwd: coreDir,
           stdio: "pipe",
           env: {
+            ...projectEnv,
             ...process.env,
             NEXTSPARK_PROJECT_ROOT: projectRoot
           }
@@ -132,7 +166,7 @@ async function buildCommand(options) {
         });
         registryProcess.on("close", (code) => {
           if (code === 0) {
-            resolve2();
+            resolve4();
           } else {
             reject(new Error(`Registry generation failed: ${stderr}`));
           }
@@ -146,6 +180,7 @@ async function buildCommand(options) {
       cwd: projectRoot,
       stdio: "inherit",
       env: {
+        ...projectEnv,
         ...process.env,
         NEXTSPARK_CORE_DIR: coreDir,
         NODE_ENV: "production"
@@ -177,8 +212,31 @@ Build failed with exit code ${code}`));
 
 // src/commands/generate.ts
 import { spawn as spawn3 } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
 import chalk3 from "chalk";
 import ora3 from "ora";
+function loadProjectEnv2(projectRoot) {
+  const envPath = join2(projectRoot, ".env");
+  const envVars = {};
+  if (existsSync3(envPath)) {
+    const content = readFileSync2(envPath, "utf-8");
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("#")) {
+        const [key, ...valueParts] = trimmed.split("=");
+        if (key && valueParts.length > 0) {
+          let value = valueParts.join("=");
+          if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+            value = value.slice(1, -1);
+          }
+          envVars[key] = value;
+        }
+      }
+    }
+  }
+  return envVars;
+}
 async function generateCommand(options) {
   const spinner = ora3("Preparing registry generation...").start();
   try {
@@ -186,14 +244,16 @@ async function generateCommand(options) {
     const projectRoot = getProjectRoot();
     const mode = isMonorepoMode() ? "monorepo" : "npm";
     spinner.succeed(`Core found at: ${coreDir} (${mode} mode)`);
-    const scriptName = options.watch ? "registry-watch.js" : "registry-build.js";
+    const projectEnv = loadProjectEnv2(projectRoot);
+    const watchArg = options.watch ? ["--watch"] : [];
     const action = options.watch ? "Watching" : "Generating";
     console.log(chalk3.blue(`
 ${action} registries...`));
-    const generateProcess = spawn3("node", [`scripts/${scriptName}`], {
+    const generateProcess = spawn3("node", ["scripts/build/registry.mjs", ...watchArg], {
       cwd: coreDir,
       stdio: "inherit",
       env: {
+        ...projectEnv,
         ...process.env,
         NEXTSPARK_PROJECT_ROOT: projectRoot
       }
@@ -236,19 +296,44 @@ Registry generation failed with exit code ${code}`));
 
 // src/commands/registry.ts
 import { spawn as spawn4 } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
 import chalk4 from "chalk";
 import ora4 from "ora";
+function loadProjectEnv3(projectRoot) {
+  const envPath = join3(projectRoot, ".env");
+  const envVars = {};
+  if (existsSync4(envPath)) {
+    const content = readFileSync3(envPath, "utf-8");
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("#")) {
+        const [key, ...valueParts] = trimmed.split("=");
+        if (key && valueParts.length > 0) {
+          let value = valueParts.join("=");
+          if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+            value = value.slice(1, -1);
+          }
+          envVars[key] = value;
+        }
+      }
+    }
+  }
+  return envVars;
+}
 async function registryBuildCommand() {
   const spinner = ora4("Building registries...").start();
   try {
     const coreDir = getCoreDir();
     const projectRoot = getProjectRoot();
     const mode = isMonorepoMode() ? "monorepo" : "npm";
+    const projectEnv = loadProjectEnv3(projectRoot);
     spinner.text = `Building registries (${mode} mode)...`;
-    const buildProcess = spawn4("node", ["scripts/registry-build.js"], {
+    const buildProcess = spawn4("node", ["scripts/build/registry.mjs"], {
       cwd: coreDir,
       stdio: "pipe",
       env: {
+        ...projectEnv,
         ...process.env,
         NEXTSPARK_PROJECT_ROOT: projectRoot
       }
@@ -297,10 +382,12 @@ async function registryWatchCommand() {
     const mode = isMonorepoMode() ? "monorepo" : "npm";
     spinner.succeed(`Registry watcher started (${mode} mode)`);
     console.log(chalk4.blue("\nWatching for changes... Press Ctrl+C to stop.\n"));
-    const watchProcess = spawn4("node", ["scripts/registry-watch.js"], {
+    const projectEnv = loadProjectEnv3(projectRoot);
+    const watchProcess = spawn4("node", ["scripts/build/registry.mjs", "--watch"], {
       cwd: coreDir,
       stdio: "inherit",
       env: {
+        ...projectEnv,
         ...process.env,
         NEXTSPARK_PROJECT_ROOT: projectRoot
       }
@@ -335,111 +422,3187 @@ Watcher exited with code ${code}`));
 }
 
 // src/commands/init.ts
-import { existsSync as existsSync2, mkdirSync, writeFileSync, readFileSync } from "fs";
-import { join } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync6 } from "fs";
+import { join as join7 } from "path";
+import chalk12 from "chalk";
+import ora8 from "ora";
+
+// src/wizard/index.ts
+import chalk11 from "chalk";
+import ora7 from "ora";
+import { confirm as confirm5 } from "@inquirer/prompts";
+import { execSync } from "child_process";
+import { existsSync as existsSync7, readdirSync } from "fs";
+import { join as join6 } from "path";
+
+// src/wizard/banner.ts
 import chalk5 from "chalk";
-import ora5 from "ora";
-function generateInitialRegistries(registriesDir) {
-  writeFileSync(join(registriesDir, "block-registry.ts"), `// Auto-generated by nextspark init - Run 'nextspark generate' to populate
-import type { ComponentType } from 'react'
+var BANNER = `
+    _   __          __  _____                  __
+   / | / /__  _  __/ /_/ ___/____  ____ ______/ /__
+  /  |/ / _ \\| |/_/ __/\\__ \\/ __ \\/ __ \`/ ___/ //_/
+ / /|  /  __/>  </ /_ ___/ / /_/ / /_/ / /  / ,<
+/_/ |_/\\___/_/|_|\\__//____/ .___/\\__,_/_/  /_/|_|
+                         /_/
+`;
+function showBanner() {
+  console.log(chalk5.cyan(BANNER));
+  console.log(chalk5.bold.white("  Welcome to NextSpark - The Complete SaaS Framework for Next.js"));
+  console.log(chalk5.gray("  Create production-ready SaaS applications in minutes\n"));
+  console.log(chalk5.gray("  " + "=".repeat(60) + "\n"));
+}
+function showSection(title, step, totalSteps) {
+  console.log("");
+  console.log(chalk5.cyan(`  Step ${step}/${totalSteps}: ${title}`));
+  console.log(chalk5.gray("  " + "-".repeat(40)));
+  console.log("");
+}
+function showWarning(message) {
+  console.log(chalk5.yellow(`  \u26A0 ${message}`));
+}
+function showError(message) {
+  console.log(chalk5.red(`  \u2717 ${message}`));
+}
+function showInfo(message) {
+  console.log(chalk5.blue(`  \u2139 ${message}`));
+}
 
-export const BLOCK_REGISTRY: Record<string, {
-  name: string
-  slug: string
-  componentPath: string
-  fields?: unknown[]
-  examples?: unknown[]
-}> = {}
+// src/wizard/prompts/project-info.ts
+import { input } from "@inquirer/prompts";
+function toSlug(str) {
+  return str.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function validateProjectName(name) {
+  if (!name || name.trim().length === 0) {
+    return "Project name is required";
+  }
+  if (name.trim().length < 2) {
+    return "Project name must be at least 2 characters";
+  }
+  if (name.trim().length > 50) {
+    return "Project name must be less than 50 characters";
+  }
+  return true;
+}
+function validateSlug(slug) {
+  if (!slug || slug.trim().length === 0) {
+    return "Slug is required";
+  }
+  if (!/^[a-z][a-z0-9-]*$/.test(slug)) {
+    return "Slug must start with a letter and contain only lowercase letters, numbers, and hyphens";
+  }
+  if (slug.length < 2) {
+    return "Slug must be at least 2 characters";
+  }
+  if (slug.length > 30) {
+    return "Slug must be less than 30 characters";
+  }
+  return true;
+}
+async function promptProjectInfo() {
+  showSection("Project Information", 1, 5);
+  const projectName = await input({
+    message: "What is your project name?",
+    default: "My SaaS App",
+    validate: validateProjectName
+  });
+  const suggestedSlug = toSlug(projectName);
+  const projectSlug = await input({
+    message: "Project slug (used for theme folder and URLs):",
+    default: suggestedSlug,
+    validate: validateSlug
+  });
+  const projectDescription = await input({
+    message: "Short description of your project:",
+    default: "A modern SaaS application built with NextSpark"
+  });
+  return {
+    projectName,
+    projectSlug,
+    projectDescription
+  };
+}
 
-// Lazy-loaded block components - populated by 'nextspark generate'
-export const BLOCK_COMPONENTS: Record<string, React.LazyExoticComponent<ComponentType<any>>> = {}
-`);
-  writeFileSync(join(registriesDir, "theme-registry.ts"), `// Auto-generated by nextspark init - Run 'nextspark generate' to populate
-export const THEME_REGISTRY: Record<string, unknown> = {}
-`);
-  writeFileSync(join(registriesDir, "entity-registry.ts"), `// Auto-generated by nextspark init - Run 'nextspark generate' to populate
-export const ENTITY_REGISTRY: Record<string, unknown> = {}
-`);
-  writeFileSync(join(registriesDir, "entity-registry.client.ts"), `// Auto-generated by nextspark init - Run 'nextspark generate' to populate
-export const CLIENT_ENTITY_REGISTRY: Record<string, unknown> = {}
-export function parseChildEntity(path: string) { return null }
-export function getEntityApiPath(entity: string) { return \`/api/\${entity}\` }
-export function clientMetaSystemAdapter() { return {} }
-export type ClientEntityConfig = Record<string, unknown>
-`);
-  writeFileSync(join(registriesDir, "billing-registry.ts"), `// Auto-generated by nextspark init - Run 'nextspark generate' to populate
-export const BILLING_REGISTRY = { plans: [], features: [] }
-`);
-  writeFileSync(join(registriesDir, "plugin-registry.ts"), `// Auto-generated by nextspark init - Run 'nextspark generate' to populate
-export const PLUGIN_REGISTRY: Record<string, unknown> = {}
-`);
-  writeFileSync(join(registriesDir, "testing-registry.ts"), `// Auto-generated by nextspark init - Run 'nextspark generate' to populate
-export const FLOW_REGISTRY: Record<string, unknown> = {}
-export const FEATURE_REGISTRY: Record<string, unknown> = {}
-export const TAGS_REGISTRY: Record<string, unknown> = {}
-export const COVERAGE_SUMMARY = { total: 0, covered: 0 }
-export type FlowEntry = unknown
-export type FeatureEntry = unknown
-`);
-  writeFileSync(join(registriesDir, "docs-registry.ts"), `// Auto-generated by nextspark init - Run 'nextspark generate' to populate
-export const DOCS_REGISTRY = { sections: [], pages: [] }
-export type DocSectionMeta = { title: string; slug: string }
-`);
-  writeFileSync(join(registriesDir, "index.ts"), `// Auto-generated by nextspark init - Run 'nextspark generate' to populate
-export * from './block-registry'
-export * from './theme-registry'
-export * from './entity-registry'
-export * from './entity-registry.client'
-export * from './billing-registry'
-export * from './plugin-registry'
-export * from './testing-registry'
-export * from './docs-registry'
-`);
+// src/wizard/prompts/team-config.ts
+import { select, checkbox } from "@inquirer/prompts";
+
+// src/wizard/types.ts
+var AVAILABLE_LOCALES = {
+  en: "English",
+  es: "Spanish",
+  fr: "French",
+  de: "German",
+  it: "Italian",
+  pt: "Portuguese"
+};
+var DEFAULT_ROLES = ["owner", "admin", "member", "viewer"];
+var CURRENCIES = [
+  { value: "usd", label: "USD - US Dollar" },
+  { value: "eur", label: "EUR - Euro" },
+  { value: "gbp", label: "GBP - British Pound" },
+  { value: "cad", label: "CAD - Canadian Dollar" },
+  { value: "aud", label: "AUD - Australian Dollar" },
+  { value: "ars", label: "ARS - Argentine Peso" },
+  { value: "brl", label: "BRL - Brazilian Real" },
+  { value: "mxn", label: "MXN - Mexican Peso" }
+];
+
+// src/wizard/prompts/team-config.ts
+var TEAM_MODE_OPTIONS = [
+  {
+    name: "Multi-tenant (Multiple teams, team switching)",
+    value: "multi-tenant",
+    description: "Users can create and join multiple teams. Perfect for CRM, project management, or collaboration tools."
+  },
+  {
+    name: "Single-tenant (One organization, no switching)",
+    value: "single-tenant",
+    description: "All users belong to one organization. Ideal for internal tools or company-specific applications."
+  },
+  {
+    name: "Single-user (Personal app, no teams)",
+    value: "single-user",
+    description: "Individual user accounts without team features. Perfect for personal dashboards or blogs."
+  }
+];
+var ROLE_OPTIONS = [
+  { name: "Owner (Full control, can delete team)", value: "owner", checked: true },
+  { name: "Admin (Can manage members and settings)", value: "admin", checked: true },
+  { name: "Member (Standard access)", value: "member", checked: true },
+  { name: "Viewer (Read-only access)", value: "viewer", checked: true }
+];
+async function promptTeamConfig() {
+  showSection("Team Configuration", 2, 5);
+  const teamMode = await select({
+    message: "What team mode do you need?",
+    choices: TEAM_MODE_OPTIONS,
+    default: "multi-tenant"
+  });
+  const selectedOption = TEAM_MODE_OPTIONS.find((o) => o.value === teamMode);
+  if (selectedOption) {
+    showInfo(selectedOption.description);
+  }
+  let teamRoles = DEFAULT_ROLES;
+  if (teamMode !== "single-user") {
+    console.log("");
+    teamRoles = await checkbox({
+      message: "Which roles do you want to include?",
+      choices: ROLE_OPTIONS,
+      required: true
+    });
+    if (!teamRoles.includes("owner")) {
+      teamRoles = ["owner", ...teamRoles];
+      showInfo("Owner role is required and has been added automatically.");
+    }
+    console.log("");
+    showInfo("You can add custom roles later by editing app.config.ts");
+  }
+  return {
+    teamMode,
+    teamRoles
+  };
 }
-async function initCommand(options) {
-  const spinner = ora5("Initializing NextSpark project...").start();
-  const projectRoot = process.cwd();
+
+// src/wizard/prompts/i18n-config.ts
+import { select as select2, checkbox as checkbox2 } from "@inquirer/prompts";
+var LOCALE_OPTIONS = Object.entries(AVAILABLE_LOCALES).map(([value, name]) => ({
+  name: `${name} (${value})`,
+  value,
+  checked: value === "en"
+  // English selected by default
+}));
+async function promptI18nConfig() {
+  showSection("Internationalization", 3, 5);
+  const supportedLocales = await checkbox2({
+    message: "Which languages do you want to support?",
+    choices: LOCALE_OPTIONS,
+    required: true
+  });
+  if (supportedLocales.length === 0) {
+    showInfo("At least one language is required. English has been selected.");
+    supportedLocales.push("en");
+  }
+  let defaultLocale = "en";
+  if (supportedLocales.length === 1) {
+    defaultLocale = supportedLocales[0];
+    showInfo(`Default language set to ${AVAILABLE_LOCALES[defaultLocale]}`);
+  } else {
+    console.log("");
+    defaultLocale = await select2({
+      message: "Which should be the default language?",
+      choices: supportedLocales.map((locale) => ({
+        name: `${AVAILABLE_LOCALES[locale]} (${locale})`,
+        value: locale
+      })),
+      default: supportedLocales.includes("en") ? "en" : supportedLocales[0]
+    });
+  }
+  return {
+    defaultLocale,
+    supportedLocales
+  };
+}
+
+// src/wizard/prompts/billing-config.ts
+import { select as select3 } from "@inquirer/prompts";
+var BILLING_MODEL_OPTIONS = [
+  {
+    name: "Free (No payments)",
+    value: "free",
+    description: "All features are free. No payment processing needed."
+  },
+  {
+    name: "Freemium (Free + Paid tiers)",
+    value: "freemium",
+    description: "Free tier with optional paid upgrades (Free + Pro plans)."
+  },
+  {
+    name: "Paid (Subscription required)",
+    value: "paid",
+    description: "Subscription-based access with optional trial period."
+  }
+];
+async function promptBillingConfig() {
+  showSection("Billing Configuration", 4, 5);
+  const billingModel = await select3({
+    message: "What billing model do you want to use?",
+    choices: BILLING_MODEL_OPTIONS,
+    default: "freemium"
+  });
+  const selectedOption = BILLING_MODEL_OPTIONS.find((o) => o.value === billingModel);
+  if (selectedOption) {
+    showInfo(selectedOption.description);
+  }
+  let currency = "usd";
+  if (billingModel !== "free") {
+    console.log("");
+    currency = await select3({
+      message: "What currency will you use?",
+      choices: CURRENCIES.map((c) => ({
+        name: c.label,
+        value: c.value
+      })),
+      default: "usd"
+    });
+  }
+  console.log("");
+  showInfo("You can customize plans and pricing in billing.config.ts");
+  return {
+    billingModel,
+    currency
+  };
+}
+
+// src/wizard/prompts/features-config.ts
+import { checkbox as checkbox3 } from "@inquirer/prompts";
+var FEATURE_OPTIONS = [
+  {
+    name: "Analytics Dashboard",
+    value: "analytics",
+    description: "Built-in analytics and metrics dashboard",
+    checked: true
+  },
+  {
+    name: "Team Management",
+    value: "teams",
+    description: "Team invitations, roles, and member management",
+    checked: true
+  },
+  {
+    name: "Billing & Subscriptions",
+    value: "billing",
+    description: "Stripe integration for payments and subscriptions",
+    checked: true
+  },
+  {
+    name: "API Access",
+    value: "api",
+    description: "REST API endpoints with authentication",
+    checked: true
+  },
+  {
+    name: "Documentation Site",
+    value: "docs",
+    description: "Built-in documentation system with markdown support",
+    checked: false
+  }
+];
+async function promptFeaturesConfig() {
+  showSection("Features", 5, 5);
+  showInfo("Select the features you want to include in your project.");
+  showInfo("You can add or remove features later by editing your config files.");
+  console.log("");
+  const selectedFeatures = await checkbox3({
+    message: "Which features do you want to enable?",
+    choices: FEATURE_OPTIONS
+  });
+  const features = {
+    analytics: selectedFeatures.includes("analytics"),
+    teams: selectedFeatures.includes("teams"),
+    billing: selectedFeatures.includes("billing"),
+    api: selectedFeatures.includes("api"),
+    docs: selectedFeatures.includes("docs")
+  };
+  return {
+    features
+  };
+}
+
+// src/wizard/prompts/content-features-config.ts
+import { checkbox as checkbox4 } from "@inquirer/prompts";
+var CONTENT_FEATURE_OPTIONS = [
+  {
+    name: "Pages with Page Builder",
+    value: "pages",
+    description: "Adds the 'page' entity with full page builder support. Build custom pages using blocks.",
+    checked: false
+  },
+  {
+    name: "Blog",
+    value: "blog",
+    description: "Adds the 'post' entity for blog articles with the Post Content block for rich editorial content.",
+    checked: false
+  }
+];
+async function promptContentFeaturesConfig(mode = "interactive", totalSteps = 9) {
+  showSection("Content Features", 6, totalSteps);
+  showInfo("Enable optional content features for your project.");
+  showInfo("These features add entities and blocks for building pages and blog posts.");
+  console.log("");
+  const selectedFeatures = await checkbox4({
+    message: "Which content features do you want to enable?",
+    choices: CONTENT_FEATURE_OPTIONS
+  });
+  console.log("");
+  showInfo("You can add more blocks later in contents/themes/[your-theme]/blocks/");
+  const contentFeatures = {
+    pages: selectedFeatures.includes("pages"),
+    blog: selectedFeatures.includes("blog")
+  };
+  return {
+    contentFeatures
+  };
+}
+
+// src/wizard/prompts/auth-config.ts
+import { checkbox as checkbox5 } from "@inquirer/prompts";
+var AUTH_METHOD_OPTIONS = [
+  {
+    name: "Email & Password",
+    value: "emailPassword",
+    description: "Traditional email and password authentication",
+    checked: true
+  },
+  {
+    name: "Google OAuth",
+    value: "googleOAuth",
+    description: "Sign in with Google accounts",
+    checked: false
+  }
+];
+var SECURITY_OPTIONS = [
+  {
+    name: "Email Verification",
+    value: "emailVerification",
+    description: "Require users to verify their email address",
+    checked: true
+  }
+];
+function getDefaultAuthConfig() {
+  return {
+    emailPassword: true,
+    googleOAuth: false,
+    emailVerification: true
+  };
+}
+async function promptAuthConfig(mode = "interactive", totalSteps = 8) {
+  showSection("Authentication", 6, totalSteps);
+  showInfo("Configure how users will authenticate to your application.");
+  console.log("");
+  const selectedMethods = await checkbox5({
+    message: "Which authentication methods do you want to enable?",
+    choices: AUTH_METHOD_OPTIONS
+  });
+  let selectedSecurity = ["emailVerification"];
+  if (mode === "expert") {
+    console.log("");
+    showInfo("Configure additional security features.");
+    console.log("");
+    selectedSecurity = await checkbox5({
+      message: "Which security features do you want to enable?",
+      choices: SECURITY_OPTIONS
+    });
+  }
+  const auth = {
+    emailPassword: selectedMethods.includes("emailPassword"),
+    googleOAuth: selectedMethods.includes("googleOAuth"),
+    emailVerification: selectedSecurity.includes("emailVerification")
+  };
+  return { auth };
+}
+
+// src/wizard/prompts/dashboard-config.ts
+import { checkbox as checkbox6, confirm } from "@inquirer/prompts";
+var DASHBOARD_FEATURE_OPTIONS = [
+  {
+    name: "Global Search",
+    value: "search",
+    description: "Search across your application from the dashboard",
+    checked: false
+  },
+  {
+    name: "Notifications",
+    value: "notifications",
+    description: "In-app notification system with bell icon",
+    checked: false
+  },
+  {
+    name: "Theme Toggle",
+    value: "themeToggle",
+    description: "Allow users to switch between light and dark themes",
+    checked: true
+  },
+  {
+    name: "Support/Help Menu",
+    value: "support",
+    description: "Help dropdown with documentation and support links",
+    checked: true
+  },
+  {
+    name: "Quick Create",
+    value: "quickCreate",
+    description: "Quick create button for creating new entities",
+    checked: true
+  },
+  {
+    name: "Superadmin Access",
+    value: "superadminAccess",
+    description: "Button to access superadmin area (only visible to superadmins)",
+    checked: true
+  },
+  {
+    name: "DevTools Access",
+    value: "devtoolsAccess",
+    description: "Button to access developer tools (only visible to developers)",
+    checked: true
+  }
+];
+function getDefaultDashboardConfig() {
+  return {
+    search: false,
+    notifications: false,
+    themeToggle: true,
+    support: true,
+    quickCreate: true,
+    superadminAccess: true,
+    devtoolsAccess: true,
+    sidebarCollapsed: false
+  };
+}
+async function promptDashboardConfig(mode = "interactive", totalSteps = 8) {
+  showSection("Dashboard", 7, totalSteps);
+  showInfo("Configure your dashboard user interface.");
+  showInfo("These settings can be changed later in your theme config.");
+  console.log("");
+  const selectedFeatures = await checkbox6({
+    message: "Which dashboard features do you want to enable?",
+    choices: DASHBOARD_FEATURE_OPTIONS
+  });
+  let sidebarCollapsed = false;
+  if (mode === "expert") {
+    console.log("");
+    sidebarCollapsed = await confirm({
+      message: "Start with sidebar collapsed by default?",
+      default: false
+    });
+  }
+  const dashboard = {
+    search: selectedFeatures.includes("search"),
+    notifications: selectedFeatures.includes("notifications"),
+    themeToggle: selectedFeatures.includes("themeToggle"),
+    support: selectedFeatures.includes("support"),
+    quickCreate: selectedFeatures.includes("quickCreate"),
+    superadminAccess: selectedFeatures.includes("superadminAccess"),
+    devtoolsAccess: selectedFeatures.includes("devtoolsAccess"),
+    sidebarCollapsed
+  };
+  return { dashboard };
+}
+
+// src/wizard/prompts/dev-config.ts
+import { checkbox as checkbox7, confirm as confirm2 } from "@inquirer/prompts";
+var DEV_TOOL_OPTIONS = [
+  {
+    name: "Dev Keyring",
+    value: "devKeyring",
+    description: "Quick login as different users during development",
+    checked: true
+  },
+  {
+    name: "Debug Mode",
+    value: "debugMode",
+    description: "Enable verbose logging and debugging tools",
+    checked: false
+  }
+];
+function getDefaultDevConfig() {
+  return {
+    devKeyring: true,
+    debugMode: false
+  };
+}
+async function promptDevConfig(mode = "interactive", totalSteps = 8) {
+  showSection("Development Tools", 8, totalSteps);
+  showInfo("Configure development and debugging tools.");
+  showWarning("These tools are disabled in production builds.");
+  console.log("");
+  let devKeyring = true;
+  let debugMode = false;
+  if (mode === "expert") {
+    const selectedTools = await checkbox7({
+      message: "Which development tools do you want to enable?",
+      choices: DEV_TOOL_OPTIONS
+    });
+    devKeyring = selectedTools.includes("devKeyring");
+    debugMode = selectedTools.includes("debugMode");
+  } else {
+    devKeyring = await confirm2({
+      message: "Enable dev keyring for quick user switching during development?",
+      default: true
+    });
+  }
+  const dev = {
+    devKeyring,
+    debugMode
+  };
+  return { dev };
+}
+
+// src/wizard/prompts/theme-selection.ts
+import { select as select4 } from "@inquirer/prompts";
+import chalk6 from "chalk";
+async function promptThemeSelection() {
+  console.log("");
+  console.log(chalk6.cyan("  Reference Theme Installation"));
+  console.log(chalk6.gray("  " + "-".repeat(40)));
+  console.log("");
+  console.log(chalk6.gray("  A reference theme provides a complete example to learn from."));
+  console.log(chalk6.gray("  Your custom theme (based on starter) will be your active theme."));
+  console.log("");
+  const theme = await select4({
+    message: "Which reference theme would you like to install?",
+    choices: [
+      {
+        name: "None (skip)",
+        value: null,
+        description: "Only my custom theme, no reference (add later with add:theme)"
+      },
+      {
+        name: "Default (SaaS boilerplate)",
+        value: "default",
+        description: "Full-featured SaaS with dashboard, billing, AI chat"
+      },
+      {
+        name: "Blog",
+        value: "blog",
+        description: "Content management and publishing platform"
+      },
+      {
+        name: "CRM",
+        value: "crm",
+        description: "Customer relationship management"
+      },
+      {
+        name: "Productivity",
+        value: "productivity",
+        description: "Tasks, projects, and calendar management"
+      }
+    ],
+    default: null
+  });
+  return theme;
+}
+
+// src/wizard/prompts/plugins-selection.ts
+import { checkbox as checkbox8 } from "@inquirer/prompts";
+import chalk7 from "chalk";
+var THEME_REQUIRED_PLUGINS = {
+  "default": ["langchain"],
+  "blog": [],
+  "crm": [],
+  "productivity": []
+};
+async function promptPluginsSelection(selectedTheme) {
+  const requiredPlugins = selectedTheme ? THEME_REQUIRED_PLUGINS[selectedTheme] || [] : [];
+  console.log("");
+  console.log(chalk7.cyan("  Plugin Selection"));
+  console.log(chalk7.gray("  " + "-".repeat(40)));
+  if (requiredPlugins.length > 0) {
+    console.log("");
+    console.log(chalk7.gray(`  Note: ${requiredPlugins.join(", ")} will be installed (required by theme)`));
+  }
+  console.log("");
+  const plugins = await checkbox8({
+    message: "Select plugins to install (Enter to skip, Space to select):",
+    choices: [
+      {
+        name: "AI",
+        value: "ai",
+        description: "AI SDK with OpenAI, Anthropic, Ollama support",
+        checked: false
+      },
+      {
+        name: "LangChain",
+        value: "langchain",
+        description: "AI agents, chains, and advanced AI features",
+        checked: requiredPlugins.includes("langchain"),
+        disabled: requiredPlugins.includes("langchain") ? "(required by theme)" : false
+      },
+      {
+        name: "Social Media Publisher",
+        value: "social-media-publisher",
+        description: "Multi-platform social media publishing",
+        checked: false
+      }
+    ]
+  });
+  const allPlugins = [.../* @__PURE__ */ new Set([...requiredPlugins, ...plugins])];
+  return allPlugins;
+}
+function getRequiredPlugins(theme) {
+  if (!theme) return [];
+  return THEME_REQUIRED_PLUGINS[theme] || [];
+}
+
+// src/wizard/prompts/env-config.ts
+import { confirm as confirm3, input as input2 } from "@inquirer/prompts";
+
+// src/wizard/prompts/git-config.ts
+import { confirm as confirm4, input as input3 } from "@inquirer/prompts";
+
+// src/wizard/prompts/index.ts
+async function runAllPrompts() {
+  const projectInfo = await promptProjectInfo();
+  const teamConfig = await promptTeamConfig();
+  const i18nConfig = await promptI18nConfig();
+  const billingConfig = await promptBillingConfig();
+  const featuresConfig = await promptFeaturesConfig();
+  const contentFeaturesConfig = await promptContentFeaturesConfig("interactive", 9);
+  const authConfig = await promptAuthConfig("interactive", 9);
+  const dashboardConfig = await promptDashboardConfig("interactive", 9);
+  const devConfig = await promptDevConfig("interactive", 9);
+  return {
+    ...projectInfo,
+    ...teamConfig,
+    ...i18nConfig,
+    ...billingConfig,
+    ...featuresConfig,
+    ...contentFeaturesConfig,
+    ...authConfig,
+    ...dashboardConfig,
+    ...devConfig
+  };
+}
+async function runQuickPrompts() {
+  const projectInfo = await promptProjectInfo();
+  const teamConfig = await promptTeamConfig();
+  const i18nConfig = await promptI18nConfig();
+  const billingConfig = await promptBillingConfig();
+  const featuresConfig = await promptFeaturesConfig();
+  const contentFeaturesConfig = await promptContentFeaturesConfig("quick", 9);
+  const authConfig = { auth: getDefaultAuthConfig() };
+  const dashboardConfig = { dashboard: getDefaultDashboardConfig() };
+  const devConfig = { dev: getDefaultDevConfig() };
+  return {
+    ...projectInfo,
+    ...teamConfig,
+    ...i18nConfig,
+    ...billingConfig,
+    ...featuresConfig,
+    ...contentFeaturesConfig,
+    ...authConfig,
+    ...dashboardConfig,
+    ...devConfig
+  };
+}
+async function runExpertPrompts() {
+  const projectInfo = await promptProjectInfo();
+  const teamConfig = await promptTeamConfig();
+  const i18nConfig = await promptI18nConfig();
+  const billingConfig = await promptBillingConfig();
+  const featuresConfig = await promptFeaturesConfig();
+  const contentFeaturesConfig = await promptContentFeaturesConfig("expert", 9);
+  const authConfig = await promptAuthConfig("expert", 9);
+  const dashboardConfig = await promptDashboardConfig("expert", 9);
+  const devConfig = await promptDevConfig("expert", 9);
+  return {
+    ...projectInfo,
+    ...teamConfig,
+    ...i18nConfig,
+    ...billingConfig,
+    ...featuresConfig,
+    ...contentFeaturesConfig,
+    ...authConfig,
+    ...dashboardConfig,
+    ...devConfig
+  };
+}
+
+// src/wizard/generators/index.ts
+import fs7 from "fs-extra";
+import path5 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+
+// src/wizard/generators/theme-renamer.ts
+import fs from "fs-extra";
+import path from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path.dirname(__filename2);
+function getTemplatesDir() {
   try {
-    const nextspark = join(projectRoot, ".nextspark");
-    const registriesDir = join(nextspark, "registries");
-    if (!existsSync2(registriesDir) || options.force) {
-      mkdirSync(registriesDir, { recursive: true });
-      spinner.text = "Creating .nextspark/registries/";
-      generateInitialRegistries(registriesDir);
-      spinner.text = "Generated initial registries";
+    const corePkgPath = __require.resolve("@nextsparkjs/core/package.json");
+    return path.join(path.dirname(corePkgPath), "templates");
+  } catch {
+    const possiblePaths = [
+      path.resolve(__dirname2, "../../../../../core/templates"),
+      path.resolve(__dirname2, "../../../../core/templates"),
+      path.resolve(process.cwd(), "node_modules/@nextsparkjs/core/templates")
+    ];
+    for (const p of possiblePaths) {
+      if (fs.existsSync(p)) {
+        return p;
+      }
     }
-    const tsconfigPath = join(projectRoot, "tsconfig.json");
-    if (existsSync2(tsconfigPath)) {
-      spinner.text = "Updating tsconfig.json paths...";
-      const tsconfig = JSON.parse(readFileSync(tsconfigPath, "utf-8"));
-      tsconfig.compilerOptions = tsconfig.compilerOptions || {};
-      tsconfig.compilerOptions.paths = {
-        ...tsconfig.compilerOptions.paths,
-        "@nextsparkjs/registries": ["./.nextspark/registries/index.ts"],
-        "@nextsparkjs/registries/*": ["./.nextspark/registries/*"]
-      };
-      writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2));
+    throw new Error("Could not find @nextsparkjs/core templates directory");
+  }
+}
+function getTargetThemesDir() {
+  return path.resolve(process.cwd(), "contents", "themes");
+}
+async function copyStarterTheme(config) {
+  const templatesDir = getTemplatesDir();
+  const starterThemePath = path.join(templatesDir, "contents", "themes", "starter");
+  const targetThemesDir = getTargetThemesDir();
+  const newThemePath = path.join(targetThemesDir, config.projectSlug);
+  if (!await fs.pathExists(starterThemePath)) {
+    throw new Error(`Starter theme not found at: ${starterThemePath}`);
+  }
+  if (await fs.pathExists(newThemePath)) {
+    throw new Error(`Theme already exists at: ${newThemePath}. Please choose a different name or remove the existing theme.`);
+  }
+  await fs.ensureDir(targetThemesDir);
+  await fs.copy(starterThemePath, newThemePath);
+}
+async function updateThemeConfig(config) {
+  const themeConfigPath = path.join(getTargetThemesDir(), config.projectSlug, "config", "theme.config.ts");
+  if (!await fs.pathExists(themeConfigPath)) {
+    throw new Error(`theme.config.ts not found at: ${themeConfigPath}`);
+  }
+  let content = await fs.readFile(themeConfigPath, "utf-8");
+  content = content.replace(
+    /name:\s*['"]starter['"]/g,
+    `name: '${config.projectSlug}'`
+  );
+  content = content.replace(
+    /displayName:\s*['"]Starter['"]/g,
+    `displayName: '${config.projectName}'`
+  );
+  content = content.replace(
+    /description:\s*['"]Minimal starter theme for NextSpark['"]/g,
+    `description: '${config.projectDescription}'`
+  );
+  content = content.replace(
+    /export const starterThemeConfig/g,
+    `export const ${toCamelCase(config.projectSlug)}ThemeConfig`
+  );
+  content = content.replace(
+    /export default starterThemeConfig/g,
+    `export default ${toCamelCase(config.projectSlug)}ThemeConfig`
+  );
+  await fs.writeFile(themeConfigPath, content, "utf-8");
+}
+async function updateDevConfig(config) {
+  const devConfigPath = path.join(getTargetThemesDir(), config.projectSlug, "config", "dev.config.ts");
+  if (!await fs.pathExists(devConfigPath)) {
+    return;
+  }
+  let content = await fs.readFile(devConfigPath, "utf-8");
+  content = content.replace(/@starter\.dev/g, `@${config.projectSlug}.dev`);
+  content = content.replace(/STARTER THEME/g, `${config.projectName.toUpperCase()}`);
+  content = content.replace(/Starter Theme/g, config.projectName);
+  content = content.replace(/Starter Team/g, `${config.projectName} Team`);
+  await fs.writeFile(devConfigPath, content, "utf-8");
+}
+async function updateAppConfig(config) {
+  const appConfigPath = path.join(getTargetThemesDir(), config.projectSlug, "config", "app.config.ts");
+  if (!await fs.pathExists(appConfigPath)) {
+    throw new Error(`app.config.ts not found at: ${appConfigPath}`);
+  }
+  let content = await fs.readFile(appConfigPath, "utf-8");
+  content = content.replace(
+    /name:\s*['"]Starter['"]/g,
+    `name: '${config.projectName}'`
+  );
+  content = content.replace(
+    /mode:\s*['"]multi-tenant['"]\s*as\s*const/g,
+    `mode: '${config.teamMode}' as const`
+  );
+  const localesArray = config.supportedLocales.map((l) => `'${l}'`).join(", ");
+  content = content.replace(
+    /supportedLocales:\s*\[.*?\]/g,
+    `supportedLocales: [${localesArray}]`
+  );
+  content = content.replace(
+    /defaultLocale:\s*['"]en['"]\s*as\s*const/g,
+    `defaultLocale: '${config.defaultLocale}' as const`
+  );
+  content = content.replace(
+    /label:\s*['"]Starter['"]/g,
+    `label: '${config.projectName}'`
+  );
+  await fs.writeFile(appConfigPath, content, "utf-8");
+}
+async function updateRolesConfig(config) {
+  const appConfigPath = path.join(getTargetThemesDir(), config.projectSlug, "config", "app.config.ts");
+  if (!await fs.pathExists(appConfigPath)) {
+    return;
+  }
+  let content = await fs.readFile(appConfigPath, "utf-8");
+  const rolesArray = config.teamRoles.map((r) => `'${r}'`).join(", ");
+  content = content.replace(
+    /availableTeamRoles:\s*\[.*?\]/g,
+    `availableTeamRoles: [${rolesArray}]`
+  );
+  await fs.writeFile(appConfigPath, content, "utf-8");
+}
+async function updateBillingConfig(config) {
+  const billingConfigPath = path.join(getTargetThemesDir(), config.projectSlug, "config", "billing.config.ts");
+  if (!await fs.pathExists(billingConfigPath)) {
+    return;
+  }
+  let content = await fs.readFile(billingConfigPath, "utf-8");
+  content = content.replace(
+    /currency:\s*['"]usd['"]/g,
+    `currency: '${config.currency}'`
+  );
+  const plansContent = generateBillingPlans(config.billingModel, config.currency);
+  content = content.replace(
+    /plans:\s*\[[\s\S]*?\],\s*\n\s*\/\/ ===+\s*\n\s*\/\/ ACTION MAPPINGS/,
+    `plans: ${plansContent},
+
+  // ===========================================
+  // ACTION MAPPINGS`
+  );
+  await fs.writeFile(billingConfigPath, content, "utf-8");
+}
+function generateBillingPlans(billingModel, currency) {
+  if (billingModel === "free") {
+    return "[]";
+  }
+  const currencySymbol = currency === "eur" ? "\u20AC" : currency === "gbp" ? "\xA3" : "$";
+  if (billingModel === "freemium") {
+    return `[
+    // Free Plan
+    {
+      slug: 'free',
+      name: 'billing.plans.free.name',
+      description: 'billing.plans.free.description',
+      type: 'free',
+      visibility: 'public',
+      price: { monthly: 0, yearly: 0 },
+      trialDays: 0,
+      features: ['basic_analytics'],
+      limits: {
+        team_members: 3,
+        tasks: 50,
+        api_calls: 1000,
+        storage_gb: 1,
+      },
+      stripePriceIdMonthly: null,
+      stripePriceIdYearly: null,
+    },
+    // Pro Plan - ${currencySymbol}29/month
+    {
+      slug: 'pro',
+      name: 'billing.plans.pro.name',
+      description: 'billing.plans.pro.description',
+      type: 'paid',
+      visibility: 'public',
+      price: {
+        monthly: 2900,  // ${currencySymbol}29.00
+        yearly: 29000,  // ${currencySymbol}290.00 (16% savings)
+      },
+      trialDays: 14,
+      features: [
+        'basic_analytics',
+        'advanced_analytics',
+        'api_access',
+        'priority_support',
+      ],
+      limits: {
+        team_members: 15,
+        tasks: 1000,
+        api_calls: 100000,
+        storage_gb: 50,
+      },
+      stripePriceIdMonthly: 'price_pro_monthly',
+      stripePriceIdYearly: 'price_pro_yearly',
+    },
+  ]`;
+  }
+  return `[
+    // Starter Plan - ${currencySymbol}15/month
+    {
+      slug: 'starter',
+      name: 'billing.plans.starter.name',
+      description: 'billing.plans.starter.description',
+      type: 'paid',
+      visibility: 'public',
+      price: {
+        monthly: 1500,  // ${currencySymbol}15.00
+        yearly: 14400,  // ${currencySymbol}144.00 (20% savings)
+      },
+      trialDays: 7,
+      features: [
+        'basic_analytics',
+        'api_access',
+      ],
+      limits: {
+        team_members: 5,
+        tasks: 200,
+        api_calls: 10000,
+        storage_gb: 10,
+      },
+      stripePriceIdMonthly: 'price_starter_monthly',
+      stripePriceIdYearly: 'price_starter_yearly',
+    },
+    // Pro Plan - ${currencySymbol}29/month
+    {
+      slug: 'pro',
+      name: 'billing.plans.pro.name',
+      description: 'billing.plans.pro.description',
+      type: 'paid',
+      visibility: 'public',
+      price: {
+        monthly: 2900,  // ${currencySymbol}29.00
+        yearly: 29000,  // ${currencySymbol}290.00 (16% savings)
+      },
+      trialDays: 14,
+      features: [
+        'basic_analytics',
+        'advanced_analytics',
+        'api_access',
+        'priority_support',
+      ],
+      limits: {
+        team_members: 15,
+        tasks: 1000,
+        api_calls: 100000,
+        storage_gb: 50,
+      },
+      stripePriceIdMonthly: 'price_pro_monthly',
+      stripePriceIdYearly: 'price_pro_yearly',
+    },
+    // Business Plan - ${currencySymbol}79/month
+    {
+      slug: 'business',
+      name: 'billing.plans.business.name',
+      description: 'billing.plans.business.description',
+      type: 'paid',
+      visibility: 'public',
+      price: {
+        monthly: 7900,  // ${currencySymbol}79.00
+        yearly: 79000,  // ${currencySymbol}790.00 (16% savings)
+      },
+      trialDays: 14,
+      features: [
+        'basic_analytics',
+        'advanced_analytics',
+        'api_access',
+        'sso',
+        'audit_logs',
+        'priority_support',
+        'dedicated_support',
+      ],
+      limits: {
+        team_members: 50,
+        tasks: 5000,
+        api_calls: 500000,
+        storage_gb: 200,
+      },
+      stripePriceIdMonthly: 'price_business_monthly',
+      stripePriceIdYearly: 'price_business_yearly',
+    },
+  ]`;
+}
+async function updateMigrations(config) {
+  const migrationsDir = path.join(getTargetThemesDir(), config.projectSlug, "migrations");
+  if (!await fs.pathExists(migrationsDir)) {
+    return;
+  }
+  const files = await fs.readdir(migrationsDir);
+  const sqlFiles = files.filter((f) => f.endsWith(".sql"));
+  for (const file of sqlFiles) {
+    const filePath = path.join(migrationsDir, file);
+    let content = await fs.readFile(filePath, "utf-8");
+    content = content.replace(/@starter\.dev/g, `@${config.projectSlug}.dev`);
+    content = content.replace(/Starter Theme/g, config.projectName);
+    content = content.replace(/starter theme/g, config.projectSlug);
+    await fs.writeFile(filePath, content, "utf-8");
+  }
+}
+function toCamelCase(str) {
+  return str.split("-").map((word, index) => {
+    if (index === 0) {
+      return word.toLowerCase();
     }
-    const envExample = join(projectRoot, ".env.example");
-    if (!existsSync2(envExample)) {
-      const envContent = `# NextSpark Configuration
-DATABASE_URL="postgresql://user:password@localhost:5432/db"
-BETTER_AUTH_SECRET="your-secret-here-min-32-chars"
-BETTER_AUTH_URL=http://localhost:3000
-NEXT_PUBLIC_APP_URL=http://localhost:3000
+    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+  }).join("");
+}
+
+// src/wizard/generators/config-generator.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+function getTargetThemesDir2() {
+  return path2.resolve(process.cwd(), "contents", "themes");
+}
+async function updateAuthConfig(config) {
+  const authConfigPath = path2.join(
+    getTargetThemesDir2(),
+    config.projectSlug,
+    "config",
+    "auth.config.ts"
+  );
+  if (!await fs2.pathExists(authConfigPath)) {
+    return;
+  }
+  let content = await fs2.readFile(authConfigPath, "utf-8");
+  content = content.replace(
+    /(emailPassword:\s*{[^}]*enabled:\s*)(?:true|false)/gs,
+    `$1${config.auth.emailPassword}`
+  );
+  content = content.replace(
+    /(google:\s*{[^}]*enabled:\s*)(?:true|false)/gs,
+    `$1${config.auth.googleOAuth}`
+  );
+  content = content.replace(
+    /(emailVerification:\s*)(?:true|false)/g,
+    `$1${config.auth.emailVerification}`
+  );
+  await fs2.writeFile(authConfigPath, content, "utf-8");
+}
+async function updateDashboardUIConfig(config) {
+  const dashboardConfigPath = path2.join(
+    getTargetThemesDir2(),
+    config.projectSlug,
+    "config",
+    "dashboard.config.ts"
+  );
+  if (!await fs2.pathExists(dashboardConfigPath)) {
+    return;
+  }
+  let content = await fs2.readFile(dashboardConfigPath, "utf-8");
+  content = content.replace(
+    /(search:\s*{[^}]*enabled:\s*)(?:true|false)/gs,
+    `$1${config.dashboard.search}`
+  );
+  content = content.replace(
+    /(notifications:\s*{[^}]*enabled:\s*)(?:true|false)/gs,
+    `$1${config.dashboard.notifications}`
+  );
+  content = content.replace(
+    /(themeToggle:\s*{[^}]*enabled:\s*)(?:true|false)/gs,
+    `$1${config.dashboard.themeToggle}`
+  );
+  content = content.replace(
+    /(support:\s*{[^}]*enabled:\s*)(?:true|false)/gs,
+    `$1${config.dashboard.support}`
+  );
+  content = content.replace(
+    /(quickCreate:\s*{[^}]*enabled:\s*)(?:true|false)/gs,
+    `$1${config.dashboard.quickCreate}`
+  );
+  content = content.replace(
+    /(adminAccess:\s*{[^}]*enabled:\s*)(?:true|false)/gs,
+    `$1${config.dashboard.superadminAccess}`
+  );
+  content = content.replace(
+    /(devtoolsAccess:\s*{[^}]*enabled:\s*)(?:true|false)/gs,
+    `$1${config.dashboard.devtoolsAccess}`
+  );
+  content = content.replace(
+    /(defaultCollapsed:\s*)(?:true|false)/g,
+    `$1${config.dashboard.sidebarCollapsed}`
+  );
+  await fs2.writeFile(dashboardConfigPath, content, "utf-8");
+}
+async function updateDevToolsConfig(config) {
+  const devConfigPath = path2.join(
+    getTargetThemesDir2(),
+    config.projectSlug,
+    "config",
+    "dev.config.ts"
+  );
+  if (!await fs2.pathExists(devConfigPath)) {
+    return;
+  }
+  let content = await fs2.readFile(devConfigPath, "utf-8");
+  content = content.replace(
+    /(devKeyring:\s*{[^}]*enabled:\s*)(?:true|false)/gs,
+    `$1${config.dev.devKeyring}`
+  );
+  content = content.replace(
+    /(debugMode:\s*)(?:true|false)/g,
+    `$1${config.dev.debugMode}`
+  );
+  await fs2.writeFile(devConfigPath, content, "utf-8");
+}
+async function updatePermissionsConfig(config) {
+  const permissionsConfigPath = path2.join(
+    getTargetThemesDir2(),
+    config.projectSlug,
+    "config",
+    "permissions.config.ts"
+  );
+  if (!await fs2.pathExists(permissionsConfigPath)) {
+    return;
+  }
+  let content = await fs2.readFile(permissionsConfigPath, "utf-8");
+  const availableRoles = config.teamRoles;
+  const roleArrayPattern = /roles:\s*\[(.*?)\]/g;
+  content = content.replace(roleArrayPattern, (match, rolesStr) => {
+    const currentRoles = rolesStr.split(",").map((r) => r.trim().replace(/['"]/g, "")).filter((r) => r.length > 0);
+    const filteredRoles = currentRoles.filter((r) => availableRoles.includes(r));
+    if (filteredRoles.length === 0) {
+      filteredRoles.push("owner");
+    }
+    return `roles: [${filteredRoles.map((r) => `'${r}'`).join(", ")}]`;
+  });
+  await fs2.writeFile(permissionsConfigPath, content, "utf-8");
+}
+async function updateDashboardConfig(config) {
+  const dashboardConfigPath = path2.join(
+    getTargetThemesDir2(),
+    config.projectSlug,
+    "config",
+    "dashboard.config.ts"
+  );
+  if (!await fs2.pathExists(dashboardConfigPath)) {
+    return;
+  }
+  let content = await fs2.readFile(dashboardConfigPath, "utf-8");
+  if (!config.features.analytics) {
+    content = content.replace(
+      /(id:\s*['"]analytics['"].*?enabled:\s*)true/gs,
+      "$1false"
+    );
+  }
+  if (!config.features.billing) {
+    content = content.replace(
+      /(id:\s*['"]billing['"].*?enabled:\s*)true/gs,
+      "$1false"
+    );
+  }
+  if (config.teamMode === "single-user") {
+    content = content.replace(
+      /(id:\s*['"]team['"].*?enabled:\s*)true/gs,
+      "$1false"
+    );
+    content = content.replace(
+      /(id:\s*['"]members['"].*?enabled:\s*)true/gs,
+      "$1false"
+    );
+  }
+  await fs2.writeFile(dashboardConfigPath, content, "utf-8");
+}
+async function generateEnvExample(config) {
+  const envExamplePath = path2.resolve(process.cwd(), ".env.example");
+  let oauthSection = "";
+  if (config.auth.googleOAuth) {
+    oauthSection = `# =============================================================================
+# OAUTH PROVIDERS
+# =============================================================================
+GOOGLE_CLIENT_ID="your-google-client-id"
+GOOGLE_CLIENT_SECRET="your-google-client-secret"
 `;
-      writeFileSync(envExample, envContent);
-      spinner.text = "Created .env.example";
+  } else {
+    oauthSection = `# =============================================================================
+# OAUTH (Optional - enable in auth.config.ts)
+# =============================================================================
+# GOOGLE_CLIENT_ID=""
+# GOOGLE_CLIENT_SECRET=""
+`;
+  }
+  const envContent = `# NextSpark Environment Configuration
+# Generated for: ${config.projectName}
+
+# =============================================================================
+# DATABASE
+# =============================================================================
+DATABASE_URL="postgresql://user:password@localhost:5432/database"
+
+# =============================================================================
+# AUTHENTICATION (better-auth)
+# =============================================================================
+# Generate with: openssl rand -base64 32
+BETTER_AUTH_SECRET="your-secret-key-here"
+
+# =============================================================================
+# THEME
+# =============================================================================
+NEXT_PUBLIC_ACTIVE_THEME="${config.projectSlug}"
+
+# =============================================================================
+# APPLICATION
+# =============================================================================
+NEXT_PUBLIC_APP_URL="http://localhost:3000"
+NODE_ENV="development"
+
+${config.features.billing ? `# =============================================================================
+# STRIPE (Billing)
+# =============================================================================
+STRIPE_SECRET_KEY="sk_test_..."
+STRIPE_WEBHOOK_SECRET="whsec_..."
+NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY="pk_test_..."
+` : "# Billing is disabled - no Stripe configuration needed"}
+
+# =============================================================================
+# EMAIL (Resend)
+# =============================================================================
+RESEND_API_KEY="re_..."
+
+${oauthSection}`;
+  if (!await fs2.pathExists(envExamplePath)) {
+    await fs2.writeFile(envExamplePath, envContent, "utf-8");
+  }
+}
+async function updateReadme(config) {
+  const readmePath = path2.join(getTargetThemesDir2(), config.projectSlug, "README.md");
+  if (!await fs2.pathExists(readmePath)) {
+    return;
+  }
+  let content = await fs2.readFile(readmePath, "utf-8");
+  content = content.replace(/# Starter Theme/g, `# ${config.projectName}`);
+  content = content.replace(
+    /Minimal starter theme for NextSpark/g,
+    config.projectDescription
+  );
+  await fs2.writeFile(readmePath, content, "utf-8");
+}
+
+// src/wizard/generators/messages-generator.ts
+import fs3 from "fs-extra";
+import path3 from "path";
+function getTargetThemesDir3() {
+  return path3.resolve(process.cwd(), "contents", "themes");
+}
+async function removeUnusedLanguages(config) {
+  const messagesDir = path3.join(getTargetThemesDir3(), config.projectSlug, "messages");
+  if (!await fs3.pathExists(messagesDir)) {
+    return;
+  }
+  const folders = await fs3.readdir(messagesDir);
+  const languageFolders = folders.filter((f) => {
+    const folderPath = path3.join(messagesDir, f);
+    return fs3.statSync(folderPath).isDirectory() && Object.keys(AVAILABLE_LOCALES).includes(f);
+  });
+  for (const folder of languageFolders) {
+    if (!config.supportedLocales.includes(folder)) {
+      await fs3.remove(path3.join(messagesDir, folder));
     }
-    spinner.succeed("NextSpark initialized successfully!");
-    console.log(chalk5.blue("\nNext steps:"));
-    console.log("  1. Copy .env.example to .env and configure");
-    console.log("  2. Run: nextspark generate  (to populate registries)");
-    console.log("  3. Run: nextspark dev");
+  }
+}
+async function removeUnusedEntityMessages(config) {
+  const entitiesDir = path3.join(getTargetThemesDir3(), config.projectSlug, "entities");
+  if (!await fs3.pathExists(entitiesDir)) {
+    return;
+  }
+  const entityFolders = await fs3.readdir(entitiesDir);
+  for (const entity of entityFolders) {
+    const messagesDir = path3.join(entitiesDir, entity, "messages");
+    if (!await fs3.pathExists(messagesDir)) {
+      continue;
+    }
+    const files = await fs3.readdir(messagesDir);
+    for (const file of files) {
+      const locale = path3.basename(file, ".json");
+      if (Object.keys(AVAILABLE_LOCALES).includes(locale) && !config.supportedLocales.includes(locale)) {
+        await fs3.remove(path3.join(messagesDir, file));
+      }
+    }
+  }
+}
+async function ensureLanguageFolders(config) {
+  const messagesDir = path3.join(getTargetThemesDir3(), config.projectSlug, "messages");
+  if (!await fs3.pathExists(messagesDir)) {
+    return;
+  }
+  const defaultLocaleDir = path3.join(messagesDir, config.defaultLocale);
+  if (!await fs3.pathExists(defaultLocaleDir)) {
+    const enDir = path3.join(messagesDir, "en");
+    if (await fs3.pathExists(enDir)) {
+      await fs3.copy(enDir, defaultLocaleDir);
+    }
+  }
+  for (const locale of config.supportedLocales) {
+    const localeDir = path3.join(messagesDir, locale);
+    if (!await fs3.pathExists(localeDir) && await fs3.pathExists(defaultLocaleDir)) {
+      await fs3.copy(defaultLocaleDir, localeDir);
+    }
+  }
+}
+async function updateMessageFiles(config) {
+  const messagesDir = path3.join(getTargetThemesDir3(), config.projectSlug, "messages");
+  if (!await fs3.pathExists(messagesDir)) {
+    return;
+  }
+  for (const locale of config.supportedLocales) {
+    const commonPath = path3.join(messagesDir, locale, "common.json");
+    if (await fs3.pathExists(commonPath)) {
+      try {
+        const content = await fs3.readJson(commonPath);
+        if (content.app) {
+          content.app.name = config.projectName;
+          if (content.app.description) {
+            content.app.description = config.projectDescription;
+          }
+        }
+        await fs3.writeJson(commonPath, content, { spaces: 2 });
+      } catch {
+      }
+    }
+  }
+}
+async function processI18n(config) {
+  await removeUnusedLanguages(config);
+  await removeUnusedEntityMessages(config);
+  await ensureLanguageFolders(config);
+  await updateMessageFiles(config);
+}
+
+// src/wizard/generators/content-features-generator.ts
+import fs4 from "fs-extra";
+import path4 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname3 = path4.dirname(__filename3);
+function getTemplatesDir2() {
+  try {
+    const corePkgPath = __require.resolve("@nextsparkjs/core/package.json");
+    return path4.join(path4.dirname(corePkgPath), "templates");
+  } catch {
+    const possiblePaths = [
+      path4.resolve(__dirname3, "../../../../../core/templates"),
+      path4.resolve(__dirname3, "../../../../core/templates"),
+      path4.resolve(process.cwd(), "node_modules/@nextsparkjs/core/templates")
+    ];
+    for (const p of possiblePaths) {
+      if (fs4.existsSync(p)) {
+        return p;
+      }
+    }
+    throw new Error("Could not find @nextsparkjs/core templates directory");
+  }
+}
+function getFeaturesDir() {
+  return path4.join(getTemplatesDir2(), "features");
+}
+function getTargetThemeDir(projectSlug) {
+  return path4.resolve(process.cwd(), "contents", "themes", projectSlug);
+}
+async function copyPagesFeature(config) {
+  const featuresDir = getFeaturesDir();
+  const targetThemeDir = getTargetThemeDir(config.projectSlug);
+  const sourcePagesEntity = path4.join(featuresDir, "pages", "entities", "pages");
+  const targetEntitiesDir = path4.join(targetThemeDir, "entities", "pages");
+  if (!await fs4.pathExists(sourcePagesEntity)) {
+    console.warn(`Warning: Pages entity not found at: ${sourcePagesEntity}`);
+    return;
+  }
+  await fs4.copy(sourcePagesEntity, targetEntitiesDir);
+}
+async function copyBlogFeature(config) {
+  const featuresDir = getFeaturesDir();
+  const targetThemeDir = getTargetThemeDir(config.projectSlug);
+  const sourcePostsEntity = path4.join(featuresDir, "blog", "entities", "posts");
+  const targetPostsEntity = path4.join(targetThemeDir, "entities", "posts");
+  if (await fs4.pathExists(sourcePostsEntity)) {
+    await fs4.copy(sourcePostsEntity, targetPostsEntity);
+  } else {
+    console.warn(`Warning: Posts entity not found at: ${sourcePostsEntity}`);
+  }
+  const sourcePostContentBlock = path4.join(featuresDir, "blog", "blocks", "post-content");
+  const targetPostContentBlock = path4.join(targetThemeDir, "blocks", "post-content");
+  if (await fs4.pathExists(sourcePostContentBlock)) {
+    await fs4.copy(sourcePostContentBlock, targetPostContentBlock);
+  } else {
+    console.warn(`Warning: Post-content block not found at: ${sourcePostContentBlock}`);
+  }
+}
+async function copyContentFeatures(config) {
+  if (!config.contentFeatures.pages && !config.contentFeatures.blog) {
+    return;
+  }
+  if (config.contentFeatures.pages) {
+    await copyPagesFeature(config);
+  }
+  if (config.contentFeatures.blog) {
+    await copyBlogFeature(config);
+  }
+}
+
+// src/wizard/generators/theme-plugins-installer.ts
+import { existsSync as existsSync6, cpSync, mkdirSync, readFileSync as readFileSync5, writeFileSync } from "fs";
+import { join as join5, resolve as resolve2 } from "path";
+import chalk9 from "chalk";
+import ora6 from "ora";
+
+// src/commands/add-theme.ts
+import chalk8 from "chalk";
+import ora5 from "ora";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
+async function addTheme(packageSpec, options = {}) {
+  const spinner = ora5(`Adding theme ${packageSpec}`).start();
+  let cleanup = null;
+  try {
+    const contentsDir = join4(process.cwd(), "contents");
+    if (!existsSync5(contentsDir)) {
+      spinner.fail('contents/ directory not found. Run "nextspark init" first.');
+      return;
+    }
+    spinner.text = "Downloading package...";
+    const { packageJson, extractedPath, cleanup: cleanupFn } = await fetchPackage(
+      packageSpec,
+      options.version
+    );
+    cleanup = cleanupFn;
+    spinner.text = "Validating theme...";
+    const validation = validateTheme(packageJson, extractedPath);
+    if (!validation.valid) {
+      spinner.fail("Invalid theme");
+      validation.errors.forEach((e) => console.log(chalk8.red(`  \u2717 ${e}`)));
+      return;
+    }
+    if (validation.warnings.length > 0) {
+      validation.warnings.forEach((w) => console.log(chalk8.yellow(`  \u26A0 ${w}`)));
+    }
+    if (packageJson.requiredPlugins?.length && !options.skipPostinstall) {
+      spinner.stop();
+      console.log(chalk8.blue("\n  Installing required plugins..."));
+      const installingPlugins = /* @__PURE__ */ new Set();
+      for (const plugin of packageJson.requiredPlugins) {
+        if (!checkPluginExists(plugin)) {
+          await addPlugin(plugin, { installingPlugins });
+        }
+      }
+    }
+    spinner.text = "Installing theme...";
+    spinner.stop();
+    const result = await installTheme(extractedPath, packageJson, options);
+    if (!options.skipPostinstall) {
+      const coreVersion = getCoreVersion();
+      const context = {
+        activeTheme: result.name,
+        // The newly installed theme
+        projectRoot: process.cwd(),
+        themeName: result.name,
+        coreVersion,
+        timestamp: Date.now(),
+        installingPlugins: /* @__PURE__ */ new Set()
+      };
+      await runPostinstall(packageJson, result.installedPath, context);
+    }
+    console.log(chalk8.green(`
+  \u2713 Theme ${result.name} installed successfully!`));
+    console.log(chalk8.gray(`    Location: contents/themes/${result.name}/`));
+    console.log(chalk8.gray(`    Set NEXT_PUBLIC_ACTIVE_THEME=${result.name} to activate`));
+  } catch (error) {
+    spinner.fail("Failed to add theme");
+    if (error instanceof Error) {
+      console.log(chalk8.red(`  ${error.message}`));
+    }
+    throw error;
+  } finally {
+    if (cleanup) cleanup();
+  }
+}
+function checkPluginExists(pluginName) {
+  const name = pluginName.replace(/^@[^/]+\//, "").replace(/^nextspark-plugin-/, "").replace(/^plugin-/, "");
+  return existsSync5(join4(process.cwd(), "contents", "plugins", name));
+}
+function getCoreVersion() {
+  const pkgPath = join4(process.cwd(), "node_modules", "@nextsparkjs", "core", "package.json");
+  if (existsSync5(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+      return pkg.version || "0.0.0";
+    } catch {
+      return "0.0.0";
+    }
+  }
+  return "0.0.0";
+}
+function addThemeCommand(packageSpec, options) {
+  return addTheme(packageSpec, {
+    force: options.force,
+    skipDeps: options.noDeps,
+    dryRun: options.dryRun,
+    skipPostinstall: options.skipPostinstall,
+    version: options.version
+  });
+}
+
+// src/wizard/generators/theme-plugins-installer.ts
+var THEME_PACKAGES = {
+  "default": "@nextsparkjs/theme-default",
+  "blog": "@nextsparkjs/theme-blog",
+  "crm": "@nextsparkjs/theme-crm",
+  "productivity": "@nextsparkjs/theme-productivity"
+};
+var PLUGIN_PACKAGES = {
+  "ai": "@nextsparkjs/plugin-ai",
+  "langchain": "@nextsparkjs/plugin-langchain",
+  "social-media-publisher": "@nextsparkjs/plugin-social-media-publisher"
+};
+var THEME_REQUIRED_PLUGINS2 = {
+  "default": ["langchain"],
+  "blog": [],
+  "crm": [],
+  "productivity": []
+};
+function isMonorepoMode2() {
+  const possiblePaths = [
+    join5(process.cwd(), "pnpm-workspace.yaml"),
+    join5(process.cwd(), "..", "pnpm-workspace.yaml"),
+    join5(process.cwd(), "..", "..", "pnpm-workspace.yaml")
+  ];
+  return possiblePaths.some((p) => existsSync6(p));
+}
+function getMonorepoRoot() {
+  const possibleRoots = [
+    process.cwd(),
+    join5(process.cwd(), ".."),
+    join5(process.cwd(), "..", "..")
+  ];
+  for (const root of possibleRoots) {
+    if (existsSync6(join5(root, "pnpm-workspace.yaml"))) {
+      return resolve2(root);
+    }
+  }
+  return null;
+}
+function getLocalPackageDir(type, name) {
+  const monorepoRoot = getMonorepoRoot();
+  if (!monorepoRoot) return null;
+  const baseDir = type === "theme" ? "themes" : "plugins";
+  const packageDir = join5(monorepoRoot, baseDir, name);
+  if (existsSync6(packageDir) && existsSync6(join5(packageDir, "package.json"))) {
+    return packageDir;
+  }
+  return null;
+}
+async function copyLocalTheme(name, sourceDir) {
+  const targetDir = join5(process.cwd(), "contents", "themes", name);
+  const themesDir = join5(process.cwd(), "contents", "themes");
+  if (!existsSync6(themesDir)) {
+    mkdirSync(themesDir, { recursive: true });
+  }
+  if (existsSync6(targetDir)) {
+    console.log(chalk9.gray(`    Theme ${name} already exists, skipping...`));
+    return true;
+  }
+  cpSync(sourceDir, targetDir, { recursive: true });
+  await updateTsConfigPaths(name, "theme");
+  return true;
+}
+async function copyLocalPlugin(name, sourceDir) {
+  const targetDir = join5(process.cwd(), "contents", "plugins", name);
+  const pluginsDir = join5(process.cwd(), "contents", "plugins");
+  if (!existsSync6(pluginsDir)) {
+    mkdirSync(pluginsDir, { recursive: true });
+  }
+  if (existsSync6(targetDir)) {
+    console.log(chalk9.gray(`    Plugin ${name} already exists, skipping...`));
+    return true;
+  }
+  cpSync(sourceDir, targetDir, { recursive: true });
+  await updateTsConfigPaths(name, "plugin");
+  return true;
+}
+async function updateTsConfigPaths(name, type) {
+  const tsconfigPath = join5(process.cwd(), "tsconfig.json");
+  if (!existsSync6(tsconfigPath)) {
+    return;
+  }
+  try {
+    const content = readFileSync5(tsconfigPath, "utf-8");
+    const tsconfig = JSON.parse(content);
+    if (!tsconfig.compilerOptions) {
+      tsconfig.compilerOptions = {};
+    }
+    if (!tsconfig.compilerOptions.paths) {
+      tsconfig.compilerOptions.paths = {};
+    }
+    const basePath = type === "theme" ? `contents/themes/${name}` : `contents/plugins/${name}`;
+    const aliasKey = type === "theme" ? `@themes/${name}/*` : `@plugins/${name}/*`;
+    tsconfig.compilerOptions.paths[aliasKey] = [`./${basePath}/*`];
+    writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2));
+  } catch {
+  }
+}
+async function installThemeViaCli(packageSpec) {
+  try {
+    await addTheme(packageSpec, {});
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installPluginViaCli(packageSpec) {
+  try {
+    await addPlugin(packageSpec, {});
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installTheme2(theme) {
+  if (!theme) {
+    return true;
+  }
+  const spinner = ora6({
+    text: `Installing reference theme: ${theme}...`,
+    prefixText: "  "
+  }).start();
+  try {
+    const targetDir = join5(process.cwd(), "contents", "themes", theme);
+    if (existsSync6(targetDir)) {
+      spinner.info(chalk9.gray(`Reference theme ${theme} already exists`));
+      return true;
+    }
+    if (isMonorepoMode2()) {
+      const localDir = getLocalPackageDir("theme", theme);
+      if (localDir) {
+        spinner.text = `Copying reference theme from local: ${theme}...`;
+        const success2 = await copyLocalTheme(theme, localDir);
+        if (success2) {
+          const requiredPlugins = THEME_REQUIRED_PLUGINS2[theme] || [];
+          for (const plugin of requiredPlugins) {
+            const pluginDir = getLocalPackageDir("plugin", plugin);
+            if (pluginDir) {
+              await copyLocalPlugin(plugin, pluginDir);
+            }
+          }
+          spinner.succeed(chalk9.green(`Reference theme ${theme} installed!`));
+          return true;
+        }
+      }
+    }
+    spinner.text = `Installing reference theme: ${theme}...`;
+    const packageSpec = THEME_PACKAGES[theme];
+    const success = await installThemeViaCli(packageSpec);
+    if (success) {
+      spinner.succeed(chalk9.green(`Reference theme ${theme} installed!`));
+      return true;
+    } else {
+      spinner.fail(chalk9.red(`Failed to install theme: ${theme}`));
+      console.log(chalk9.gray("  Hint: Make sure @nextsparkjs/cli is installed or the theme package is published"));
+      return false;
+    }
+  } catch (error) {
+    spinner.fail(chalk9.red(`Failed to install theme: ${theme}`));
+    if (error instanceof Error) {
+      console.log(chalk9.red(`  Error: ${error.message}`));
+    }
+    return false;
+  }
+}
+async function installPlugins(plugins) {
+  if (plugins.length === 0) {
+    return true;
+  }
+  let allSuccess = true;
+  for (const plugin of plugins) {
+    const spinner = ora6({
+      text: `Installing plugin: ${plugin}...`,
+      prefixText: "  "
+    }).start();
+    try {
+      const pluginDir = join5(process.cwd(), "contents", "plugins", plugin);
+      if (existsSync6(pluginDir)) {
+        spinner.info(chalk9.gray(`Plugin ${plugin} already installed`));
+        continue;
+      }
+      if (isMonorepoMode2()) {
+        const localDir = getLocalPackageDir("plugin", plugin);
+        if (localDir) {
+          spinner.text = `Copying plugin from local: ${plugin}...`;
+          const success2 = await copyLocalPlugin(plugin, localDir);
+          if (success2) {
+            spinner.succeed(chalk9.green(`Plugin ${plugin} installed!`));
+            continue;
+          }
+        }
+      }
+      spinner.text = `Installing plugin: ${plugin}...`;
+      const packageSpec = PLUGIN_PACKAGES[plugin];
+      const success = await installPluginViaCli(packageSpec);
+      if (success) {
+        spinner.succeed(chalk9.green(`Plugin ${plugin} installed!`));
+      } else {
+        spinner.fail(chalk9.red(`Failed to install plugin: ${plugin}`));
+        console.log(chalk9.gray("  Hint: Make sure @nextsparkjs/cli is installed or the plugin package is published"));
+        allSuccess = false;
+      }
+    } catch (error) {
+      spinner.fail(chalk9.red(`Failed to install plugin: ${plugin}`));
+      if (error instanceof Error) {
+        console.log(chalk9.red(`  Error: ${error.message}`));
+      }
+      allSuccess = false;
+    }
+  }
+  return allSuccess;
+}
+async function installThemeAndPlugins(theme, plugins) {
+  if (!theme && plugins.length === 0) {
+    return true;
+  }
+  console.log("");
+  console.log(chalk9.cyan("  Installing Reference Theme & Plugins"));
+  console.log(chalk9.gray("  " + "-".repeat(40)));
+  console.log("");
+  const themeSuccess = await installTheme2(theme);
+  if (!themeSuccess && theme) {
+    console.log(chalk9.yellow("  Warning: Theme installation failed, continuing with plugins..."));
+  }
+  const pluginsSuccess = await installPlugins(plugins);
+  console.log("");
+  if (themeSuccess && pluginsSuccess) {
+    console.log(chalk9.green("  All installations completed successfully!"));
+  } else {
+    console.log(chalk9.yellow("  Some installations had issues. Check the messages above."));
+  }
+  return themeSuccess && pluginsSuccess;
+}
+
+// src/wizard/generators/env-setup.ts
+import fs5 from "fs-extra";
+
+// src/wizard/generators/git-init.ts
+import fs6 from "fs-extra";
+
+// src/wizard/generators/index.ts
+var __filename4 = fileURLToPath4(import.meta.url);
+var __dirname4 = path5.dirname(__filename4);
+function getTemplatesDir3() {
+  try {
+    const corePkgPath = __require.resolve("@nextsparkjs/core/package.json");
+    return path5.join(path5.dirname(corePkgPath), "templates");
+  } catch {
+    const possiblePaths = [
+      path5.resolve(__dirname4, "../../../../../core/templates"),
+      path5.resolve(__dirname4, "../../../../core/templates"),
+      path5.resolve(process.cwd(), "node_modules/@nextsparkjs/core/templates")
+    ];
+    for (const p of possiblePaths) {
+      if (fs7.existsSync(p)) {
+        return p;
+      }
+    }
+    throw new Error("Could not find @nextsparkjs/core templates directory");
+  }
+}
+async function copyProjectFiles() {
+  const templatesDir = getTemplatesDir3();
+  const projectDir = process.cwd();
+  const itemsToCopy = [
+    { src: "app", dest: "app", force: true },
+    { src: "public", dest: "public", force: true },
+    { src: "next.config.mjs", dest: "next.config.mjs", force: true },
+    { src: "tsconfig.json", dest: "tsconfig.json", force: true },
+    { src: "postcss.config.mjs", dest: "postcss.config.mjs", force: true },
+    { src: "i18n.ts", dest: "i18n.ts", force: true },
+    { src: "npmrc", dest: ".npmrc", force: false },
+    { src: "tsconfig.cypress.json", dest: "tsconfig.cypress.json", force: false },
+    { src: "cypress.d.ts", dest: "cypress.d.ts", force: false },
+    { src: "eslint.config.mjs", dest: "eslint.config.mjs", force: false }
+  ];
+  for (const item of itemsToCopy) {
+    const srcPath = path5.join(templatesDir, item.src);
+    const destPath = path5.join(projectDir, item.dest);
+    if (await fs7.pathExists(srcPath)) {
+      if (item.force || !await fs7.pathExists(destPath)) {
+        await fs7.copy(srcPath, destPath);
+      }
+    }
+  }
+}
+async function updatePackageJson(config) {
+  const packageJsonPath = path5.resolve(process.cwd(), "package.json");
+  let packageJson;
+  if (!await fs7.pathExists(packageJsonPath)) {
+    packageJson = {
+      name: config.projectSlug,
+      version: "0.1.0",
+      private: true,
+      scripts: {},
+      dependencies: {},
+      devDependencies: {}
+    };
+  } else {
+    packageJson = await fs7.readJson(packageJsonPath);
+  }
+  packageJson.scripts = packageJson.scripts || {};
+  const scriptsToAdd = {
+    "dev": "nextspark dev",
+    "build": "nextspark build",
+    "start": "next start",
+    "lint": "next lint",
+    "build:registries": "nextspark registry:build",
+    "db:migrate": "nextspark db:migrate",
+    "db:seed": "nextspark db:seed",
+    "test:theme": `jest --config contents/themes/${config.projectSlug}/tests/jest/jest.config.ts`,
+    "cy:open": `cypress open --config-file contents/themes/${config.projectSlug}/tests/cypress.config.ts`,
+    "cy:run": `cypress run --config-file contents/themes/${config.projectSlug}/tests/cypress.config.ts`,
+    "allure:generate": `allure generate contents/themes/${config.projectSlug}/tests/cypress/allure-results --clean -o contents/themes/${config.projectSlug}/tests/cypress/allure-report`,
+    "allure:open": `allure open contents/themes/${config.projectSlug}/tests/cypress/allure-report`
+  };
+  for (const [name, command] of Object.entries(scriptsToAdd)) {
+    if (!packageJson.scripts[name]) {
+      packageJson.scripts[name] = command;
+    }
+  }
+  packageJson.dependencies = packageJson.dependencies || {};
+  const depsToAdd = {
+    // NextSpark
+    "@nextsparkjs/core": "^0.1.0-beta.4",
+    "@nextsparkjs/cli": "^0.1.0-beta.4",
+    // Next.js + React
+    "next": "^15.1.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    // Auth
+    "better-auth": "^1.4.0",
+    // i18n
+    "next-intl": "^4.0.2",
+    // Database
+    "drizzle-orm": "^0.41.0",
+    "postgres": "^3.4.5",
+    // State & Data
+    "@tanstack/react-query": "^5.64.2",
+    // Forms & Validation
+    "zod": "^4.1.5",
+    "react-hook-form": "^7.54.2",
+    "@hookform/resolvers": "^5.0.1",
+    // UI
+    "tailwindcss": "^4.0.0",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "tailwind-merge": "^2.6.0",
+    "lucide-react": "^0.469.0",
+    "sonner": "^1.7.4",
+    // Utilities
+    "date-fns": "^4.1.0",
+    "nanoid": "^5.0.9",
+    "slugify": "^1.6.6"
+  };
+  for (const [name, version] of Object.entries(depsToAdd)) {
+    if (!packageJson.dependencies[name]) {
+      packageJson.dependencies[name] = version;
+    }
+  }
+  packageJson.devDependencies = packageJson.devDependencies || {};
+  const devDepsToAdd = {
+    // TypeScript
+    "typescript": "^5.7.3",
+    "@types/node": "^22.10.7",
+    "@types/react": "^19.0.7",
+    "@types/react-dom": "^19.0.3",
+    // Tailwind
+    "@tailwindcss/postcss": "^4.0.0",
+    // ESLint
+    "eslint": "^9.18.0",
+    "eslint-config-next": "^15.1.0",
+    "@eslint/eslintrc": "^3.2.0",
+    // Database
+    "drizzle-kit": "^0.31.4",
+    // Jest
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2",
+    "@types/jest": "^29.5.14",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.3.0",
+    "jest-environment-jsdom": "^29.7.0",
+    // Cypress
+    "cypress": "^14.0.0",
+    "@testing-library/cypress": "^10.0.2",
+    "@cypress/webpack-preprocessor": "^6.0.2",
+    "@cypress/grep": "^4.1.0",
+    "ts-loader": "^9.5.1",
+    "webpack": "^5.97.0",
+    "allure-cypress": "^3.0.0",
+    "allure-commandline": "^2.27.0"
+  };
+  for (const [name, version] of Object.entries(devDepsToAdd)) {
+    if (!packageJson.devDependencies[name]) {
+      packageJson.devDependencies[name] = version;
+    }
+  }
+  await fs7.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+}
+async function updateGitignore(config) {
+  const gitignorePath = path5.resolve(process.cwd(), ".gitignore");
+  const entriesToAdd = `
+# NextSpark
+.nextspark/
+
+# Cypress (theme-based)
+contents/themes/*/tests/cypress/videos
+contents/themes/*/tests/cypress/screenshots
+contents/themes/*/tests/cypress/allure-results
+contents/themes/*/tests/cypress/allure-report
+
+# Jest (theme-based)
+contents/themes/*/tests/jest/coverage
+
+# Environment
+.env
+.env.local
+`;
+  if (await fs7.pathExists(gitignorePath)) {
+    const currentContent = await fs7.readFile(gitignorePath, "utf-8");
+    if (!currentContent.includes(".nextspark/")) {
+      await fs7.appendFile(gitignorePath, entriesToAdd);
+    }
+  } else {
+    await fs7.writeFile(gitignorePath, entriesToAdd.trim());
+  }
+}
+async function generateProject(config) {
+  await copyProjectFiles();
+  await copyStarterTheme(config);
+  await copyContentFeatures(config);
+  await updateThemeConfig(config);
+  await updateDevConfig(config);
+  await updateAppConfig(config);
+  await updateBillingConfig(config);
+  await updateRolesConfig(config);
+  await updateMigrations(config);
+  await updatePermissionsConfig(config);
+  await updateDashboardConfig(config);
+  await updateAuthConfig(config);
+  await updateDashboardUIConfig(config);
+  await updateDevToolsConfig(config);
+  await processI18n(config);
+  await updatePackageJson(config);
+  await updateGitignore(config);
+  await generateEnvExample(config);
+  await updateReadme(config);
+}
+
+// src/wizard/presets.ts
+var SAAS_PRESET = {
+  teamMode: "multi-tenant",
+  teamRoles: ["owner", "admin", "member", "viewer"],
+  defaultLocale: "en",
+  supportedLocales: ["en"],
+  billingModel: "freemium",
+  currency: "usd",
+  features: {
+    analytics: true,
+    teams: true,
+    billing: true,
+    api: true,
+    docs: false
+  },
+  contentFeatures: {
+    pages: false,
+    blog: false
+  },
+  auth: {
+    emailPassword: true,
+    googleOAuth: true,
+    emailVerification: true
+  },
+  dashboard: {
+    search: true,
+    notifications: true,
+    themeToggle: true,
+    support: true,
+    quickCreate: true,
+    superadminAccess: true,
+    devtoolsAccess: true,
+    sidebarCollapsed: false
+  },
+  dev: {
+    devKeyring: true,
+    debugMode: false
+  }
+};
+var BLOG_PRESET = {
+  teamMode: "single-user",
+  teamRoles: ["owner"],
+  defaultLocale: "en",
+  supportedLocales: ["en"],
+  billingModel: "free",
+  currency: "usd",
+  features: {
+    analytics: true,
+    teams: false,
+    billing: false,
+    api: false,
+    docs: true
+  },
+  contentFeatures: {
+    pages: false,
+    blog: true
+  },
+  auth: {
+    emailPassword: true,
+    googleOAuth: false,
+    emailVerification: false
+  },
+  dashboard: {
+    search: false,
+    notifications: false,
+    themeToggle: true,
+    support: true,
+    quickCreate: false,
+    superadminAccess: true,
+    devtoolsAccess: true,
+    sidebarCollapsed: false
+  },
+  dev: {
+    devKeyring: true,
+    debugMode: false
+  }
+};
+var CRM_PRESET = {
+  teamMode: "single-tenant",
+  teamRoles: ["owner", "admin", "member"],
+  defaultLocale: "en",
+  supportedLocales: ["en"],
+  billingModel: "paid",
+  currency: "usd",
+  features: {
+    analytics: true,
+    teams: true,
+    billing: true,
+    api: true,
+    docs: false
+  },
+  contentFeatures: {
+    pages: true,
+    blog: false
+  },
+  auth: {
+    emailPassword: true,
+    googleOAuth: true,
+    emailVerification: true
+  },
+  dashboard: {
+    search: true,
+    notifications: true,
+    themeToggle: true,
+    support: true,
+    quickCreate: true,
+    superadminAccess: true,
+    devtoolsAccess: true,
+    sidebarCollapsed: false
+  },
+  dev: {
+    devKeyring: true,
+    debugMode: false
+  }
+};
+var PRESETS = {
+  saas: SAAS_PRESET,
+  blog: BLOG_PRESET,
+  crm: CRM_PRESET
+};
+var PRESET_DESCRIPTIONS = {
+  saas: "Multi-tenant SaaS with freemium billing and team management",
+  blog: "Single-user blog or content site with minimal features",
+  crm: "Single-tenant CRM or internal tool with paid subscription"
+};
+function getPreset(name) {
+  const preset = PRESETS[name];
+  if (!preset) {
+    throw new Error(`Unknown preset: ${name}. Available presets: ${Object.keys(PRESETS).join(", ")}`);
+  }
+  return preset;
+}
+function applyPreset(projectInfo, presetName) {
+  const preset = getPreset(presetName);
+  return {
+    ...projectInfo,
+    ...preset
+  };
+}
+
+// src/wizard/preview.ts
+import chalk10 from "chalk";
+var BOX = {
+  vertical: "\u2502",
+  // |
+  horizontal: "\u2500",
+  // -
+  corner: "\u2514",
+  // L
+  tee: "\u251C",
+  // |-
+  topLeft: "\u250C",
+  // top-left corner
+  topRight: "\u2510",
+  // top-right corner
+  bottomLeft: "\u2514",
+  // bottom-left corner
+  bottomRight: "\u2518"
+  // bottom-right corner
+};
+function getFileTree(config) {
+  const files = [];
+  const themeDir = `contents/themes/${config.projectSlug}`;
+  files.push(`${themeDir}/config/app.config.ts`);
+  files.push(`${themeDir}/config/billing.config.ts`);
+  files.push(`${themeDir}/config/dashboard.config.ts`);
+  files.push(`${themeDir}/config/dev.config.ts`);
+  files.push(`${themeDir}/config/permissions.config.ts`);
+  files.push(`${themeDir}/config/theme.config.ts`);
+  files.push(`${themeDir}/config/auth.config.ts`);
+  files.push(`${themeDir}/config/dashboard-ui.config.ts`);
+  files.push(`${themeDir}/config/dev-tools.config.ts`);
+  files.push(`${themeDir}/entities/tasks/entity.ts`);
+  files.push(`${themeDir}/entities/tasks/schema.ts`);
+  files.push(`${themeDir}/entities/tasks/permissions.ts`);
+  files.push(`${themeDir}/blocks/hero/block.tsx`);
+  files.push(`${themeDir}/blocks/hero/schema.ts`);
+  files.push(`${themeDir}/blocks/hero/styles.ts`);
+  for (const locale of config.supportedLocales) {
+    files.push(`${themeDir}/messages/${locale}/common.json`);
+    files.push(`${themeDir}/messages/${locale}/auth.json`);
+    files.push(`${themeDir}/messages/${locale}/dashboard.json`);
+    files.push(`${themeDir}/messages/${locale}/errors.json`);
+  }
+  files.push(`${themeDir}/migrations/0001_initial_schema.sql`);
+  files.push(`${themeDir}/migrations/0002_auth_tables.sql`);
+  files.push(`${themeDir}/migrations/0003_tasks_entity.sql`);
+  files.push(`${themeDir}/styles/globals.css`);
+  files.push(`${themeDir}/styles/theme.css`);
+  files.push(`${themeDir}/styles/components.css`);
+  files.push(`${themeDir}/tests/cypress.config.ts`);
+  files.push(`${themeDir}/tests/jest/jest.config.ts`);
+  files.push(`${themeDir}/tests/cypress/e2e/auth.cy.ts`);
+  files.push(`${themeDir}/tests/cypress/e2e/dashboard.cy.ts`);
+  files.push(`${themeDir}/tests/jest/components/hero.test.tsx`);
+  return files;
+}
+function groupFilesByCategory(files) {
+  const groups = {
+    config: [],
+    entities: [],
+    blocks: [],
+    messages: [],
+    migrations: [],
+    styles: [],
+    tests: []
+  };
+  for (const file of files) {
+    if (file.includes("/config/")) {
+      groups.config.push(file);
+    } else if (file.includes("/entities/")) {
+      groups.entities.push(file);
+    } else if (file.includes("/blocks/")) {
+      groups.blocks.push(file);
+    } else if (file.includes("/messages/")) {
+      groups.messages.push(file);
+    } else if (file.includes("/migrations/")) {
+      groups.migrations.push(file);
+    } else if (file.includes("/styles/")) {
+      groups.styles.push(file);
+    } else if (file.includes("/tests/")) {
+      groups.tests.push(file);
+    }
+  }
+  return groups;
+}
+function formatFilePath(file, themeDir) {
+  return file.replace(`${themeDir}/`, "");
+}
+function showConfigPreview(config) {
+  const files = getFileTree(config);
+  const groups = groupFilesByCategory(files);
+  const themeDir = `contents/themes/${config.projectSlug}`;
+  console.log("");
+  console.log(chalk10.cyan.bold("  Theme Preview"));
+  console.log(chalk10.gray("  " + "=".repeat(50)));
+  console.log("");
+  console.log(chalk10.white.bold(`  ${BOX.topLeft}${"\u2500".repeat(48)}${BOX.topRight}`));
+  console.log(chalk10.white.bold(`  ${BOX.vertical}`) + chalk10.cyan(` ${themeDir}/`) + " ".repeat(48 - themeDir.length - 2) + chalk10.white.bold(BOX.vertical));
+  console.log(chalk10.white.bold(`  ${BOX.vertical}${"\u2500".repeat(48)}${BOX.vertical}`));
+  const categoryLabels = {
+    config: "Configuration",
+    entities: "Entities",
+    blocks: "Blocks",
+    messages: "Messages (i18n)",
+    migrations: "Migrations",
+    styles: "Styles",
+    tests: "Tests"
+  };
+  const categoryIcons = {
+    config: "*",
+    entities: "@",
+    blocks: "#",
+    messages: "%",
+    migrations: "~",
+    styles: "&",
+    tests: "!"
+  };
+  const categoryOrder = ["config", "entities", "blocks", "messages", "migrations", "styles", "tests"];
+  for (const category of categoryOrder) {
+    const categoryFiles = groups[category];
+    if (categoryFiles.length === 0) continue;
+    const label = categoryLabels[category];
+    const icon = categoryIcons[category];
+    console.log(chalk10.white.bold(`  ${BOX.vertical}  `) + chalk10.yellow(`[${icon}] ${label}`) + chalk10.gray(` (${categoryFiles.length} files)`));
+    for (let i = 0; i < categoryFiles.length; i++) {
+      const file = categoryFiles[i];
+      const isLast = i === categoryFiles.length - 1;
+      const prefix = isLast ? BOX.corner : BOX.tee;
+      const formattedPath = formatFilePath(file, themeDir);
+      console.log(chalk10.white.bold(`  ${BOX.vertical}  `) + chalk10.gray(`    ${prefix}${BOX.horizontal} `) + chalk10.white(formattedPath));
+    }
+    console.log(chalk10.white.bold(`  ${BOX.vertical}`));
+  }
+  console.log(chalk10.white.bold(`  ${BOX.bottomLeft}${"\u2500".repeat(48)}${BOX.bottomRight}`));
+  console.log("");
+  console.log(chalk10.cyan.bold("  Summary"));
+  console.log(chalk10.gray("  " + "-".repeat(30)));
+  console.log("");
+  const totalFiles = files.length;
+  const estimatedSize = "~350KB";
+  console.log(chalk10.white(`    Total files:      `) + chalk10.green.bold(totalFiles.toString()));
+  console.log(chalk10.white(`    Estimated size:   `) + chalk10.green.bold(estimatedSize));
+  console.log("");
+  console.log(chalk10.gray("    By category:"));
+  for (const category of categoryOrder) {
+    const count = groups[category].length;
+    if (count > 0) {
+      const label = categoryLabels[category].padEnd(16);
+      console.log(chalk10.gray(`      ${label}`) + chalk10.white(count.toString().padStart(3)) + chalk10.gray(" files"));
+    }
+  }
+  console.log("");
+  console.log(chalk10.gray("    Locales configured:"));
+  for (const locale of config.supportedLocales) {
+    const isDefault = locale === config.defaultLocale;
+    const suffix = isDefault ? chalk10.cyan(" (default)") : "";
+    console.log(chalk10.gray(`      - `) + chalk10.white(locale) + suffix);
+  }
+  console.log("");
+}
+
+// src/wizard/index.ts
+function getProjectInfoFromOptions(options) {
+  if (options.name && options.slug && options.description) {
+    return {
+      projectName: options.name,
+      projectSlug: options.slug,
+      projectDescription: options.description
+    };
+  }
+  return null;
+}
+async function runWizard(options = { mode: "interactive" }) {
+  showBanner();
+  showModeIndicator(options);
+  try {
+    let selectedTheme = null;
+    let selectedPlugins = [];
+    if (!options.preset) {
+      if (options.theme !== void 0) {
+        selectedTheme = options.theme === "none" ? null : options.theme;
+        showInfo(`Reference theme: ${selectedTheme || "None"}`);
+      } else if (options.mode !== "quick") {
+        selectedTheme = await promptThemeSelection();
+      }
+      if (options.plugins !== void 0) {
+        selectedPlugins = options.plugins;
+        if (selectedPlugins.length > 0) {
+          showInfo(`Selected plugins: ${selectedPlugins.join(", ")}`);
+        }
+      } else if (options.mode !== "quick" && !options.yes) {
+        selectedPlugins = await promptPluginsSelection(selectedTheme);
+      } else if (selectedTheme) {
+        selectedPlugins = getRequiredPlugins(selectedTheme);
+      }
+    }
+    let config;
+    if (options.preset) {
+      config = await runPresetMode(options.preset, options);
+    } else {
+      switch (options.mode) {
+        case "quick":
+          config = await runQuickPrompts();
+          break;
+        case "expert":
+          config = await runExpertPrompts();
+          break;
+        case "interactive":
+        default:
+          config = await runAllPrompts();
+          break;
+      }
+    }
+    showConfigSummary(config);
+    showConfigPreview(config);
+    if (!options.yes) {
+      console.log("");
+      const proceed = await confirm5({
+        message: "Proceed with project generation?",
+        default: true
+      });
+      if (!proceed) {
+        console.log("");
+        showInfo("Project generation cancelled. No changes were made.");
+        process.exit(0);
+      }
+    }
+    await copyNpmrc();
+    console.log("");
+    const coreInstalled = await installCore();
+    if (!coreInstalled) {
+      showError("Failed to install @nextsparkjs/core. Cannot generate project.");
+      process.exit(1);
+    }
+    console.log("");
+    const spinner = ora7({
+      text: "Generating your NextSpark project...",
+      prefixText: "  "
+    }).start();
+    try {
+      await generateProject(config);
+      spinner.succeed("Project generated successfully!");
+    } catch (error) {
+      spinner.fail("Failed to generate project");
+      throw error;
+    }
+    if (selectedTheme || selectedPlugins.length > 0) {
+      await installThemeAndPlugins(selectedTheme, selectedPlugins);
+    }
+    showNextSteps(config, selectedTheme);
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.message.includes("User force closed")) {
+        console.log("");
+        showInfo("Wizard cancelled. No changes were made.");
+        process.exit(0);
+      }
+      showError(error.message);
+    }
+    process.exit(1);
+  }
+}
+function showModeIndicator(options) {
+  if (options.preset) {
+    showInfo(`Using preset: ${chalk11.cyan(options.preset)} - ${PRESET_DESCRIPTIONS[options.preset]}`);
+    console.log("");
+  } else if (options.mode === "quick") {
+    showInfo("Quick mode: Running essential prompts only (steps 1-5)");
+    console.log("");
+  } else if (options.mode === "expert") {
+    showInfo("Expert mode: Running all prompts with advanced options");
+    console.log("");
+  }
+}
+async function runPresetMode(presetName, options) {
+  if (!presetName) {
+    throw new Error("Preset name is required for preset mode");
+  }
+  const projectInfoFromOptions = getProjectInfoFromOptions(options);
+  let projectInfo;
+  if (projectInfoFromOptions) {
+    projectInfo = projectInfoFromOptions;
+    showInfo(`Project: ${projectInfo.projectName} (${projectInfo.projectSlug})`);
+  } else {
+    showSection("Project Information", 1, 1);
+    showInfo("Using preset defaults. Only project information is required.");
+    console.log("");
+    projectInfo = await promptProjectInfo();
+  }
+  const config = applyPreset(projectInfo, presetName);
+  return config;
+}
+function showConfigSummary(config) {
+  console.log("");
+  console.log(chalk11.cyan("  " + "=".repeat(60)));
+  console.log(chalk11.bold.white("  Configuration Summary"));
+  console.log(chalk11.cyan("  " + "=".repeat(60)));
+  console.log("");
+  console.log(chalk11.white("  Project:"));
+  console.log(chalk11.gray(`    Name: ${chalk11.white(config.projectName)}`));
+  console.log(chalk11.gray(`    Slug: ${chalk11.white(config.projectSlug)}`));
+  console.log(chalk11.gray(`    Description: ${chalk11.white(config.projectDescription)}`));
+  console.log("");
+  console.log(chalk11.white("  Team Mode:"));
+  console.log(chalk11.gray(`    Mode: ${chalk11.white(config.teamMode)}`));
+  console.log(chalk11.gray(`    Roles: ${chalk11.white(config.teamRoles.join(", "))}`));
+  console.log("");
+  console.log(chalk11.white("  Internationalization:"));
+  console.log(chalk11.gray(`    Default: ${chalk11.white(config.defaultLocale)}`));
+  console.log(chalk11.gray(`    Languages: ${chalk11.white(config.supportedLocales.join(", "))}`));
+  console.log("");
+  console.log(chalk11.white("  Billing:"));
+  console.log(chalk11.gray(`    Model: ${chalk11.white(config.billingModel)}`));
+  console.log(chalk11.gray(`    Currency: ${chalk11.white(config.currency.toUpperCase())}`));
+  console.log("");
+  console.log(chalk11.white("  Features:"));
+  const enabledFeatures = Object.entries(config.features).filter(([_, enabled]) => enabled).map(([feature]) => feature);
+  console.log(chalk11.gray(`    Enabled: ${chalk11.white(enabledFeatures.join(", ") || "None")}`));
+  console.log("");
+  console.log(chalk11.white("  Authentication:"));
+  const enabledAuth = Object.entries(config.auth).filter(([_, enabled]) => enabled).map(([method]) => formatAuthMethod(method));
+  console.log(chalk11.gray(`    Methods: ${chalk11.white(enabledAuth.join(", ") || "None")}`));
+  console.log("");
+  console.log(chalk11.white("  Dashboard:"));
+  const enabledDashboard = Object.entries(config.dashboard).filter(([_, enabled]) => enabled).map(([feature]) => formatDashboardFeature(feature));
+  console.log(chalk11.gray(`    Features: ${chalk11.white(enabledDashboard.join(", ") || "None")}`));
+  console.log("");
+  console.log(chalk11.white("  Dev Tools:"));
+  const enabledDevTools = Object.entries(config.dev).filter(([_, enabled]) => enabled).map(([tool]) => formatDevTool(tool));
+  console.log(chalk11.gray(`    Enabled: ${chalk11.white(enabledDevTools.join(", ") || "None")}`));
+}
+function formatAuthMethod(method) {
+  const mapping = {
+    emailPassword: "Email/Password",
+    googleOAuth: "Google",
+    emailVerification: "Email Verification"
+  };
+  return mapping[method] || method;
+}
+function formatDashboardFeature(feature) {
+  const mapping = {
+    search: "Search",
+    notifications: "Notifications",
+    themeToggle: "Theme Toggle",
+    sidebarCollapsed: "Sidebar Collapsed"
+  };
+  return mapping[feature] || feature;
+}
+function formatDevTool(tool) {
+  const mapping = {
+    devKeyring: "Dev Keyring",
+    debugMode: "Debug Mode"
+  };
+  return mapping[tool] || tool;
+}
+function showNextSteps(config, referenceTheme = null) {
+  console.log("");
+  console.log(chalk11.cyan("  " + "=".repeat(60)));
+  console.log(chalk11.bold.green("  \u2728 NextSpark project created successfully!"));
+  console.log(chalk11.cyan("  " + "=".repeat(60)));
+  console.log("");
+  console.log(chalk11.bold.white("  Next steps:"));
+  console.log("");
+  console.log(chalk11.white("  1. Install dependencies:"));
+  console.log(chalk11.cyan("     pnpm install"));
+  console.log("");
+  console.log(chalk11.white("  2. Set up your environment:"));
+  console.log(chalk11.gray("     Copy .env.example to .env and configure:"));
+  console.log(chalk11.yellow("     - DATABASE_URL"));
+  console.log(chalk11.yellow("     - BETTER_AUTH_SECRET"));
+  console.log(chalk11.yellow(`     - NEXT_PUBLIC_ACTIVE_THEME=${config.projectSlug}`));
+  console.log("");
+  console.log(chalk11.white("  3. Generate registries:"));
+  console.log(chalk11.cyan("     pnpm build:registries"));
+  console.log("");
+  console.log(chalk11.white("  4. Run database migrations:"));
+  console.log(chalk11.cyan("     pnpm db:migrate"));
+  console.log("");
+  console.log(chalk11.white("  5. Start the development server:"));
+  console.log(chalk11.cyan("     pnpm dev"));
+  console.log("");
+  console.log(chalk11.gray("  " + "-".repeat(60)));
+  console.log(chalk11.gray(`  Your theme: ${chalk11.white(`contents/themes/${config.projectSlug}/`)}`));
+  if (referenceTheme) {
+    console.log(chalk11.gray(`  Reference theme: ${chalk11.white(`contents/themes/${referenceTheme}/`)}`));
+  }
+  console.log(chalk11.gray("  Documentation: https://nextspark.dev/docs"));
+  console.log("");
+}
+function findLocalCoreTarball() {
+  const cwd = process.cwd();
+  try {
+    const files = readdirSync(cwd);
+    const coreTarball = files.find(
+      (f) => f.includes("nextsparkjs-core") && f.endsWith(".tgz")
+    );
+    if (coreTarball) {
+      return join6(cwd, coreTarball);
+    }
+  } catch {
+  }
+  return null;
+}
+function isCoreInstalled() {
+  const corePath = join6(process.cwd(), "node_modules", "@nextsparkjs", "core");
+  return existsSync7(corePath);
+}
+async function installCore() {
+  if (isCoreInstalled()) {
+    return true;
+  }
+  const spinner = ora7({
+    text: "Installing @nextsparkjs/core...",
+    prefixText: "  "
+  }).start();
+  try {
+    const localTarball = findLocalCoreTarball();
+    let packageSpec = "@nextsparkjs/core";
+    if (localTarball) {
+      packageSpec = localTarball;
+      spinner.text = "Installing @nextsparkjs/core from local tarball...";
+    }
+    const useYarn = existsSync7(join6(process.cwd(), "yarn.lock"));
+    const usePnpm = existsSync7(join6(process.cwd(), "pnpm-lock.yaml"));
+    let installCmd;
+    if (usePnpm) {
+      installCmd = `pnpm add ${packageSpec}`;
+    } else if (useYarn) {
+      installCmd = `yarn add ${packageSpec}`;
+    } else {
+      installCmd = `npm install ${packageSpec}`;
+    }
+    execSync(installCmd, {
+      stdio: "pipe",
+      cwd: process.cwd()
+    });
+    spinner.succeed(chalk11.green("@nextsparkjs/core installed successfully!"));
+    return true;
+  } catch (error) {
+    spinner.fail(chalk11.red("Failed to install @nextsparkjs/core"));
+    if (error instanceof Error) {
+      console.log(chalk11.red(`  Error: ${error.message}`));
+    }
+    console.log(chalk11.gray("  Hint: Make sure the package is available (npm registry or local tarball)"));
+    return false;
+  }
+}
+async function copyNpmrc() {
+  const npmrcPath = join6(process.cwd(), ".npmrc");
+  if (existsSync7(npmrcPath)) {
+    return;
+  }
+  const npmrcContent = `# Hoist @nextsparkjs/core dependencies so they're accessible from the project
+# This is required for pnpm to make peer dependencies available
+public-hoist-pattern[]=*
+`;
+  const { writeFileSync: writeFileSync3 } = await import("fs");
+  writeFileSync3(npmrcPath, npmrcContent);
+}
+
+// src/commands/init.ts
+function getWizardMode(options) {
+  if (options.quick) return "quick";
+  if (options.expert) return "expert";
+  return "interactive";
+}
+function parsePlugins(pluginsStr) {
+  if (!pluginsStr) return void 0;
+  return pluginsStr.split(",").map((p) => p.trim());
+}
+function hasExistingProject() {
+  const projectRoot = process.cwd();
+  return existsSync8(join7(projectRoot, "contents")) || existsSync8(join7(projectRoot, ".nextspark"));
+}
+function generateInitialRegistries(registriesDir) {
+  writeFileSync2(join7(registriesDir, "block-registry.ts"), `// Auto-generated by nextspark init
+import type { ComponentType } from 'react'
+
+export const BLOCK_REGISTRY: Record<string, {
+  name: string
+  slug: string
+  componentPath: string
+  fields?: unknown[]
+  examples?: unknown[]
+}> = {}
+
+export const BLOCK_COMPONENTS: Record<string, React.LazyExoticComponent<ComponentType<any>>> = {}
+`);
+  writeFileSync2(join7(registriesDir, "theme-registry.ts"), `// Auto-generated by nextspark init
+export const THEME_REGISTRY: Record<string, unknown> = {}
+`);
+  writeFileSync2(join7(registriesDir, "entity-registry.ts"), `// Auto-generated by nextspark init
+export const ENTITY_REGISTRY: Record<string, unknown> = {}
+`);
+  writeFileSync2(join7(registriesDir, "entity-registry.client.ts"), `// Auto-generated by nextspark init
+export const CLIENT_ENTITY_REGISTRY: Record<string, unknown> = {}
+export function parseChildEntity(path: string) { return null }
+export function getEntityApiPath(entity: string) { return \`/api/\${entity}\` }
+export function clientMetaSystemAdapter() { return {} }
+export type ClientEntityConfig = Record<string, unknown>
+`);
+  writeFileSync2(join7(registriesDir, "billing-registry.ts"), `// Auto-generated by nextspark init
+export const BILLING_REGISTRY = { plans: [], features: [] }
+`);
+  writeFileSync2(join7(registriesDir, "plugin-registry.ts"), `// Auto-generated by nextspark init
+export const PLUGIN_REGISTRY: Record<string, unknown> = {}
+`);
+  writeFileSync2(join7(registriesDir, "testing-registry.ts"), `// Auto-generated by nextspark init
+export const FLOW_REGISTRY: Record<string, unknown> = {}
+export const FEATURE_REGISTRY: Record<string, unknown> = {}
+export const TAGS_REGISTRY: Record<string, unknown> = {}
+export const COVERAGE_SUMMARY = { total: 0, covered: 0 }
+export type FlowEntry = unknown
+export type FeatureEntry = unknown
+`);
+  writeFileSync2(join7(registriesDir, "docs-registry.ts"), `// Auto-generated by nextspark init
+export const DOCS_REGISTRY = { sections: [], pages: [] }
+export type DocSectionMeta = { title: string; slug: string }
+`);
+  writeFileSync2(join7(registriesDir, "index.ts"), `// Auto-generated by nextspark init
+export * from './block-registry'
+export * from './theme-registry'
+export * from './entity-registry'
+export * from './entity-registry.client'
+export * from './billing-registry'
+export * from './plugin-registry'
+export * from './testing-registry'
+export * from './docs-registry'
+`);
+}
+async function simpleInit(options) {
+  const spinner = ora8("Initializing NextSpark project...").start();
+  const projectRoot = process.cwd();
+  try {
+    const nextspark = join7(projectRoot, ".nextspark");
+    const registriesDir = join7(nextspark, "registries");
+    if (!existsSync8(registriesDir) || options.force) {
+      mkdirSync2(registriesDir, { recursive: true });
+      spinner.text = "Creating .nextspark/registries/";
+      generateInitialRegistries(registriesDir);
+      spinner.text = "Generated initial registries";
+    }
+    const tsconfigPath = join7(projectRoot, "tsconfig.json");
+    if (existsSync8(tsconfigPath)) {
+      spinner.text = "Updating tsconfig.json paths...";
+      const tsconfig = JSON.parse(readFileSync6(tsconfigPath, "utf-8"));
+      tsconfig.compilerOptions = tsconfig.compilerOptions || {};
+      tsconfig.compilerOptions.paths = {
+        ...tsconfig.compilerOptions.paths,
+        "@nextsparkjs/registries": ["./.nextspark/registries/index.ts"],
+        "@nextsparkjs/registries/*": ["./.nextspark/registries/*"]
+      };
+      writeFileSync2(tsconfigPath, JSON.stringify(tsconfig, null, 2));
+    }
+    const envExample = join7(projectRoot, ".env.example");
+    if (!existsSync8(envExample)) {
+      const envContent = `# NextSpark Configuration
+DATABASE_URL="postgresql://user:password@localhost:5432/db"
+BETTER_AUTH_SECRET="your-secret-here-min-32-chars"
+BETTER_AUTH_URL=http://localhost:3000
+NEXT_PUBLIC_APP_URL=http://localhost:3000
+`;
+      writeFileSync2(envExample, envContent);
+      spinner.text = "Created .env.example";
+    }
+    spinner.succeed("NextSpark initialized successfully!");
+    console.log(chalk12.blue("\nNext steps:"));
+    console.log("  1. Copy .env.example to .env and configure");
+    console.log("  2. Run: nextspark generate");
+    console.log("  3. Run: nextspark dev");
   } catch (error) {
     spinner.fail("Initialization failed");
     if (error instanceof Error) {
-      console.error(chalk5.red(error.message));
+      console.error(chalk12.red(error.message));
+    }
+    process.exit(1);
+  }
+}
+async function initCommand(options) {
+  if (options.registriesOnly) {
+    await simpleInit(options);
+    return;
+  }
+  if (hasExistingProject() && !options.wizard && !options.preset && !options.theme) {
+    console.log(chalk12.yellow("Existing NextSpark project detected."));
+    console.log(chalk12.gray("Use --wizard to run the full wizard, or --registries-only for just registries."));
+    await simpleInit(options);
+    return;
+  }
+  const wizardOptions = {
+    mode: getWizardMode(options),
+    preset: options.preset,
+    theme: options.theme,
+    plugins: parsePlugins(options.plugins),
+    yes: options.yes,
+    name: options.name,
+    slug: options.slug,
+    description: options.description
+  };
+  await runWizard(wizardOptions);
+}
+
+// src/commands/doctor.ts
+import chalk14 from "chalk";
+
+// src/doctor/index.ts
+import chalk13 from "chalk";
+
+// src/doctor/checks/dependencies.ts
+import fs8 from "fs-extra";
+import path6 from "path";
+async function checkDependencies() {
+  const cwd = process.cwd();
+  const nodeModulesPath = path6.join(cwd, "node_modules");
+  const packageJsonPath = path6.join(cwd, "package.json");
+  if (!await fs8.pathExists(packageJsonPath)) {
+    return {
+      name: "Dependencies",
+      status: "fail",
+      message: "package.json not found",
+      fix: "Ensure you are in a NextSpark project directory"
+    };
+  }
+  if (!await fs8.pathExists(nodeModulesPath)) {
+    return {
+      name: "Dependencies",
+      status: "fail",
+      message: "node_modules not found",
+      fix: "Run: pnpm install"
+    };
+  }
+  let packageJson;
+  try {
+    packageJson = await fs8.readJson(packageJsonPath);
+  } catch {
+    return {
+      name: "Dependencies",
+      status: "fail",
+      message: "Failed to read package.json",
+      fix: "Ensure package.json is valid JSON"
+    };
+  }
+  const allDependencies = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies
+  };
+  const missingDeps = [];
+  const criticalDeps = ["next", "react", "react-dom"];
+  for (const dep of criticalDeps) {
+    if (allDependencies[dep]) {
+      const depPath = path6.join(nodeModulesPath, dep);
+      if (!await fs8.pathExists(depPath)) {
+        missingDeps.push(dep);
+      }
+    }
+  }
+  const nextsparksCorePath = path6.join(nodeModulesPath, "@nextsparkjs", "core");
+  const hasNextSparkCore = await fs8.pathExists(nextsparksCorePath);
+  if (missingDeps.length > 0) {
+    return {
+      name: "Dependencies",
+      status: "fail",
+      message: `Missing packages: ${missingDeps.join(", ")}`,
+      fix: "Run: pnpm install"
+    };
+  }
+  if (!hasNextSparkCore && allDependencies["@nextsparkjs/core"]) {
+    return {
+      name: "Dependencies",
+      status: "warn",
+      message: "@nextsparkjs/core not installed",
+      fix: "Run: pnpm install"
+    };
+  }
+  return {
+    name: "Dependencies",
+    status: "pass",
+    message: "All packages installed"
+  };
+}
+
+// src/doctor/checks/config.ts
+import fs9 from "fs-extra";
+import path7 from "path";
+var REQUIRED_CONFIG_FILES = [
+  "next.config.ts",
+  "tailwind.config.ts",
+  "tsconfig.json"
+];
+async function checkConfigs() {
+  const cwd = process.cwd();
+  const missingFiles = [];
+  const invalidFiles = [];
+  for (const file of REQUIRED_CONFIG_FILES) {
+    const filePath = path7.join(cwd, file);
+    if (file.endsWith(".ts")) {
+      const jsPath = path7.join(cwd, file.replace(".ts", ".js"));
+      const mjsPath = path7.join(cwd, file.replace(".ts", ".mjs"));
+      const tsExists = await fs9.pathExists(filePath);
+      const jsExists = await fs9.pathExists(jsPath);
+      const mjsExists = await fs9.pathExists(mjsPath);
+      if (!tsExists && !jsExists && !mjsExists) {
+        if (!file.includes("next.config") && !file.includes("tailwind.config")) {
+          missingFiles.push(file);
+        }
+      }
+      continue;
+    }
+    if (!await fs9.pathExists(filePath)) {
+      missingFiles.push(file);
+    }
+  }
+  const tsconfigPath = path7.join(cwd, "tsconfig.json");
+  if (await fs9.pathExists(tsconfigPath)) {
+    try {
+      const content = await fs9.readFile(tsconfigPath, "utf-8");
+      JSON.parse(content);
+    } catch {
+      invalidFiles.push("tsconfig.json");
+    }
+  } else {
+    missingFiles.push("tsconfig.json");
+  }
+  const configDir = path7.join(cwd, "config");
+  if (await fs9.pathExists(configDir)) {
+    const configFiles = await fs9.readdir(configDir);
+    const tsConfigFiles = configFiles.filter((f) => f.endsWith(".ts"));
+    for (const file of tsConfigFiles) {
+      const filePath = path7.join(configDir, file);
+      try {
+        const content = await fs9.readFile(filePath, "utf-8");
+        if (content.trim().length === 0) {
+          invalidFiles.push(`config/${file}`);
+        }
+      } catch {
+        invalidFiles.push(`config/${file}`);
+      }
+    }
+  }
+  if (invalidFiles.length > 0) {
+    return {
+      name: "Configuration",
+      status: "fail",
+      message: `Invalid config files: ${invalidFiles.join(", ")}`,
+      fix: "Check the syntax of the invalid configuration files"
+    };
+  }
+  if (missingFiles.length > 0) {
+    return {
+      name: "Configuration",
+      status: "warn",
+      message: `Missing config files: ${missingFiles.join(", ")}`,
+      fix: "Run: npx nextspark init to regenerate configuration"
+    };
+  }
+  return {
+    name: "Configuration",
+    status: "pass",
+    message: "All config files valid"
+  };
+}
+
+// src/doctor/checks/database.ts
+import fs10 from "fs-extra";
+import path8 from "path";
+function parseEnvFile(content) {
+  const result = {};
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const equalsIndex = trimmed.indexOf("=");
+    if (equalsIndex > 0) {
+      const key = trimmed.substring(0, equalsIndex).trim();
+      let value = trimmed.substring(equalsIndex + 1).trim();
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      result[key] = value;
+    }
+  }
+  return result;
+}
+async function checkDatabase() {
+  const cwd = process.cwd();
+  const envPath = path8.join(cwd, ".env");
+  const envLocalPath = path8.join(cwd, ".env.local");
+  let envVars = {};
+  if (await fs10.pathExists(envLocalPath)) {
+    try {
+      const content = await fs10.readFile(envLocalPath, "utf-8");
+      envVars = { ...envVars, ...parseEnvFile(content) };
+    } catch {
+    }
+  }
+  if (await fs10.pathExists(envPath)) {
+    try {
+      const content = await fs10.readFile(envPath, "utf-8");
+      envVars = { ...envVars, ...parseEnvFile(content) };
+    } catch {
+    }
+  }
+  const databaseUrl = envVars["DATABASE_URL"] || process.env.DATABASE_URL;
+  if (!await fs10.pathExists(envPath) && !await fs10.pathExists(envLocalPath)) {
+    return {
+      name: "Database",
+      status: "warn",
+      message: "No .env file found",
+      fix: "Copy .env.example to .env and configure DATABASE_URL"
+    };
+  }
+  if (!databaseUrl) {
+    return {
+      name: "Database",
+      status: "warn",
+      message: "DATABASE_URL not configured",
+      fix: "Add DATABASE_URL to .env"
+    };
+  }
+  if (databaseUrl.includes("your-") || databaseUrl.includes("example") || databaseUrl.includes("placeholder") || databaseUrl === "postgresql://") {
+    return {
+      name: "Database",
+      status: "warn",
+      message: "DATABASE_URL appears to be a placeholder",
+      fix: "Update DATABASE_URL in .env with your actual database connection string"
+    };
+  }
+  const isValidFormat = databaseUrl.startsWith("postgresql://") || databaseUrl.startsWith("postgres://") || databaseUrl.startsWith("mysql://") || databaseUrl.startsWith("sqlite:");
+  if (!isValidFormat) {
+    return {
+      name: "Database",
+      status: "warn",
+      message: "DATABASE_URL format may be invalid",
+      fix: "Ensure DATABASE_URL is a valid database connection string"
+    };
+  }
+  return {
+    name: "Database",
+    status: "pass",
+    message: "DATABASE_URL configured"
+  };
+}
+
+// src/doctor/checks/imports.ts
+import fs11 from "fs-extra";
+import path9 from "path";
+async function checkCorePackage(cwd) {
+  const nodeModulesPath = path9.join(cwd, "node_modules", "@nextsparkjs", "core");
+  if (!await fs11.pathExists(nodeModulesPath)) {
+    return { accessible: false, reason: "@nextsparkjs/core not found in node_modules" };
+  }
+  const packageJsonPath = path9.join(nodeModulesPath, "package.json");
+  if (!await fs11.pathExists(packageJsonPath)) {
+    return { accessible: false, reason: "@nextsparkjs/core package.json not found" };
+  }
+  try {
+    const packageJson = await fs11.readJson(packageJsonPath);
+    const mainEntry = packageJson.main || packageJson.module || "./dist/index.js";
+    const mainPath = path9.join(nodeModulesPath, mainEntry);
+    if (!await fs11.pathExists(mainPath)) {
+      return { accessible: false, reason: "@nextsparkjs/core entry point not found" };
+    }
+  } catch {
+    return { accessible: false, reason: "Failed to read @nextsparkjs/core package.json" };
+  }
+  return { accessible: true };
+}
+async function scanForBrokenImports(cwd) {
+  const brokenImports = [];
+  const srcDirs = ["src", "app", "pages", "components", "lib"];
+  const existingDirs = [];
+  for (const dir of srcDirs) {
+    const dirPath = path9.join(cwd, dir);
+    if (await fs11.pathExists(dirPath)) {
+      existingDirs.push(dirPath);
+    }
+  }
+  const maxFilesToScan = 50;
+  let filesScanned = 0;
+  for (const dir of existingDirs) {
+    if (filesScanned >= maxFilesToScan) break;
+    try {
+      const files = await fs11.readdir(dir, { withFileTypes: true });
+      for (const file of files) {
+        if (filesScanned >= maxFilesToScan) break;
+        if (file.isFile() && (file.name.endsWith(".ts") || file.name.endsWith(".tsx"))) {
+          const filePath = path9.join(dir, file.name);
+          try {
+            const content = await fs11.readFile(filePath, "utf-8");
+            const importMatches = content.match(/from ['"](@?[^'"]+)['"]/g);
+            if (importMatches) {
+              for (const match of importMatches) {
+                const importPath = match.replace(/from ['"]/g, "").replace(/['"]/g, "");
+                if (importPath.startsWith(".")) {
+                  const absoluteImportPath = path9.resolve(path9.dirname(filePath), importPath);
+                  const possiblePaths = [
+                    absoluteImportPath,
+                    `${absoluteImportPath}.ts`,
+                    `${absoluteImportPath}.tsx`,
+                    `${absoluteImportPath}.js`,
+                    `${absoluteImportPath}.jsx`,
+                    path9.join(absoluteImportPath, "index.ts"),
+                    path9.join(absoluteImportPath, "index.tsx"),
+                    path9.join(absoluteImportPath, "index.js")
+                  ];
+                  const exists = await Promise.any(
+                    possiblePaths.map(async (p) => {
+                      if (await fs11.pathExists(p)) return true;
+                      throw new Error("Not found");
+                    })
+                  ).catch(() => false);
+                  if (!exists) {
+                    brokenImports.push(`${file.name}: ${importPath}`);
+                  }
+                }
+              }
+            }
+            filesScanned++;
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return brokenImports;
+}
+async function checkImports() {
+  const cwd = process.cwd();
+  const coreCheck = await checkCorePackage(cwd);
+  if (!coreCheck.accessible) {
+    const packageJsonPath = path9.join(cwd, "package.json");
+    let hasCoreDep = false;
+    if (await fs11.pathExists(packageJsonPath)) {
+      try {
+        const packageJson = await fs11.readJson(packageJsonPath);
+        hasCoreDep = !!(packageJson.dependencies?.["@nextsparkjs/core"] || packageJson.devDependencies?.["@nextsparkjs/core"]);
+      } catch {
+      }
+    }
+    if (hasCoreDep) {
+      return {
+        name: "Imports",
+        status: "fail",
+        message: coreCheck.reason || "@nextsparkjs/core not accessible",
+        fix: "Run: pnpm install"
+      };
+    }
+  }
+  try {
+    const brokenImports = await scanForBrokenImports(cwd);
+    if (brokenImports.length > 0) {
+      const displayImports = brokenImports.slice(0, 3).join(", ");
+      const remaining = brokenImports.length > 3 ? ` (+${brokenImports.length - 3} more)` : "";
+      return {
+        name: "Imports",
+        status: "warn",
+        message: `Potentially broken imports: ${displayImports}${remaining}`,
+        fix: "Check the import paths in the mentioned files"
+      };
+    }
+  } catch {
+  }
+  return {
+    name: "Imports",
+    status: "pass",
+    message: "No broken imports found"
+  };
+}
+
+// src/doctor/index.ts
+var STATUS_ICONS = {
+  pass: chalk13.green("\u2713"),
+  warn: chalk13.yellow("\u26A0"),
+  fail: chalk13.red("\u2717")
+};
+function formatResult(result) {
+  const icon = STATUS_ICONS[result.status];
+  const nameColor = result.status === "fail" ? chalk13.red : result.status === "warn" ? chalk13.yellow : chalk13.white;
+  const name = nameColor(result.name.padEnd(18));
+  const message = chalk13.gray(result.message);
+  let output = `${icon} ${name} ${message}`;
+  if (result.fix && result.status !== "pass") {
+    output += `
+${" ".repeat(22)}${chalk13.cyan("\u2192")} ${chalk13.cyan(result.fix)}`;
+  }
+  return output;
+}
+function showHeader() {
+  console.log("");
+  console.log(chalk13.cyan("\u{1FA7A} NextSpark Health Check"));
+  console.log("");
+}
+function showSummary(results) {
+  const passed = results.filter((r) => r.status === "pass").length;
+  const warnings = results.filter((r) => r.status === "warn").length;
+  const failed = results.filter((r) => r.status === "fail").length;
+  console.log("");
+  console.log(chalk13.gray("-".repeat(50)));
+  const summary = [
+    chalk13.green(`${passed} passed`),
+    warnings > 0 ? chalk13.yellow(`${warnings} warning${warnings > 1 ? "s" : ""}`) : null,
+    failed > 0 ? chalk13.red(`${failed} failed`) : null
+  ].filter(Boolean).join(", ");
+  console.log(`Summary: ${summary}`);
+  console.log("");
+  if (failed > 0) {
+    process.exitCode = 1;
+  }
+}
+async function runHealthCheck() {
+  const results = [];
+  const checks = [
+    { name: "Dependencies", fn: checkDependencies },
+    { name: "Configuration", fn: checkConfigs },
+    { name: "Database", fn: checkDatabase },
+    { name: "Imports", fn: checkImports }
+  ];
+  for (const check of checks) {
+    try {
+      const result = await check.fn();
+      results.push(result);
+    } catch (error) {
+      results.push({
+        name: check.name,
+        status: "fail",
+        message: error instanceof Error ? error.message : "Unknown error occurred",
+        fix: "Check the error message and try again"
+      });
+    }
+  }
+  return results;
+}
+async function runDoctorCommand() {
+  showHeader();
+  const results = await runHealthCheck();
+  for (const result of results) {
+    console.log(formatResult(result));
+  }
+  showSummary(results);
+}
+var isDirectExecution = process.argv[1]?.includes("doctor") || process.argv.includes("doctor");
+if (isDirectExecution && typeof __require !== "undefined") {
+  runDoctorCommand().catch((error) => {
+    console.error(chalk13.red("An unexpected error occurred:"), error.message);
+    process.exit(1);
+  });
+}
+
+// src/commands/doctor.ts
+async function doctorCommand() {
+  try {
+    await runDoctorCommand();
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk14.red(`Error: ${error.message}`));
     }
     process.exit(1);
   }
@@ -447,7 +3610,7 @@ NEXT_PUBLIC_APP_URL=http://localhost:3000
 
 // src/cli.ts
 var program = new Command();
-program.name("nextspark").description("NextSpark CLI - Professional SaaS Boilerplate").version("0.3.0");
+program.name("nextspark").description("NextSpark CLI - Professional SaaS Boilerplate").version("0.1.0-beta.4");
 program.command("dev").description("Start development server with registry watcher").option("-p, --port <port>", "Port to run the dev server on", "3000").option("--no-registry", "Disable registry watcher").action(devCommand);
 program.command("build").description("Build for production").option("--no-registry", "Skip registry generation before build").action(buildCommand);
 program.command("generate").description("Generate all registries").option("-w, --watch", "Watch for changes").action(generateCommand);
@@ -456,9 +3619,12 @@ registry.command("build").description("Build all registries").action(registryBui
 registry.command("watch").description("Watch and rebuild registries on changes").action(registryWatchCommand);
 program.command("registry:build").description("Build all registries (alias)").action(registryBuildCommand);
 program.command("registry:watch").description("Watch and rebuild registries (alias)").action(registryWatchCommand);
-program.command("init").description("Initialize NextSpark in current project").option("-f, --force", "Overwrite existing configuration").action(initCommand);
+program.command("init").description("Initialize NextSpark project").option("-f, --force", "Overwrite existing configuration").option("--wizard", "Run full project wizard").option("--quick", "Quick wizard mode (essential steps only)").option("--expert", "Expert wizard mode (all options)").option("--preset <name>", "Use preset configuration (saas, blog, crm)").option("--theme <name>", "Pre-select theme (default, blog, crm, productivity, none)").option("--plugins <list>", "Pre-select plugins (comma-separated)").option("-y, --yes", "Skip confirmations").option("--registries-only", "Only create registries (no wizard)").option("--name <name>", "Project name (non-interactive mode)").option("--slug <slug>", "Project slug (non-interactive mode)").option("--description <desc>", "Project description (non-interactive mode)").action(initCommand);
+program.command("add:plugin <package>").description("Add a plugin to your project").option("-v, --version <version>", "Specific version to install").option("-f, --force", "Overwrite if already exists").option("--skip-postinstall", "Skip postinstall hooks").option("--no-deps", "Skip installing dependencies").option("--dry-run", "Show what would be done without making changes").action(addPluginCommand);
+program.command("add:theme <package>").description("Add a theme to your project").option("-v, --version <version>", "Specific version to install").option("-f, --force", "Overwrite if already exists").option("--skip-postinstall", "Skip postinstall hooks").option("--no-deps", "Skip installing dependencies").option("--dry-run", "Show what would be done without making changes").action(addThemeCommand);
+program.command("doctor").description("Run health check on NextSpark project").action(doctorCommand);
 program.showHelpAfterError();
 program.configureOutput({
-  writeErr: (str) => process.stderr.write(chalk6.red(str))
+  writeErr: (str) => process.stderr.write(chalk15.red(str))
 });
 program.parse();