@nextsparkjs/cli 0.1.0-beta.2 → 0.1.0-beta.4

package/dist/chunk-ALB2C27N.js

@@ -0,0 +1,712 @@
+var __require = /* @__PURE__ */ ((x2) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x2, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x2)(function(x2) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x2 + '" is not supported');
+});
+
+// src/commands/add-plugin.ts
+import chalk7 from "chalk";
+import ora from "ora";
+
+// src/lib/package-fetcher.ts
+import { execSync } from "child_process";
+import { mkdtempSync, readdirSync, rmSync, existsSync, readFileSync, copyFileSync } from "fs";
+import { tmpdir } from "os";
+import { join, isAbsolute } from "path";
+import * as tar from "tar";
+async function fetchPackage(packageSpec, version) {
+  if (packageSpec.endsWith(".tgz") || packageSpec.startsWith("./") || packageSpec.startsWith("/") || isAbsolute(packageSpec)) {
+    return fetchLocalPackage(packageSpec);
+  }
+  return fetchNpmPackage(packageSpec, version);
+}
+async function fetchLocalPackage(filePath) {
+  const absolutePath = isAbsolute(filePath) ? filePath : join(process.cwd(), filePath);
+  if (!existsSync(absolutePath)) {
+    throw new Error(`Local package not found: ${absolutePath}`);
+  }
+  const tempDir = mkdtempSync(join(tmpdir(), "nextspark-add-"));
+  try {
+    const tgzPath = join(tempDir, "package.tgz");
+    copyFileSync(absolutePath, tgzPath);
+    await tar.x({
+      file: tgzPath,
+      cwd: tempDir
+    });
+    const extractedPath = join(tempDir, "package");
+    const packageJson = JSON.parse(
+      readFileSync(join(extractedPath, "package.json"), "utf-8")
+    );
+    return {
+      packageJson,
+      extractedPath,
+      cleanup: () => rmSync(tempDir, { recursive: true, force: true })
+    };
+  } catch (error) {
+    rmSync(tempDir, { recursive: true, force: true });
+    throw error;
+  }
+}
+async function fetchNpmPackage(packageName, version) {
+  const spec = version ? `${packageName}@${version}` : packageName;
+  const tempDir = mkdtempSync(join(tmpdir(), "nextspark-add-"));
+  try {
+    console.log(`  Downloading ${spec}...`);
+    execSync(`npm pack ${spec} --pack-destination "${tempDir}"`, {
+      stdio: "pipe",
+      encoding: "utf-8"
+    });
+    const tgzFile = readdirSync(tempDir).find((f) => f.endsWith(".tgz"));
+    if (!tgzFile) {
+      throw new Error(`Failed to download package: ${spec}`);
+    }
+    await tar.x({
+      file: join(tempDir, tgzFile),
+      cwd: tempDir
+    });
+    const extractedPath = join(tempDir, "package");
+    if (!existsSync(extractedPath)) {
+      throw new Error(`Package extraction failed for: ${spec}`);
+    }
+    const packageJson = JSON.parse(
+      readFileSync(join(extractedPath, "package.json"), "utf-8")
+    );
+    return {
+      packageJson,
+      extractedPath,
+      cleanup: () => rmSync(tempDir, { recursive: true, force: true })
+    };
+  } catch (error) {
+    rmSync(tempDir, { recursive: true, force: true });
+    if (error instanceof Error) {
+      if (error.message.includes("404") || error.message.includes("not found")) {
+        throw new Error(`Package not found: ${spec}. Verify the package name exists on npm.`);
+      }
+      if (error.message.includes("ENETUNREACH") || error.message.includes("ENOTFOUND")) {
+        throw new Error(`Network error. Check your internet connection.`);
+      }
+    }
+    throw error;
+  }
+}
+
+// src/lib/validator.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+function validatePlugin(packageJson, extractedPath) {
+  const errors = [];
+  const warnings = [];
+  const peerDepIssues = [];
+  if (!existsSync2(join2(extractedPath, "plugin.config.ts"))) {
+    errors.push("Missing plugin.config.ts - not a valid NextSpark plugin");
+  }
+  if (!packageJson.nextspark) {
+    warnings.push("Missing nextspark field in package.json (recommended)");
+  } else if (packageJson.nextspark.type !== "plugin") {
+    warnings.push(`nextspark.type is "${packageJson.nextspark.type}", expected "plugin"`);
+  }
+  const peerDeps = packageJson.peerDependencies || {};
+  if (!peerDeps["@nextsparkjs/core"]) {
+    warnings.push("Plugin should have @nextsparkjs/core as peerDependency");
+  }
+  const projectPkgPath = join2(process.cwd(), "package.json");
+  if (existsSync2(projectPkgPath)) {
+    const projectPkg = JSON.parse(readFileSync2(projectPkgPath, "utf-8"));
+    const projectDeps = {
+      ...projectPkg.dependencies,
+      ...projectPkg.devDependencies
+    };
+    for (const [name, required] of Object.entries(peerDeps)) {
+      const installed = projectDeps[name];
+      if (!installed) {
+        peerDepIssues.push({
+          name,
+          required,
+          installed: null,
+          severity: "warning"
+        });
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    peerDepIssues
+  };
+}
+function validateTheme(packageJson, extractedPath) {
+  const errors = [];
+  const warnings = [];
+  const peerDepIssues = [];
+  const configPath = join2(extractedPath, "config", "theme.config.ts");
+  if (!existsSync2(configPath)) {
+    errors.push("Missing config/theme.config.ts - not a valid NextSpark theme");
+  }
+  if (!packageJson.nextspark) {
+    warnings.push("Missing nextspark field in package.json (recommended)");
+  } else if (packageJson.nextspark.type !== "theme") {
+    warnings.push(`nextspark.type is "${packageJson.nextspark.type}", expected "theme"`);
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    peerDepIssues
+  };
+}
+
+// src/lib/installer.ts
+import { existsSync as existsSync5, cpSync, rmSync as rmSync2, mkdirSync } from "fs";
+import { join as join5 } 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";
+async function updateTsConfig(name, type) {
+  const tsconfigPath = join4(process.cwd(), "tsconfig.json");
+  if (!existsSync4(tsconfigPath)) {
+    console.log("  Warning: tsconfig.json not found, skipping path update");
+    return;
+  }
+  try {
+    const content = readFileSync4(tsconfigPath, "utf-8");
+    const tsconfig = JSON.parse(content);
+    if (!tsconfig.compilerOptions) {
+      tsconfig.compilerOptions = {};
+    }
+    if (!tsconfig.compilerOptions.paths) {
+      tsconfig.compilerOptions.paths = {};
+    }
+    const pathKey = type === "plugin" ? `@plugins/${name}/*` : `@themes/${name}/*`;
+    const pathValue = type === "plugin" ? [`./contents/plugins/${name}/*`] : [`./contents/themes/${name}/*`];
+    if (!tsconfig.compilerOptions.paths[pathKey]) {
+      tsconfig.compilerOptions.paths[pathKey] = pathValue;
+      writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2) + "\n");
+      console.log(`  Updated tsconfig.json with ${pathKey} path`);
+    }
+  } catch (error) {
+    console.log("  Warning: Could not update tsconfig.json");
+  }
+}
+async function registerInPackageJson(npmName, version, type) {
+  const pkgPath = join4(process.cwd(), "package.json");
+  if (!existsSync4(pkgPath)) {
+    console.log("  Warning: package.json not found, skipping registration");
+    return;
+  }
+  try {
+    const content = readFileSync4(pkgPath, "utf-8");
+    const pkg = JSON.parse(content);
+    if (!pkg.nextspark) {
+      pkg.nextspark = {};
+    }
+    const key = type === "plugin" ? "plugins" : "themes";
+    if (!pkg.nextspark[key]) {
+      pkg.nextspark[key] = [];
+    }
+    const entry = { name: npmName, version };
+    const existingIndex = pkg.nextspark[key].findIndex(
+      (e) => e.name === npmName
+    );
+    if (existingIndex >= 0) {
+      pkg.nextspark[key][existingIndex] = entry;
+    } else {
+      pkg.nextspark[key].push(entry);
+    }
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+    console.log(`  Registered ${type} in package.json`);
+  } catch (error) {
+    console.log("  Warning: Could not update package.json");
+  }
+}
+
+// src/lib/installer.ts
+async function installPlugin(extractedPath, packageJson, options = {}) {
+  const pluginName = extractPluginName(packageJson.name);
+  const targetDir = join5(process.cwd(), "contents", "plugins", pluginName);
+  if (options.dryRun) {
+    console.log(chalk.cyan("\n  [Dry Run] Would perform:"));
+    console.log(`    - Copy to: contents/plugins/${pluginName}/`);
+    if (packageJson.dependencies && Object.keys(packageJson.dependencies).length > 0) {
+      console.log(`    - Install deps: ${Object.keys(packageJson.dependencies).join(", ")}`);
+    }
+    console.log(`    - Update tsconfig.json paths`);
+    console.log(`    - Register in package.json`);
+    return { success: true, installedPath: targetDir, name: pluginName };
+  }
+  if (existsSync5(targetDir)) {
+    if (!options.force) {
+      throw new Error(
+        `Plugin "${pluginName}" already exists at ${targetDir}.
+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)) {
+    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);
+    }
+  }
+  await updateTsConfig(pluginName, "plugin");
+  await registerInPackageJson(packageJson.name, packageJson.version || "0.0.0", "plugin");
+  return {
+    success: true,
+    installedPath: targetDir,
+    name: pluginName
+  };
+}
+async function installTheme(extractedPath, packageJson, options = {}) {
+  const themeName = extractThemeName(packageJson.name);
+  const targetDir = join5(process.cwd(), "contents", "themes", themeName);
+  if (options.dryRun) {
+    console.log(chalk.cyan("\n  [Dry Run] Would perform:"));
+    console.log(`    - Copy to: contents/themes/${themeName}/`);
+    if (packageJson.requiredPlugins?.length) {
+      console.log(`    - Install required plugins: ${packageJson.requiredPlugins.join(", ")}`);
+    }
+    console.log(`    - Update tsconfig.json paths`);
+    console.log(`    - Register in package.json`);
+    return { success: true, installedPath: targetDir, name: themeName };
+  }
+  if (existsSync5(targetDir)) {
+    if (!options.force) {
+      throw new Error(
+        `Theme "${themeName}" already exists at ${targetDir}.
+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)) {
+    mkdirSync(themesDir, { recursive: true });
+  }
+  console.log(`  Copying to contents/themes/${themeName}/...`);
+  cpSync(extractedPath, targetDir, { recursive: true });
+  await updateTsConfig(themeName, "theme");
+  await registerInPackageJson(packageJson.name, packageJson.version || "0.0.0", "theme");
+  return {
+    success: true,
+    installedPath: targetDir,
+    name: themeName
+  };
+}
+function extractPluginName(npmName) {
+  return npmName.replace(/^@[^/]+\//, "").replace(/^nextspark-plugin-/, "").replace(/^plugin-/, "");
+}
+function extractThemeName(npmName) {
+  return npmName.replace(/^@[^/]+\//, "").replace(/^nextspark-theme-/, "").replace(/^theme-/, "");
+}
+
+// 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 chalk2 from "chalk";
+async function processTemplates(templates, sourcePath, context) {
+  for (const template of templates) {
+    const from = join6(sourcePath, template.from);
+    const to = resolveVariables(template.to, context);
+    if (!existsSync6(from)) {
+      console.log(chalk2.yellow(`  Warning: Template source not found: ${template.from}`));
+      continue;
+    }
+    const targetExists = existsSync6(to);
+    const condition = template.condition || "!exists";
+    const desc = template.description || template.to;
+    switch (condition) {
+      case "!exists":
+        if (targetExists) {
+          console.log(chalk2.gray(`  Skipping ${desc} (already exists)`));
+          continue;
+        }
+        break;
+      case "exists":
+        if (!targetExists) {
+          console.log(chalk2.gray(`  Skipping ${desc} (target doesn't exist)`));
+          continue;
+        }
+        break;
+      case "prompt":
+        if (targetExists) {
+          console.log(chalk2.gray(`  Skipping ${desc} (already exists, use --force to overwrite)`));
+          continue;
+        }
+        break;
+      case "always":
+        break;
+    }
+    const parentDir = dirname(to);
+    if (!existsSync6(parentDir)) {
+      mkdirSync2(parentDir, { recursive: true });
+    }
+    console.log(chalk2.gray(`  Copying ${desc}...`));
+    cpSync2(from, to, { recursive: true });
+  }
+}
+function resolveVariables(path, context) {
+  let resolved = path;
+  if (context.activeTheme) {
+    resolved = resolved.replace(/\$\{activeTheme\}/g, context.activeTheme);
+  }
+  resolved = resolved.replace(/\$\{projectRoot\}/g, context.projectRoot);
+  resolved = resolved.replace(/\$\{timestamp\}/g, context.timestamp.toString());
+  resolved = resolved.replace(/\$\{coreVersion\}/g, context.coreVersion);
+  if (context.pluginName) {
+    resolved = resolved.replace(/\$\{pluginName\}/g, context.pluginName);
+  }
+  if (context.themeName) {
+    resolved = resolved.replace(/\$\{themeName\}/g, context.themeName);
+  }
+  const unresolvedMatch = resolved.match(/\$\{([^}]+)\}/);
+  if (unresolvedMatch) {
+    throw new Error(`Unresolved template variable: ${unresolvedMatch[0]}`);
+  }
+  if (!resolved.startsWith("/")) {
+    resolved = join6(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 chalk3 from "chalk";
+async function processEnvVars(envVars) {
+  const envExamplePath = join7(process.cwd(), ".env.example");
+  const envPath = join7(process.cwd(), ".env");
+  let added = 0;
+  const existingVars = /* @__PURE__ */ new Set();
+  if (existsSync7(envExamplePath)) {
+    const content = readFileSync5(envExamplePath, "utf-8");
+    const matches = content.match(/^[A-Z_][A-Z0-9_]*=/gm);
+    if (matches) {
+      matches.forEach((m) => existingVars.add(m.replace("=", "")));
+    }
+  }
+  const newLines = [];
+  for (const envVar of envVars) {
+    if (existingVars.has(envVar.key)) {
+      continue;
+    }
+    const value = envVar.default || "";
+    const requiredMark = envVar.required ? " (required)" : "";
+    newLines.push(`# ${envVar.description}${requiredMark}`);
+    newLines.push(`${envVar.key}=${value}`);
+    newLines.push("");
+    added++;
+  }
+  if (newLines.length > 0) {
+    const content = "\n" + newLines.join("\n");
+    if (existsSync7(envExamplePath)) {
+      appendFileSync(envExamplePath, content);
+    } else {
+      writeFileSync2(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 chalk4 from "chalk";
+async function registerMigrations(migrations, installedPath) {
+  const migrationsDir = join8(process.cwd(), "migrations");
+  if (!existsSync8(migrationsDir)) {
+    mkdirSync3(migrationsDir, { recursive: true });
+  }
+  let copied = 0;
+  for (const migration of migrations) {
+    const sourcePath = join8(installedPath, migration);
+    if (!existsSync8(sourcePath)) {
+      console.log(chalk4.yellow(`  Warning: Migration not found: ${migration}`));
+      continue;
+    }
+    const fileName = basename(migration);
+    const targetPath = join8(migrationsDir, fileName);
+    if (existsSync8(targetPath)) {
+      console.log(chalk4.gray(`  Migration ${fileName} already exists, skipping`));
+      continue;
+    }
+    cpSync3(sourcePath, targetPath);
+    copied++;
+  }
+  if (copied > 0) {
+    console.log(chalk4.gray(`  Copied ${copied} migration(s) to /migrations`));
+  }
+}
+
+// src/lib/postinstall/script-runner.ts
+import { existsSync as existsSync9 } from "fs";
+import { join as join9 } from "path";
+import chalk5 from "chalk";
+async function runCustomScript(scriptPath, installedPath, context) {
+  const fullPath = join9(installedPath, scriptPath);
+  if (!existsSync9(fullPath)) {
+    console.log(chalk5.yellow(`  Warning: Postinstall script not found: ${scriptPath}`));
+    return;
+  }
+  console.log("");
+  console.log(chalk5.yellow("  Warning: This package wants to run a custom postinstall script:"));
+  console.log(chalk5.gray(`     ${scriptPath}`));
+  console.log("");
+  console.log(chalk5.gray("  Custom scripts can execute arbitrary code."));
+  console.log(chalk5.gray("  Only allow if you trust the package author."));
+  console.log(chalk5.gray("  Skipping script execution (manual approval required)."));
+  console.log("");
+}
+
+// src/lib/postinstall/index.ts
+import { existsSync as existsSync10 } from "fs";
+import { join as join10 } from "path";
+async function runPostinstall(packageJson, installedPath, context) {
+  const postinstall = packageJson.nextspark?.postinstall;
+  if (!postinstall) {
+    return;
+  }
+  console.log(chalk6.blue("\n  Running postinstall hooks..."));
+  if (postinstall.requiredPlugins?.length) {
+    for (const plugin of postinstall.requiredPlugins) {
+      if (context.installingPlugins.has(plugin)) {
+        console.log(chalk6.yellow(`  Skipping ${plugin} (already being installed)`));
+        continue;
+      }
+      const pluginExists = await checkPluginExists(plugin);
+      if (!pluginExists) {
+        console.log(`  Installing required plugin: ${plugin}`);
+        context.installingPlugins.add(plugin);
+        const { addPlugin: addPlugin2 } = await import("./add-plugin-I3UJFL7U.js");
+        await addPlugin2(plugin, { installingPlugins: context.installingPlugins });
+      }
+    }
+  }
+  if (postinstall.templates?.length) {
+    const needsTheme = postinstall.templates.some(
+      (t) => t.to.includes("${activeTheme}")
+    );
+    if (needsTheme && !context.activeTheme) {
+      console.log(chalk6.yellow("\n  Warning: Templates require an active theme but none detected."));
+      console.log(chalk6.gray("  Set NEXT_PUBLIC_ACTIVE_THEME or install a theme first."));
+      console.log(chalk6.gray("  Skipping template installation.\n"));
+    } else {
+      await processTemplates(postinstall.templates, installedPath, context);
+    }
+  }
+  if (postinstall.envVars?.length) {
+    await processEnvVars(postinstall.envVars);
+  }
+  if (postinstall.migrations?.length) {
+    await registerMigrations(postinstall.migrations, installedPath);
+  }
+  if (postinstall.script) {
+    await runCustomScript(postinstall.script, installedPath, context);
+  }
+  if (postinstall.messages) {
+    console.log("");
+    if (postinstall.messages.success) {
+      console.log(chalk6.green(`  ${postinstall.messages.success}`));
+    }
+    if (postinstall.messages.docs) {
+      console.log(chalk6.gray(`  Docs: ${postinstall.messages.docs}`));
+    }
+    if (postinstall.messages.nextSteps?.length) {
+      console.log(chalk6.blue("\n  Next steps:"));
+      postinstall.messages.nextSteps.forEach((step, i) => {
+        console.log(chalk6.gray(`    ${i + 1}. ${step}`));
+      });
+    }
+  }
+}
+async function checkPluginExists(pluginName) {
+  const name = pluginName.replace(/^@[^/]+\//, "").replace(/^nextspark-plugin-/, "").replace(/^plugin-/, "");
+  return existsSync10(join10(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";
+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)) {
+    try {
+      const content = readFileSync6(configPath, "utf-8");
+      const match = content.match(/activeTheme\s*:\s*['"]([^'"]+)['"]/);
+      if (match) {
+        return match[1];
+      }
+    } catch {
+    }
+  }
+  const envPath = join11(process.cwd(), ".env");
+  if (existsSync11(envPath)) {
+    try {
+      const content = readFileSync6(envPath, "utf-8");
+      const match = content.match(/NEXT_PUBLIC_ACTIVE_THEME=(.+)/);
+      if (match) {
+        return match[1].trim();
+      }
+    } catch {
+    }
+  }
+  const themesDir = join11(process.cwd(), "contents", "themes");
+  if (existsSync11(themesDir)) {
+    try {
+      const themes = readdirSync2(themesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      if (themes.length === 1) {
+        return themes[0];
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/commands/add-plugin.ts
+import { existsSync as existsSync12, readFileSync as readFileSync7 } from "fs";
+import { join as join12 } 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)) {
+      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 plugin...";
+    const validation = validatePlugin(packageJson, extractedPath);
+    if (!validation.valid) {
+      spinner.fail("Invalid plugin");
+      validation.errors.forEach((e) => console.log(chalk7.red(`  \u2717 ${e}`)));
+      return;
+    }
+    if (validation.warnings.length > 0) {
+      validation.warnings.forEach((w) => console.log(chalk7.yellow(`  \u26A0 ${w}`)));
+    }
+    spinner.text = "Installing plugin...";
+    spinner.stop();
+    const result = await installPlugin(extractedPath, packageJson, options);
+    if (!options.skipPostinstall) {
+      const coreVersion = getCoreVersion();
+      const context = {
+        activeTheme: detectActiveTheme(),
+        projectRoot: process.cwd(),
+        pluginName: result.name,
+        coreVersion,
+        timestamp: Date.now(),
+        installingPlugins: options.installingPlugins || /* @__PURE__ */ new Set([packageSpec])
+      };
+      await runPostinstall(packageJson, result.installedPath, context);
+    }
+    console.log(chalk7.green(`
+  \u2713 Plugin ${result.name} installed successfully!`));
+    console.log(chalk7.gray(`    Location: contents/plugins/${result.name}/`));
+  } catch (error) {
+    spinner.fail("Failed to add plugin");
+    if (error instanceof Error) {
+      console.log(chalk7.red(`  ${error.message}`));
+    }
+    throw error;
+  } finally {
+    if (cleanup) cleanup();
+  }
+}
+function getCoreVersion() {
+  const pkgPath = join12(process.cwd(), "node_modules", "@nextsparkjs", "core", "package.json");
+  if (existsSync12(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
+      return pkg.version || "0.0.0";
+    } catch {
+      return "0.0.0";
+    }
+  }
+  return "0.0.0";
+}
+function addPluginCommand(packageSpec, options) {
+  return addPlugin(packageSpec, {
+    force: options.force,
+    skipDeps: options.noDeps,
+    dryRun: options.dryRun,
+    skipPostinstall: options.skipPostinstall,
+    version: options.version
+  });
+}
+
+export {
+  __require,
+  fetchPackage,
+  validateTheme,
+  installTheme,
+  addPlugin,
+  addPluginCommand,
+  runPostinstall
+};