@nextsparkjs/cli 0.1.0-beta.7 → 0.1.0-beta.71

package/bin/nextspark.js

@@ -1,3 +1,12 @@
 #!/usr/bin/env node
 
+// Check Node.js version before importing anything
+const nodeVersion = parseInt(process.versions.node.split('.')[0], 10);
+if (nodeVersion < 18) {
+  console.error('\x1b[31m✗ NextSpark requires Node.js 18 or higher\x1b[0m');
+  console.error(`  Current version: ${process.versions.node}`);
+  console.error('  Please upgrade Node.js: https://nodejs.org/');
+  process.exit(1);
+}
+
 import '../dist/cli.js';

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

@@ -1,7 +1,7 @@
 import {
   addPlugin,
   addPluginCommand
-} from "./chunk-EE6EJYHE.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";