@nextsparkjs/cli 0.1.0-beta.69 → 0.1.0-beta.70

package/dist/{add-plugin-I3UJFL7U.js → add-plugin-KIJLCOEQ.js}

@@ -1,7 +1,7 @@
 import {
   addPlugin,
   addPluginCommand
-} from "./chunk-ALB2C27N.js";
+} from "./chunk-DXL5CEZD.js";
 export {
   addPlugin,
   addPluginCommand

package/dist/{chunk-ALB2C27N.js → chunk-DXL5CEZD.js}

@@ -158,60 +158,21 @@ function validateTheme(packageJson, extractedPath) {
 }
 
 // src/lib/installer.ts
-import { existsSync as existsSync5, cpSync, rmSync as rmSync2, mkdirSync } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync4, cpSync, rmSync as rmSync2, mkdirSync, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
 import chalk from "chalk";
 
-// src/lib/package-manager.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join3 } from "path";
-import { execSync as execSync2 } from "child_process";
-function detectPackageManager() {
-  const cwd = process.cwd();
-  if (existsSync3(join3(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync3(join3(cwd, "yarn.lock"))) return "yarn";
-  if (existsSync3(join3(cwd, "package-lock.json"))) return "npm";
-  const pkgPath = join3(cwd, "package.json");
-  if (existsSync3(pkgPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
-      if (pkg.packageManager) {
-        if (pkg.packageManager.startsWith("pnpm")) return "pnpm";
-        if (pkg.packageManager.startsWith("yarn")) return "yarn";
-      }
-    } catch {
-    }
-  }
-  return "npm";
-}
-function getInstallCommand(pm, deps) {
-  const depsStr = deps.join(" ");
-  switch (pm) {
-    case "pnpm":
-      return `pnpm add ${depsStr}`;
-    case "yarn":
-      return `yarn add ${depsStr}`;
-    default:
-      return `npm install ${depsStr}`;
-  }
-}
-async function runInstall(pm, deps) {
-  if (deps.length === 0) return;
-  const command = getInstallCommand(pm, deps);
-  execSync2(command, { stdio: "inherit", cwd: process.cwd() });
-}
-
 // src/lib/config-updater.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { join as join3 } from "path";
 async function updateTsConfig(name, type) {
-  const tsconfigPath = join4(process.cwd(), "tsconfig.json");
-  if (!existsSync4(tsconfigPath)) {
+  const tsconfigPath = join3(process.cwd(), "tsconfig.json");
+  if (!existsSync3(tsconfigPath)) {
     console.log("  Warning: tsconfig.json not found, skipping path update");
     return;
   }
   try {
-    const content = readFileSync4(tsconfigPath, "utf-8");
+    const content = readFileSync3(tsconfigPath, "utf-8");
     const tsconfig = JSON.parse(content);
     if (!tsconfig.compilerOptions) {
       tsconfig.compilerOptions = {};
@@ -231,13 +192,13 @@ async function updateTsConfig(name, type) {
   }
 }
 async function registerInPackageJson(npmName, version, type) {
-  const pkgPath = join4(process.cwd(), "package.json");
-  if (!existsSync4(pkgPath)) {
+  const pkgPath = join3(process.cwd(), "package.json");
+  if (!existsSync3(pkgPath)) {
     console.log("  Warning: package.json not found, skipping registration");
     return;
   }
   try {
-    const content = readFileSync4(pkgPath, "utf-8");
+    const content = readFileSync3(pkgPath, "utf-8");
     const pkg = JSON.parse(content);
     if (!pkg.nextspark) {
       pkg.nextspark = {};
@@ -265,7 +226,7 @@ async function registerInPackageJson(npmName, version, type) {
 // src/lib/installer.ts
 async function installPlugin(extractedPath, packageJson, options = {}) {
   const pluginName = extractPluginName(packageJson.name);
-  const targetDir = join5(process.cwd(), "contents", "plugins", pluginName);
+  const targetDir = join4(process.cwd(), "contents", "plugins", pluginName);
   if (options.dryRun) {
     console.log(chalk.cyan("\n  [Dry Run] Would perform:"));
     console.log(`    - Copy to: contents/plugins/${pluginName}/`);
@@ -276,7 +237,7 @@ async function installPlugin(extractedPath, packageJson, options = {}) {
     console.log(`    - Register in package.json`);
     return { success: true, installedPath: targetDir, name: pluginName };
   }
-  if (existsSync5(targetDir)) {
+  if (existsSync4(targetDir)) {
     if (!options.force) {
       throw new Error(
         `Plugin "${pluginName}" already exists at ${targetDir}.
@@ -286,24 +247,20 @@ Use --force to overwrite.`
     console.log(chalk.yellow(`  Removing existing plugin...`));
     rmSync2(targetDir, { recursive: true, force: true });
   }
-  const pluginsDir = join5(process.cwd(), "contents", "plugins");
-  if (!existsSync5(pluginsDir)) {
+  const pluginsDir = join4(process.cwd(), "contents", "plugins");
+  if (!existsSync4(pluginsDir)) {
     mkdirSync(pluginsDir, { recursive: true });
   }
   console.log(`  Copying to contents/plugins/${pluginName}/...`);
   cpSync(extractedPath, targetDir, { recursive: true });
-  if (!options.skipDeps) {
-    const deps = packageJson.dependencies || {};
-    const depNames = Object.keys(deps);
-    if (depNames.length > 0) {
-      console.log(`  Installing ${depNames.length} dependencies...`);
-      const pm = detectPackageManager();
-      const depsWithVersions = Object.entries(deps).map(([name, version]) => `${name}@${version}`);
-      await runInstall(pm, depsWithVersions);
-    }
+  const deps = packageJson.dependencies || {};
+  const depCount = Object.keys(deps).length;
+  if (depCount > 0) {
+    console.log(`  Plugin has ${depCount} dependencies (will be installed via workspace)`);
   }
   await updateTsConfig(pluginName, "plugin");
   await registerInPackageJson(packageJson.name, packageJson.version || "0.0.0", "plugin");
+  await registerPluginInThemeConfig(pluginName);
   return {
     success: true,
     installedPath: targetDir,
@@ -312,7 +269,7 @@ Use --force to overwrite.`
 }
 async function installTheme(extractedPath, packageJson, options = {}) {
   const themeName = extractThemeName(packageJson.name);
-  const targetDir = join5(process.cwd(), "contents", "themes", themeName);
+  const targetDir = join4(process.cwd(), "contents", "themes", themeName);
   if (options.dryRun) {
     console.log(chalk.cyan("\n  [Dry Run] Would perform:"));
     console.log(`    - Copy to: contents/themes/${themeName}/`);
@@ -323,7 +280,7 @@ async function installTheme(extractedPath, packageJson, options = {}) {
     console.log(`    - Register in package.json`);
     return { success: true, installedPath: targetDir, name: themeName };
   }
-  if (existsSync5(targetDir)) {
+  if (existsSync4(targetDir)) {
     if (!options.force) {
       throw new Error(
         `Theme "${themeName}" already exists at ${targetDir}.
@@ -333,8 +290,8 @@ Use --force to overwrite.`
     console.log(chalk.yellow(`  Removing existing theme...`));
     rmSync2(targetDir, { recursive: true, force: true });
   }
-  const themesDir = join5(process.cwd(), "contents", "themes");
-  if (!existsSync5(themesDir)) {
+  const themesDir = join4(process.cwd(), "contents", "themes");
+  if (!existsSync4(themesDir)) {
     mkdirSync(themesDir, { recursive: true });
   }
   console.log(`  Copying to contents/themes/${themeName}/...`);
@@ -353,23 +310,59 @@ function extractPluginName(npmName) {
 function extractThemeName(npmName) {
   return npmName.replace(/^@[^/]+\//, "").replace(/^nextspark-theme-/, "").replace(/^theme-/, "");
 }
+async function registerPluginInThemeConfig(pluginName) {
+  const envPath = join4(process.cwd(), ".env");
+  let activeTheme = "starter";
+  if (existsSync4(envPath)) {
+    const envContent = readFileSync4(envPath, "utf-8");
+    const match = envContent.match(/NEXT_PUBLIC_ACTIVE_THEME=["']?([^"'\s\n]+)["']?/);
+    if (match) {
+      activeTheme = match[1];
+    }
+  }
+  const themeConfigPath = join4(process.cwd(), "contents", "themes", activeTheme, "config", "theme.config.ts");
+  if (!existsSync4(themeConfigPath)) {
+    console.log(chalk.gray(`  Theme config not found, skipping plugin registration`));
+    return;
+  }
+  try {
+    let content = readFileSync4(themeConfigPath, "utf-8");
+    if (content.includes(`'${pluginName}'`) || content.includes(`"${pluginName}"`)) {
+      console.log(chalk.gray(`  Plugin ${pluginName} already registered in theme config`));
+      return;
+    }
+    const pluginsArrayMatch = content.match(/plugins:\s*\[([^\]]*)\]/s);
+    if (pluginsArrayMatch) {
+      const existingPlugins = pluginsArrayMatch[1].trim();
+      const newPlugins = existingPlugins ? `${existingPlugins}, '${pluginName}'` : `'${pluginName}'`;
+      content = content.replace(
+        /plugins:\s*\[([^\]]*)\]/s,
+        `plugins: [${newPlugins}]`
+      );
+      writeFileSync2(themeConfigPath, content);
+      console.log(`  Registered plugin in theme.config.ts`);
+    }
+  } catch (error) {
+    console.log(chalk.yellow(`  Could not register plugin in theme config: ${error}`));
+  }
+}
 
 // src/lib/postinstall/index.ts
 import chalk6 from "chalk";
 
 // src/lib/postinstall/templates.ts
-import { existsSync as existsSync6, cpSync as cpSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join6, dirname } from "path";
+import { existsSync as existsSync5, cpSync as cpSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join5, dirname } from "path";
 import chalk2 from "chalk";
 async function processTemplates(templates, sourcePath, context) {
   for (const template of templates) {
-    const from = join6(sourcePath, template.from);
+    const from = join5(sourcePath, template.from);
     const to = resolveVariables(template.to, context);
-    if (!existsSync6(from)) {
+    if (!existsSync5(from)) {
       console.log(chalk2.yellow(`  Warning: Template source not found: ${template.from}`));
       continue;
     }
-    const targetExists = existsSync6(to);
+    const targetExists = existsSync5(to);
     const condition = template.condition || "!exists";
     const desc = template.description || template.to;
     switch (condition) {
@@ -395,7 +388,7 @@ async function processTemplates(templates, sourcePath, context) {
         break;
     }
     const parentDir = dirname(to);
-    if (!existsSync6(parentDir)) {
+    if (!existsSync5(parentDir)) {
       mkdirSync2(parentDir, { recursive: true });
     }
     console.log(chalk2.gray(`  Copying ${desc}...`));
@@ -421,21 +414,21 @@ function resolveVariables(path, context) {
     throw new Error(`Unresolved template variable: ${unresolvedMatch[0]}`);
   }
   if (!resolved.startsWith("/")) {
-    resolved = join6(context.projectRoot, resolved);
+    resolved = join5(context.projectRoot, resolved);
   }
   return resolved;
 }
 
 // src/lib/postinstall/env-vars.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync2, appendFileSync } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync3, appendFileSync } from "fs";
+import { join as join6 } from "path";
 import chalk3 from "chalk";
 async function processEnvVars(envVars) {
-  const envExamplePath = join7(process.cwd(), ".env.example");
-  const envPath = join7(process.cwd(), ".env");
+  const envExamplePath = join6(process.cwd(), ".env.example");
+  const envPath = join6(process.cwd(), ".env");
   let added = 0;
   const existingVars = /* @__PURE__ */ new Set();
-  if (existsSync7(envExamplePath)) {
+  if (existsSync6(envExamplePath)) {
     const content = readFileSync5(envExamplePath, "utf-8");
     const matches = content.match(/^[A-Z_][A-Z0-9_]*=/gm);
     if (matches) {
@@ -456,34 +449,34 @@ async function processEnvVars(envVars) {
   }
   if (newLines.length > 0) {
     const content = "\n" + newLines.join("\n");
-    if (existsSync7(envExamplePath)) {
+    if (existsSync6(envExamplePath)) {
       appendFileSync(envExamplePath, content);
     } else {
-      writeFileSync2(envExamplePath, content.trim() + "\n");
+      writeFileSync3(envExamplePath, content.trim() + "\n");
     }
     console.log(chalk3.gray(`  Added ${added} env vars to .env.example`));
   }
 }
 
 // src/lib/postinstall/migrations.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, cpSync as cpSync3 } from "fs";
-import { join as join8, basename } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, cpSync as cpSync3 } from "fs";
+import { join as join7, basename } from "path";
 import chalk4 from "chalk";
 async function registerMigrations(migrations, installedPath) {
-  const migrationsDir = join8(process.cwd(), "migrations");
-  if (!existsSync8(migrationsDir)) {
+  const migrationsDir = join7(process.cwd(), "migrations");
+  if (!existsSync7(migrationsDir)) {
     mkdirSync3(migrationsDir, { recursive: true });
   }
   let copied = 0;
   for (const migration of migrations) {
-    const sourcePath = join8(installedPath, migration);
-    if (!existsSync8(sourcePath)) {
+    const sourcePath = join7(installedPath, migration);
+    if (!existsSync7(sourcePath)) {
       console.log(chalk4.yellow(`  Warning: Migration not found: ${migration}`));
       continue;
     }
     const fileName = basename(migration);
-    const targetPath = join8(migrationsDir, fileName);
-    if (existsSync8(targetPath)) {
+    const targetPath = join7(migrationsDir, fileName);
+    if (existsSync7(targetPath)) {
       console.log(chalk4.gray(`  Migration ${fileName} already exists, skipping`));
       continue;
     }
@@ -496,12 +489,12 @@ async function registerMigrations(migrations, installedPath) {
 }
 
 // src/lib/postinstall/script-runner.ts
-import { existsSync as existsSync9 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { join as join8 } from "path";
 import chalk5 from "chalk";
 async function runCustomScript(scriptPath, installedPath, context) {
-  const fullPath = join9(installedPath, scriptPath);
-  if (!existsSync9(fullPath)) {
+  const fullPath = join8(installedPath, scriptPath);
+  if (!existsSync8(fullPath)) {
     console.log(chalk5.yellow(`  Warning: Postinstall script not found: ${scriptPath}`));
     return;
   }
@@ -516,8 +509,8 @@ async function runCustomScript(scriptPath, installedPath, context) {
 }
 
 // src/lib/postinstall/index.ts
-import { existsSync as existsSync10 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { join as join9 } from "path";
 async function runPostinstall(packageJson, installedPath, context) {
   const postinstall = packageJson.nextspark?.postinstall;
   if (!postinstall) {
@@ -534,7 +527,7 @@ async function runPostinstall(packageJson, installedPath, context) {
       if (!pluginExists) {
         console.log(`  Installing required plugin: ${plugin}`);
         context.installingPlugins.add(plugin);
-        const { addPlugin: addPlugin2 } = await import("./add-plugin-I3UJFL7U.js");
+        const { addPlugin: addPlugin2 } = await import("./add-plugin-KIJLCOEQ.js");
         await addPlugin2(plugin, { installingPlugins: context.installingPlugins });
       }
     }
@@ -578,18 +571,18 @@ async function runPostinstall(packageJson, installedPath, context) {
 }
 async function checkPluginExists(pluginName) {
   const name = pluginName.replace(/^@[^/]+\//, "").replace(/^nextspark-plugin-/, "").replace(/^plugin-/, "");
-  return existsSync10(join10(process.cwd(), "contents", "plugins", name));
+  return existsSync9(join9(process.cwd(), "contents", "plugins", name));
 }
 
 // src/lib/theme-detector.ts
-import { existsSync as existsSync11, readFileSync as readFileSync6, readdirSync as readdirSync2 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync6, readdirSync as readdirSync2 } from "fs";
+import { join as join10 } from "path";
 function detectActiveTheme() {
   if (process.env.NEXT_PUBLIC_ACTIVE_THEME) {
     return process.env.NEXT_PUBLIC_ACTIVE_THEME;
   }
-  const configPath = join11(process.cwd(), "nextspark.config.ts");
-  if (existsSync11(configPath)) {
+  const configPath = join10(process.cwd(), "nextspark.config.ts");
+  if (existsSync10(configPath)) {
     try {
       const content = readFileSync6(configPath, "utf-8");
       const match = content.match(/activeTheme\s*:\s*['"]([^'"]+)['"]/);
@@ -599,8 +592,8 @@ function detectActiveTheme() {
     } catch {
     }
   }
-  const envPath = join11(process.cwd(), ".env");
-  if (existsSync11(envPath)) {
+  const envPath = join10(process.cwd(), ".env");
+  if (existsSync10(envPath)) {
     try {
       const content = readFileSync6(envPath, "utf-8");
       const match = content.match(/NEXT_PUBLIC_ACTIVE_THEME=(.+)/);
@@ -610,8 +603,8 @@ function detectActiveTheme() {
     } catch {
     }
   }
-  const themesDir = join11(process.cwd(), "contents", "themes");
-  if (existsSync11(themesDir)) {
+  const themesDir = join10(process.cwd(), "contents", "themes");
+  if (existsSync10(themesDir)) {
     try {
       const themes = readdirSync2(themesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
       if (themes.length === 1) {
@@ -624,14 +617,14 @@ function detectActiveTheme() {
 }
 
 // src/commands/add-plugin.ts
-import { existsSync as existsSync12, readFileSync as readFileSync7 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync7 } from "fs";
+import { join as join11 } from "path";
 async function addPlugin(packageSpec, options = {}) {
   const spinner = ora(`Adding plugin ${packageSpec}`).start();
   let cleanup = null;
   try {
-    const contentsDir = join12(process.cwd(), "contents");
-    if (!existsSync12(contentsDir)) {
+    const contentsDir = join11(process.cwd(), "contents");
+    if (!existsSync11(contentsDir)) {
       spinner.fail('contents/ directory not found. Run "nextspark init" first.');
       return;
     }
@@ -680,8 +673,8 @@ async function addPlugin(packageSpec, options = {}) {
   }
 }
 function getCoreVersion() {
-  const pkgPath = join12(process.cwd(), "node_modules", "@nextsparkjs", "core", "package.json");
-  if (existsSync12(pkgPath)) {
+  const pkgPath = join11(process.cwd(), "node_modules", "@nextsparkjs", "core", "package.json");
+  if (existsSync11(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
       return pkg.version || "0.0.0";

package/dist/cli.js

@@ -7,7 +7,7 @@ import {
   installTheme,
   runPostinstall,
   validateTheme
-} from "./chunk-ALB2C27N.js";
+} from "./chunk-DXL5CEZD.js";
 
 // src/cli.ts
 import { config } from "dotenv";
@@ -1180,8 +1180,8 @@ async function runExpertPrompts() {
 
 // src/wizard/generators/index.ts
 import fs7 from "fs-extra";
-import path5 from "path";
-import { fileURLToPath as fileURLToPath5 } from "url";
+import path6 from "path";
+import { fileURLToPath as fileURLToPath6 } from "url";
 
 // src/wizard/generators/theme-renamer.ts
 import fs from "fs-extra";
@@ -2310,22 +2310,27 @@ async function installThemeAndPlugins(theme, plugins) {
 
 // src/wizard/generators/env-setup.ts
 import fs5 from "fs-extra";
+import path5 from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
+var __filename5 = fileURLToPath5(import.meta.url);
+var __dirname5 = path5.dirname(__filename5);
+var ENV_TEMPLATE_PATH = path5.resolve(__dirname5, "../../../templates/env.template");
 
 // src/wizard/generators/git-init.ts
 import fs6 from "fs-extra";
 
 // src/wizard/generators/index.ts
-var __filename5 = fileURLToPath5(import.meta.url);
-var __dirname5 = path5.dirname(__filename5);
+var __filename6 = fileURLToPath6(import.meta.url);
+var __dirname6 = path6.dirname(__filename6);
 function getTemplatesDir3() {
   try {
     const corePkgPath = __require.resolve("@nextsparkjs/core/package.json");
-    return path5.join(path5.dirname(corePkgPath), "templates");
+    return path6.join(path6.dirname(corePkgPath), "templates");
   } catch {
     const possiblePaths = [
-      path5.resolve(__dirname5, "../../../../../core/templates"),
-      path5.resolve(__dirname5, "../../../../core/templates"),
-      path5.resolve(process.cwd(), "node_modules/@nextsparkjs/core/templates")
+      path6.resolve(__dirname6, "../../../../../core/templates"),
+      path6.resolve(__dirname6, "../../../../core/templates"),
+      path6.resolve(process.cwd(), "node_modules/@nextsparkjs/core/templates")
     ];
     for (const p of possiblePaths) {
       if (fs7.existsSync(p)) {
@@ -2347,6 +2352,8 @@ async function copyProjectFiles() {
     { 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: "pnpm-workspace.yaml", dest: "pnpm-workspace.yaml", force: true },
+    // Enable workspace for themes/plugins - REQUIRED
     { 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 },
@@ -2354,8 +2361,8 @@ async function copyProjectFiles() {
     { src: "scripts/cy-run-prod.cjs", dest: "scripts/cy-run-prod.cjs", force: false }
   ];
   for (const item of itemsToCopy) {
-    const srcPath = path5.join(templatesDir, item.src);
-    const destPath = path5.join(projectDir, item.dest);
+    const srcPath = path6.join(templatesDir, item.src);
+    const destPath = path6.join(projectDir, item.dest);
     if (await fs7.pathExists(srcPath)) {
       if (item.force || !await fs7.pathExists(destPath)) {
         await fs7.copy(srcPath, destPath);
@@ -2364,7 +2371,7 @@ async function copyProjectFiles() {
   }
 }
 async function updatePackageJson(config2) {
-  const packageJsonPath = path5.resolve(process.cwd(), "package.json");
+  const packageJsonPath = path6.resolve(process.cwd(), "package.json");
   let packageJson;
   if (!await fs7.pathExists(packageJsonPath)) {
     packageJson = {
@@ -2482,7 +2489,7 @@ async function updatePackageJson(config2) {
   await fs7.writeJson(packageJsonPath, packageJson, { spaces: 2 });
 }
 async function updateGitignore(config2) {
-  const gitignorePath = path5.resolve(process.cwd(), ".gitignore");
+  const gitignorePath = path6.resolve(process.cwd(), ".gitignore");
   const entriesToAdd = `
 # NextSpark
 .nextspark/
@@ -2854,23 +2861,21 @@ async function runWizard(options = { mode: "interactive" }) {
   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);
+    if (options.theme !== void 0) {
+      selectedTheme = options.theme === "none" ? null : options.theme;
+      showInfo(`Reference theme: ${selectedTheme || "None"}`);
+    } else if (!options.preset && 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.preset && options.mode !== "quick" && !options.yes) {
+      selectedPlugins = await promptPluginsSelection(selectedTheme);
+    } else if (selectedTheme) {
+      selectedPlugins = getRequiredPlugins(selectedTheme);
     }
     let config2;
     if (options.preset) {
@@ -3320,11 +3325,11 @@ import chalk13 from "chalk";
 
 // src/doctor/checks/dependencies.ts
 import fs8 from "fs-extra";
-import path6 from "path";
+import path7 from "path";
 async function checkDependencies() {
   const cwd = process.cwd();
-  const nodeModulesPath = path6.join(cwd, "node_modules");
-  const packageJsonPath = path6.join(cwd, "package.json");
+  const nodeModulesPath = path7.join(cwd, "node_modules");
+  const packageJsonPath = path7.join(cwd, "package.json");
   if (!await fs8.pathExists(packageJsonPath)) {
     return {
       name: "Dependencies",
@@ -3360,13 +3365,13 @@ async function checkDependencies() {
   const criticalDeps = ["next", "react", "react-dom"];
   for (const dep of criticalDeps) {
     if (allDependencies[dep]) {
-      const depPath = path6.join(nodeModulesPath, dep);
+      const depPath = path7.join(nodeModulesPath, dep);
       if (!await fs8.pathExists(depPath)) {
         missingDeps.push(dep);
       }
     }
   }
-  const nextsparksCorePath = path6.join(nodeModulesPath, "@nextsparkjs", "core");
+  const nextsparksCorePath = path7.join(nodeModulesPath, "@nextsparkjs", "core");
   const hasNextSparkCore = await fs8.pathExists(nextsparksCorePath);
   if (missingDeps.length > 0) {
     return {
@@ -3393,7 +3398,7 @@ async function checkDependencies() {
 
 // src/doctor/checks/config.ts
 import fs9 from "fs-extra";
-import path7 from "path";
+import path8 from "path";
 var REQUIRED_CONFIG_FILES = [
   "next.config.ts",
   "tailwind.config.ts",
@@ -3404,10 +3409,10 @@ async function checkConfigs() {
   const missingFiles = [];
   const invalidFiles = [];
   for (const file of REQUIRED_CONFIG_FILES) {
-    const filePath = path7.join(cwd, file);
+    const filePath = path8.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 jsPath = path8.join(cwd, file.replace(".ts", ".js"));
+      const mjsPath = path8.join(cwd, file.replace(".ts", ".mjs"));
       const tsExists = await fs9.pathExists(filePath);
       const jsExists = await fs9.pathExists(jsPath);
       const mjsExists = await fs9.pathExists(mjsPath);
@@ -3422,7 +3427,7 @@ async function checkConfigs() {
       missingFiles.push(file);
     }
   }
-  const tsconfigPath = path7.join(cwd, "tsconfig.json");
+  const tsconfigPath = path8.join(cwd, "tsconfig.json");
   if (await fs9.pathExists(tsconfigPath)) {
     try {
       const content = await fs9.readFile(tsconfigPath, "utf-8");
@@ -3433,12 +3438,12 @@ async function checkConfigs() {
   } else {
     missingFiles.push("tsconfig.json");
   }
-  const configDir = path7.join(cwd, "config");
+  const configDir = path8.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);
+      const filePath = path8.join(configDir, file);
       try {
         const content = await fs9.readFile(filePath, "utf-8");
         if (content.trim().length === 0) {
@@ -3474,7 +3479,7 @@ async function checkConfigs() {
 
 // src/doctor/checks/database.ts
 import fs10 from "fs-extra";
-import path8 from "path";
+import path9 from "path";
 function parseEnvFile(content) {
   const result = {};
   const lines = content.split("\n");
@@ -3497,8 +3502,8 @@ function parseEnvFile(content) {
 }
 async function checkDatabase() {
   const cwd = process.cwd();
-  const envPath = path8.join(cwd, ".env");
-  const envLocalPath = path8.join(cwd, ".env.local");
+  const envPath = path9.join(cwd, ".env");
+  const envLocalPath = path9.join(cwd, ".env.local");
   let envVars = {};
   if (await fs10.pathExists(envLocalPath)) {
     try {
@@ -3557,20 +3562,20 @@ async function checkDatabase() {
 
 // src/doctor/checks/imports.ts
 import fs11 from "fs-extra";
-import path9 from "path";
+import path10 from "path";
 async function checkCorePackage(cwd) {
-  const nodeModulesPath = path9.join(cwd, "node_modules", "@nextsparkjs", "core");
+  const nodeModulesPath = path10.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");
+  const packageJsonPath = path10.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);
+    const mainPath = path10.join(nodeModulesPath, mainEntry);
     if (!await fs11.pathExists(mainPath)) {
       return { accessible: false, reason: "@nextsparkjs/core entry point not found" };
     }
@@ -3584,7 +3589,7 @@ async function scanForBrokenImports(cwd) {
   const srcDirs = ["src", "app", "pages", "components", "lib"];
   const existingDirs = [];
   for (const dir of srcDirs) {
-    const dirPath = path9.join(cwd, dir);
+    const dirPath = path10.join(cwd, dir);
     if (await fs11.pathExists(dirPath)) {
       existingDirs.push(dirPath);
     }
@@ -3598,7 +3603,7 @@ async function scanForBrokenImports(cwd) {
       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);
+          const filePath = path10.join(dir, file.name);
           try {
             const content = await fs11.readFile(filePath, "utf-8");
             const importMatches = content.match(/from ['"](@?[^'"]+)['"]/g);
@@ -3606,16 +3611,16 @@ async function scanForBrokenImports(cwd) {
               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 absoluteImportPath = path10.resolve(path10.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")
+                    path10.join(absoluteImportPath, "index.ts"),
+                    path10.join(absoluteImportPath, "index.tsx"),
+                    path10.join(absoluteImportPath, "index.js")
                   ];
                   const exists = await Promise.any(
                     possiblePaths.map(async (p) => {
@@ -3643,7 +3648,7 @@ async function checkImports() {
   const cwd = process.cwd();
   const coreCheck = await checkCorePackage(cwd);
   if (!coreCheck.accessible) {
-    const packageJsonPath = path9.join(cwd, "package.json");
+    const packageJsonPath = path10.join(cwd, "package.json");
     let hasCoreDep = false;
     if (await fs11.pathExists(packageJsonPath)) {
       try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextsparkjs/cli",
-  "version": "0.1.0-beta.69",
+  "version": "0.1.0-beta.70",
   "description": "NextSpark CLI - Complete development toolkit",
   "type": "module",
   "bin": {
@@ -13,10 +13,6 @@
     "bin",
     "templates"
   ],
-  "scripts": {
-    "build": "tsup src/cli.ts --format esm --dts --outDir dist",
-    "dev": "tsup src/cli.ts --format esm --watch"
-  },
   "dependencies": {
     "@inquirer/prompts": "^7.2.0",
     "@nextsparkjs/core": "^0.1.0-beta.54",
@@ -28,12 +24,12 @@
     "tar": "^7.0.0"
   },
   "devDependencies": {
-    "@nextsparkjs/core": "workspace:*",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^20.0.0",
     "@types/tar": "^6.1.0",
     "tsup": "^8.0.0",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "@nextsparkjs/core": "0.1.0-beta.50"
   },
   "keywords": [
     "nextspark",
@@ -50,5 +46,9 @@
   },
   "engines": {
     "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/cli.ts --format esm --dts --outDir dist",
+    "dev": "tsup src/cli.ts --format esm --watch"
   }
-}
+}