@nextsparkjs/cli 0.1.0-beta.1

package/README.md

@@ -0,0 +1,32 @@
+# @nextsparkjs/cli
+
+CLI tool for NextSpark development workflow.
+
+## Installation
+
+```bash
+npm install -g @nextsparkjs/cli
+# or use with npx
+npx @nextsparkjs/cli <command>
+```
+
+## Commands
+
+```bash
+nextspark init        # Initialize NextSpark in an existing Next.js project
+nextspark migrate     # Run database migrations
+nextspark registry    # Build component registries
+```
+
+## Requirements
+
+- Node.js 18+
+- @nextsparkjs/core installed in your project
+
+## Documentation
+
+Visit [nextspark.dev/docs](https://nextspark.dev/docs) for full documentation.
+
+## License
+
+MIT

package/bin/nextspark.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import '../dist/cli.js';

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,464 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import chalk6 from "chalk";
+
+// src/commands/dev.ts
+import { spawn } from "child_process";
+import chalk from "chalk";
+import ora from "ora";
+
+// src/utils/paths.ts
+import { existsSync } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function getCoreDir() {
+  const cwd = process.cwd();
+  const npmCorePath = resolve(cwd, "node_modules", "@nextsparkjs", "core");
+  if (existsSync(npmCorePath)) {
+    return npmCorePath;
+  }
+  const monorepoCorePath = resolve(__dirname, "..", "..", "..", "..", "core");
+  if (existsSync(monorepoCorePath)) {
+    return monorepoCorePath;
+  }
+  const cwdMonorepoCorePath = resolve(cwd, "..", "..", "packages", "core");
+  if (existsSync(cwdMonorepoCorePath)) {
+    return cwdMonorepoCorePath;
+  }
+  throw new Error(
+    "Could not find @nextsparkjs/core. Make sure it is installed as a dependency or you are running from within the monorepo."
+  );
+}
+function getProjectRoot() {
+  return process.cwd();
+}
+function isMonorepoMode() {
+  const cwd = process.cwd();
+  const npmCorePath = resolve(cwd, "node_modules", "@nextsparkjs", "core");
+  return !existsSync(npmCorePath);
+}
+
+// src/commands/dev.ts
+async function devCommand(options) {
+  const spinner = ora("Starting development environment...").start();
+  try {
+    const coreDir = getCoreDir();
+    const projectRoot = getProjectRoot();
+    const mode = isMonorepoMode() ? "monorepo" : "npm";
+    spinner.succeed(`Core found at: ${coreDir} (${mode} mode)`);
+    const processes = [];
+    if (options.registry) {
+      console.log(chalk.blue("\n[Registry] Starting registry watcher..."));
+      const registryProcess = spawn("node", ["scripts/registry-watch.js"], {
+        cwd: coreDir,
+        stdio: "inherit",
+        env: {
+          ...process.env,
+          NEXTSPARK_PROJECT_ROOT: projectRoot
+        }
+      });
+      processes.push(registryProcess);
+      registryProcess.on("error", (err) => {
+        console.error(chalk.red(`[Registry] Error: ${err.message}`));
+      });
+    }
+    console.log(chalk.green(`
+[Dev] Starting Next.js dev server on port ${options.port}...`));
+    const devProcess = spawn("npx", ["next", "dev", "-p", options.port], {
+      cwd: projectRoot,
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        NEXTSPARK_CORE_DIR: coreDir
+      }
+    });
+    processes.push(devProcess);
+    devProcess.on("error", (err) => {
+      console.error(chalk.red(`[Dev] Error: ${err.message}`));
+      process.exit(1);
+    });
+    const cleanup = () => {
+      console.log(chalk.yellow("\nShutting down..."));
+      processes.forEach((p) => {
+        if (!p.killed) {
+          p.kill("SIGTERM");
+        }
+      });
+      process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    devProcess.on("exit", (code) => {
+      cleanup();
+      process.exit(code ?? 0);
+    });
+  } catch (error) {
+    spinner.fail("Failed to start development environment");
+    if (error instanceof Error) {
+      console.error(chalk.red(error.message));
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/build.ts
+import { spawn as spawn2 } from "child_process";
+import chalk2 from "chalk";
+import ora2 from "ora";
+async function buildCommand(options) {
+  const spinner = ora2("Preparing production build...").start();
+  try {
+    const coreDir = getCoreDir();
+    const projectRoot = getProjectRoot();
+    spinner.succeed("Core package found");
+    if (options.registry) {
+      spinner.start("Generating registries...");
+      await new Promise((resolve2, reject) => {
+        const registryProcess = spawn2("node", ["scripts/registry-build.js"], {
+          cwd: coreDir,
+          stdio: "pipe",
+          env: {
+            ...process.env,
+            NEXTSPARK_PROJECT_ROOT: projectRoot
+          }
+        });
+        let stderr = "";
+        registryProcess.stderr?.on("data", (data) => {
+          stderr += data.toString();
+        });
+        registryProcess.on("close", (code) => {
+          if (code === 0) {
+            resolve2();
+          } else {
+            reject(new Error(`Registry generation failed: ${stderr}`));
+          }
+        });
+        registryProcess.on("error", reject);
+      });
+      spinner.succeed("Registries generated");
+    }
+    spinner.start("Building for production...");
+    const buildProcess = spawn2("npx", ["next", "build"], {
+      cwd: projectRoot,
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        NEXTSPARK_CORE_DIR: coreDir,
+        NODE_ENV: "production"
+      }
+    });
+    buildProcess.on("error", (err) => {
+      spinner.fail("Build failed");
+      console.error(chalk2.red(err.message));
+      process.exit(1);
+    });
+    buildProcess.on("close", (code) => {
+      if (code === 0) {
+        console.log(chalk2.green("\nBuild completed successfully!"));
+        process.exit(0);
+      } else {
+        console.error(chalk2.red(`
+Build failed with exit code ${code}`));
+        process.exit(code ?? 1);
+      }
+    });
+  } catch (error) {
+    spinner.fail("Build preparation failed");
+    if (error instanceof Error) {
+      console.error(chalk2.red(error.message));
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/generate.ts
+import { spawn as spawn3 } from "child_process";
+import chalk3 from "chalk";
+import ora3 from "ora";
+async function generateCommand(options) {
+  const spinner = ora3("Preparing registry generation...").start();
+  try {
+    const coreDir = getCoreDir();
+    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 action = options.watch ? "Watching" : "Generating";
+    console.log(chalk3.blue(`
+${action} registries...`));
+    const generateProcess = spawn3("node", [`scripts/${scriptName}`], {
+      cwd: coreDir,
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        NEXTSPARK_PROJECT_ROOT: projectRoot
+      }
+    });
+    generateProcess.on("error", (err) => {
+      console.error(chalk3.red(`Error: ${err.message}`));
+      process.exit(1);
+    });
+    generateProcess.on("close", (code) => {
+      if (code === 0) {
+        if (!options.watch) {
+          console.log(chalk3.green("\nRegistry generation completed!"));
+        }
+        process.exit(0);
+      } else {
+        console.error(chalk3.red(`
+Registry generation failed with exit code ${code}`));
+        process.exit(code ?? 1);
+      }
+    });
+    if (options.watch) {
+      const cleanup = () => {
+        console.log(chalk3.yellow("\nStopping watcher..."));
+        if (!generateProcess.killed) {
+          generateProcess.kill("SIGTERM");
+        }
+        process.exit(0);
+      };
+      process.on("SIGINT", cleanup);
+      process.on("SIGTERM", cleanup);
+    }
+  } catch (error) {
+    spinner.fail("Registry generation failed");
+    if (error instanceof Error) {
+      console.error(chalk3.red(error.message));
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/registry.ts
+import { spawn as spawn4 } from "child_process";
+import chalk4 from "chalk";
+import ora4 from "ora";
+async function registryBuildCommand() {
+  const spinner = ora4("Building registries...").start();
+  try {
+    const coreDir = getCoreDir();
+    const projectRoot = getProjectRoot();
+    const mode = isMonorepoMode() ? "monorepo" : "npm";
+    spinner.text = `Building registries (${mode} mode)...`;
+    const buildProcess = spawn4("node", ["scripts/registry-build.js"], {
+      cwd: coreDir,
+      stdio: "pipe",
+      env: {
+        ...process.env,
+        NEXTSPARK_PROJECT_ROOT: projectRoot
+      }
+    });
+    let stdout = "";
+    let stderr = "";
+    buildProcess.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    buildProcess.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    buildProcess.on("close", (code) => {
+      if (code === 0) {
+        spinner.succeed("Registries built successfully");
+        if (stdout.trim()) {
+          console.log(chalk4.gray(stdout.trim()));
+        }
+        process.exit(0);
+      } else {
+        spinner.fail("Registry build failed");
+        if (stderr.trim()) {
+          console.error(chalk4.red(stderr.trim()));
+        }
+        process.exit(code ?? 1);
+      }
+    });
+    buildProcess.on("error", (err) => {
+      spinner.fail("Registry build failed");
+      console.error(chalk4.red(err.message));
+      process.exit(1);
+    });
+  } catch (error) {
+    spinner.fail("Registry build failed");
+    if (error instanceof Error) {
+      console.error(chalk4.red(error.message));
+    }
+    process.exit(1);
+  }
+}
+async function registryWatchCommand() {
+  const spinner = ora4("Starting registry watcher...").start();
+  try {
+    const coreDir = getCoreDir();
+    const projectRoot = getProjectRoot();
+    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"], {
+      cwd: coreDir,
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        NEXTSPARK_PROJECT_ROOT: projectRoot
+      }
+    });
+    watchProcess.on("error", (err) => {
+      console.error(chalk4.red(`Watcher error: ${err.message}`));
+      process.exit(1);
+    });
+    const cleanup = () => {
+      console.log(chalk4.yellow("\nStopping registry watcher..."));
+      if (!watchProcess.killed) {
+        watchProcess.kill("SIGTERM");
+      }
+      process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    watchProcess.on("close", (code) => {
+      if (code !== 0) {
+        console.error(chalk4.red(`
+Watcher exited with code ${code}`));
+      }
+      process.exit(code ?? 0);
+    });
+  } catch (error) {
+    spinner.fail("Failed to start registry watcher");
+    if (error instanceof Error) {
+      console.error(chalk4.red(error.message));
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync2, mkdirSync, writeFileSync, readFileSync } from "fs";
+import { join } from "path";
+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'
+
+export const BLOCK_REGISTRY: Record<string, {
+  name: string
+  slug: string
+  componentPath: string
+  fields?: unknown[]
+  examples?: unknown[]
+}> = {}
+
+// 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'
+`);
+}
+async function initCommand(options) {
+  const spinner = ora5("Initializing NextSpark project...").start();
+  const projectRoot = process.cwd();
+  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 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));
+    }
+    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
+`;
+      writeFileSync(envExample, envContent);
+      spinner.text = "Created .env.example";
+    }
+    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");
+  } catch (error) {
+    spinner.fail("Initialization failed");
+    if (error instanceof Error) {
+      console.error(chalk5.red(error.message));
+    }
+    process.exit(1);
+  }
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("nextspark").description("NextSpark CLI - Professional SaaS Boilerplate").version("0.3.0");
+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);
+var registry = program.command("registry").description("Registry management commands");
+registry.command("build").description("Build all registries").action(registryBuildCommand);
+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.showHelpAfterError();
+program.configureOutput({
+  writeErr: (str) => process.stderr.write(chalk6.red(str))
+});
+program.parse();

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@nextsparkjs/cli",
+  "version": "0.1.0-beta.1",
+  "description": "CLI for NextSpark - wrap core scripts with a professional interface",
+  "type": "module",
+  "bin": {
+    "nextspark": "./bin/nextspark.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "scripts": {
+    "build": "tsup src/cli.ts --format esm --dts --outDir dist",
+    "dev": "tsup src/cli.ts --format esm --watch"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "chalk": "^5.3.0",
+    "ora": "^8.0.0"
+  },
+  "devDependencies": {
+    "@nextsparkjs/core": "workspace:*",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "peerDependencies": {
+    "@nextsparkjs/core": ">=0.1.0-beta.1"
+  },
+  "keywords": [
+    "nextspark",
+    "cli",
+    "nextjs",
+    "saas",
+    "boilerplate"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/NextSpark-js/nextspark.git",
+    "directory": "packages/cli"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}