create-nexu 1.0.0

package/dist/index.js

@@ -0,0 +1,603 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/add.ts
+import path2 from "path";
+import { fileURLToPath } from "url";
+import chalk2 from "chalk";
+import fs2 from "fs-extra";
+import inquirer from "inquirer";
+import ora from "ora";
+
+// src/utils/constants.ts
+var TEMPLATE_DIRS = {
+  packages: "packages",
+  services: "services",
+  workflows: ".github/workflows",
+  actions: ".github/actions",
+  config: [
+    ".eslintrc.js",
+    ".eslintignore",
+    ".prettierrc",
+    ".prettierignore",
+    "tsconfig.json",
+    "turbo.json",
+    "vitest.config.ts",
+    "commitlint.config.js"
+  ],
+  husky: ".husky",
+  vscode: ".vscode",
+  docker: "docker",
+  scripts: "scripts",
+  changeset: ".changeset"
+};
+var SHARED_PACKAGES = [
+  "cache",
+  "config",
+  "constants",
+  "logger",
+  "result",
+  "types",
+  "ui",
+  "utils"
+];
+var SERVICES = [
+  "postgres",
+  "redis",
+  "rabbitmq",
+  "kafka",
+  "prometheus",
+  "grafana",
+  "minio",
+  "elasticsearch"
+];
+
+// src/utils/helpers.ts
+import { execSync } from "child_process";
+import path from "path";
+import chalk from "chalk";
+import fs from "fs-extra";
+function isNexuProject(dir) {
+  const packageJsonPath = path.join(dir, "package.json");
+  if (!fs.existsSync(packageJsonPath)) return false;
+  try {
+    const packageJson = fs.readJsonSync(packageJsonPath);
+    return packageJson.name === "nexu" || fs.existsSync(path.join(dir, "turbo.json"));
+  } catch {
+    return false;
+  }
+}
+function exec(command, cwd) {
+  try {
+    return execSync(command, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch (error) {
+    throw new Error(`Command failed: ${command}`);
+  }
+}
+function copyWithMerge(src, dest, overwrite = false) {
+  if (fs.existsSync(dest) && !overwrite) {
+    if (fs.statSync(src).isDirectory() && fs.statSync(dest).isDirectory()) {
+      const files = fs.readdirSync(src);
+      for (const file of files) {
+        copyWithMerge(path.join(src, file), path.join(dest, file), overwrite);
+      }
+    }
+    return;
+  }
+  fs.copySync(src, dest, { overwrite });
+}
+function log(message, type = "info") {
+  const colors = {
+    info: chalk.blue,
+    success: chalk.green,
+    warn: chalk.yellow,
+    error: chalk.red
+  };
+  const icons = {
+    info: "i",
+    success: "\u2713",
+    warn: "!",
+    error: "\u2717"
+  };
+  console.log(`${colors[type](icons[type])} ${message}`);
+}
+
+// src/commands/add.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path2.dirname(__filename);
+function getTemplateDir() {
+  const possiblePaths = [
+    path2.resolve(__dirname, "..", "..", "templates", "default"),
+    path2.resolve(__dirname, "..", "templates", "default")
+  ];
+  for (const templatePath of possiblePaths) {
+    if (fs2.existsSync(templatePath)) {
+      return templatePath;
+    }
+  }
+  throw new Error("Template directory not found. Please reinstall the package.");
+}
+async function add(component, options) {
+  console.log(chalk2.bold("\n\u2795 Add Component\n"));
+  const projectDir = process.cwd();
+  if (!isNexuProject(projectDir)) {
+    log("This does not appear to be a Nexu project.", "error");
+    process.exit(1);
+  }
+  const componentType = component.toLowerCase();
+  switch (componentType) {
+    case "package":
+      await addPackage(projectDir, options.name);
+      break;
+    case "service":
+      await addService(projectDir, options.name);
+      break;
+    default:
+      log(`Unknown component type: ${component}. Use 'package' or 'service'.`, "error");
+      process.exit(1);
+  }
+}
+async function addPackage(projectDir, packageName) {
+  const packagesDir = path2.join(projectDir, "packages");
+  const existingPackages = fs2.existsSync(packagesDir) ? fs2.readdirSync(packagesDir).filter((f) => fs2.statSync(path2.join(packagesDir, f)).isDirectory()) : [];
+  const availablePackages = SHARED_PACKAGES.filter((pkg) => !existingPackages.includes(pkg));
+  if (availablePackages.length === 0) {
+    log("All packages are already installed.", "info");
+    return;
+  }
+  let selectedPackages;
+  if (packageName && availablePackages.includes(packageName)) {
+    selectedPackages = [packageName];
+  } else {
+    const { packages } = await inquirer.prompt([
+      {
+        type: "checkbox",
+        name: "packages",
+        message: "Select packages to add:",
+        choices: availablePackages.map((pkg) => ({
+          name: pkg,
+          value: pkg
+        })),
+        validate: (input) => {
+          if (input.length === 0) {
+            return "Please select at least one package";
+          }
+          return true;
+        }
+      }
+    ]);
+    selectedPackages = packages;
+  }
+  const spinner = ora("Adding packages...").start();
+  try {
+    const templateDir = getTemplateDir();
+    for (const pkg of selectedPackages) {
+      const srcDir = path2.join(templateDir, "packages", pkg);
+      const destDir = path2.join(projectDir, "packages", pkg);
+      if (fs2.existsSync(srcDir)) {
+        fs2.copySync(srcDir, destDir);
+      }
+    }
+    spinner.succeed(`Added ${selectedPackages.length} package(s): ${selectedPackages.join(", ")}`);
+    console.log("\nRun " + chalk2.cyan("pnpm install") + " to install dependencies.");
+  } catch (error) {
+    spinner.fail("Failed to add packages");
+    console.error(error);
+    process.exit(1);
+  }
+}
+async function addService(projectDir, serviceName) {
+  const servicesDir = path2.join(projectDir, "services");
+  if (!fs2.existsSync(servicesDir)) {
+    const { createServices } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "createServices",
+        message: "Services directory does not exist. Create it?",
+        default: true
+      }
+    ]);
+    if (!createServices) {
+      return;
+    }
+  }
+  let selectedServices;
+  if (serviceName && SERVICES.includes(serviceName)) {
+    selectedServices = [serviceName];
+  } else {
+    const { services } = await inquirer.prompt([
+      {
+        type: "checkbox",
+        name: "services",
+        message: "Select services to configure:",
+        choices: SERVICES.map((svc) => ({
+          name: svc,
+          value: svc
+        })),
+        validate: (input) => {
+          if (input.length === 0) {
+            return "Please select at least one service";
+          }
+          return true;
+        }
+      }
+    ]);
+    selectedServices = services;
+  }
+  const spinner = ora("Adding services configuration...").start();
+  try {
+    const templateDir = getTemplateDir();
+    const srcServicesDir = path2.join(templateDir, "services");
+    if (fs2.existsSync(srcServicesDir)) {
+      fs2.copySync(srcServicesDir, servicesDir, { overwrite: false });
+    }
+    spinner.succeed(`Services configuration added`);
+    console.log("\nAvailable services: " + chalk2.cyan(selectedServices.join(", ")));
+    console.log(
+      "Start with: " + chalk2.cyan("docker compose -f services/docker-compose.yml --profile <profile> up -d")
+    );
+  } catch (error) {
+    spinner.fail("Failed to add services");
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// src/commands/init.ts
+import path3 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import chalk3 from "chalk";
+import fs3 from "fs-extra";
+import inquirer2 from "inquirer";
+import ora2 from "ora";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path3.dirname(__filename2);
+function getTemplateDir2() {
+  const possiblePaths = [
+    path3.resolve(__dirname2, "..", "..", "templates", "default"),
+    path3.resolve(__dirname2, "..", "templates", "default")
+  ];
+  for (const templatePath of possiblePaths) {
+    if (fs3.existsSync(templatePath)) {
+      return templatePath;
+    }
+  }
+  throw new Error("Template directory not found. Please reinstall the package.");
+}
+async function init(projectName, options) {
+  console.log(chalk3.bold("\n\u{1F680} Create Nexu Monorepo\n"));
+  if (!projectName) {
+    const answers = await inquirer2.prompt([
+      {
+        type: "input",
+        name: "projectName",
+        message: "Project name:",
+        default: "my-nexu-app",
+        validate: (input) => {
+          if (!/^[a-z0-9-]+$/.test(input)) {
+            return "Project name can only contain lowercase letters, numbers, and hyphens";
+          }
+          return true;
+        }
+      }
+    ]);
+    projectName = answers.projectName;
+  }
+  const projectDir = path3.resolve(process.cwd(), projectName);
+  if (fs3.existsSync(projectDir)) {
+    const { overwrite } = await inquirer2.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: `Directory ${projectName} already exists. Overwrite?`,
+        default: false
+      }
+    ]);
+    if (!overwrite) {
+      log("Aborted.", "warn");
+      process.exit(0);
+    }
+    fs3.removeSync(projectDir);
+  }
+  const { selectedPackages } = await inquirer2.prompt([
+    {
+      type: "checkbox",
+      name: "selectedPackages",
+      message: "Select packages to include:",
+      choices: SHARED_PACKAGES.map((pkg) => ({
+        name: pkg,
+        value: pkg,
+        checked: true
+      }))
+    }
+  ]);
+  const { features } = await inquirer2.prompt([
+    {
+      type: "checkbox",
+      name: "features",
+      message: "Select additional features:",
+      choices: [
+        { name: "Docker services (PostgreSQL, Redis, etc.)", value: "services", checked: true },
+        { name: "GitHub Actions workflows", value: "workflows", checked: true },
+        { name: "Changesets (versioning)", value: "changesets", checked: true },
+        { name: "Husky (git hooks)", value: "husky", checked: true },
+        { name: "VSCode settings", value: "vscode", checked: true }
+      ]
+    }
+  ]);
+  const spinner = ora2("Copying template...").start();
+  try {
+    const templateDir = getTemplateDir2();
+    fs3.copySync(templateDir, projectDir);
+    spinner.succeed("Template copied");
+  } catch (error) {
+    spinner.fail("Failed to copy template");
+    console.error(error);
+    process.exit(1);
+  }
+  const packageJsonPath = path3.join(projectDir, "package.json");
+  let packageJsonContent = fs3.readFileSync(packageJsonPath, "utf-8");
+  packageJsonContent = packageJsonContent.replace("{{PROJECT_NAME}}", projectName);
+  fs3.writeFileSync(packageJsonPath, packageJsonContent);
+  const packagesToRemove = SHARED_PACKAGES.filter((pkg) => !selectedPackages.includes(pkg));
+  if (packagesToRemove.length > 0) {
+    const removeSpinner = ora2("Removing unselected packages...").start();
+    for (const pkg of packagesToRemove) {
+      const pkgDir = path3.join(projectDir, "packages", pkg);
+      if (fs3.existsSync(pkgDir)) {
+        fs3.removeSync(pkgDir);
+      }
+    }
+    removeSpinner.succeed("Removed unselected packages");
+  }
+  if (!features.includes("services")) {
+    fs3.removeSync(path3.join(projectDir, "services"));
+  }
+  if (!features.includes("workflows")) {
+    fs3.removeSync(path3.join(projectDir, ".github", "workflows"));
+    fs3.removeSync(path3.join(projectDir, ".github", "actions"));
+  }
+  if (!features.includes("changesets")) {
+    fs3.removeSync(path3.join(projectDir, ".changeset"));
+  }
+  if (!features.includes("husky")) {
+    fs3.removeSync(path3.join(projectDir, ".husky"));
+  }
+  if (!features.includes("vscode")) {
+    fs3.removeSync(path3.join(projectDir, ".vscode"));
+  }
+  const packageJson = fs3.readJsonSync(packageJsonPath);
+  if (!features.includes("changesets")) {
+    delete packageJson.scripts["changeset"];
+    delete packageJson.scripts["version-packages"];
+    delete packageJson.scripts["release"];
+    delete packageJson.devDependencies["@changesets/cli"];
+  }
+  if (!features.includes("husky")) {
+    delete packageJson.scripts["prepare"];
+    delete packageJson.devDependencies["husky"];
+    delete packageJson.devDependencies["lint-staged"];
+    delete packageJson["lint-staged"];
+  }
+  fs3.writeJsonSync(packageJsonPath, packageJson, { spaces: 2 });
+  if (!options.skipGit) {
+    const gitSpinner = ora2("Initializing git repository...").start();
+    try {
+      exec("git init", projectDir);
+      exec("git add .", projectDir);
+      exec('git commit -m "Initial commit from create-nexu"', projectDir);
+      gitSpinner.succeed("Git repository initialized");
+    } catch {
+      gitSpinner.warn("Failed to initialize git repository");
+    }
+  }
+  if (!options.skipInstall) {
+    const installSpinner = ora2("Installing dependencies...").start();
+    try {
+      exec("pnpm install", projectDir);
+      installSpinner.succeed("Dependencies installed");
+    } catch {
+      installSpinner.warn('Failed to install dependencies. Run "pnpm install" manually.');
+    }
+  }
+  console.log("\n" + chalk3.green.bold("\u2728 Project created successfully!\n"));
+  console.log("Next steps:\n");
+  console.log(chalk3.cyan(`  cd ${projectName}`));
+  if (options.skipInstall) {
+    console.log(chalk3.cyan("  pnpm install"));
+  }
+  console.log(chalk3.cyan("  pnpm dev"));
+  console.log("\nTo create an app:");
+  console.log(chalk3.cyan("  pnpm generate:app <name> <port>"));
+  console.log("\nTo update with latest features:");
+  console.log(chalk3.cyan("  npx create-nexu update"));
+  console.log("");
+}
+
+// src/commands/update.ts
+import path4 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import chalk4 from "chalk";
+import fs4 from "fs-extra";
+import inquirer3 from "inquirer";
+import ora3 from "ora";
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname3 = path4.dirname(__filename3);
+function getTemplateDir3() {
+  const possiblePaths = [
+    path4.resolve(__dirname3, "..", "..", "templates", "default"),
+    path4.resolve(__dirname3, "..", "templates", "default")
+  ];
+  for (const templatePath of possiblePaths) {
+    if (fs4.existsSync(templatePath)) {
+      return templatePath;
+    }
+  }
+  throw new Error("Template directory not found. Please reinstall the package.");
+}
+async function update(options) {
+  console.log(chalk4.bold("\n\u{1F504} Update Nexu Project\n"));
+  const projectDir = process.cwd();
+  if (!isNexuProject(projectDir)) {
+    log(
+      "This does not appear to be a Nexu project. Run this command from the project root.",
+      "error"
+    );
+    process.exit(1);
+  }
+  const updateAll = options.all || !options.packages && !options.config && !options.workflows && !options.services;
+  const updateTargets = {
+    packages: updateAll || options.packages,
+    config: updateAll || options.config,
+    workflows: updateAll || options.workflows,
+    services: updateAll || options.services
+  };
+  console.log("Components to update:");
+  if (updateTargets.packages) console.log(chalk4.cyan("  - Shared packages"));
+  if (updateTargets.config) console.log(chalk4.cyan("  - Configuration files"));
+  if (updateTargets.workflows) console.log(chalk4.cyan("  - GitHub workflows"));
+  if (updateTargets.services) console.log(chalk4.cyan("  - Docker services"));
+  console.log("");
+  if (options.dryRun) {
+    log("Dry run mode - no changes will be made", "info");
+    return;
+  }
+  const { confirm } = await inquirer3.prompt([
+    {
+      type: "confirm",
+      name: "confirm",
+      message: "Proceed with update?",
+      default: true
+    }
+  ]);
+  if (!confirm) {
+    log("Update cancelled.", "warn");
+    return;
+  }
+  const templateDir = getTemplateDir3();
+  if (updateTargets.packages) {
+    await updatePackages(projectDir, templateDir);
+  }
+  if (updateTargets.config) {
+    await updateConfig(projectDir, templateDir);
+  }
+  if (updateTargets.workflows) {
+    await updateWorkflows(projectDir, templateDir);
+  }
+  if (updateTargets.services) {
+    await updateServices(projectDir, templateDir);
+  }
+  console.log("\n" + chalk4.green.bold("\u2728 Update complete!\n"));
+  console.log("Run " + chalk4.cyan("pnpm install") + " to install any new dependencies.");
+  console.log("");
+}
+async function updatePackages(projectDir, templateDir) {
+  const spinner = ora3("Updating shared packages...").start();
+  const existingPackages = fs4.existsSync(path4.join(projectDir, "packages")) ? fs4.readdirSync(path4.join(projectDir, "packages")).filter((f) => fs4.statSync(path4.join(projectDir, "packages", f)).isDirectory()) : [];
+  const { selectedPackages } = await inquirer3.prompt([
+    {
+      type: "checkbox",
+      name: "selectedPackages",
+      message: "Select packages to update:",
+      choices: SHARED_PACKAGES.map((pkg) => ({
+        name: pkg + (existingPackages.includes(pkg) ? " (update)" : " (add new)"),
+        value: pkg,
+        checked: existingPackages.includes(pkg)
+      }))
+    }
+  ]);
+  spinner.start("Updating packages...");
+  for (const pkg of selectedPackages) {
+    const srcDir = path4.join(templateDir, "packages", pkg);
+    const destDir = path4.join(projectDir, "packages", pkg);
+    if (fs4.existsSync(srcDir)) {
+      let existingPkgJson = null;
+      const pkgJsonPath = path4.join(destDir, "package.json");
+      if (fs4.existsSync(pkgJsonPath)) {
+        existingPkgJson = fs4.readJsonSync(pkgJsonPath);
+      }
+      fs4.copySync(srcDir, destDir, { overwrite: true });
+      if (existingPkgJson) {
+        const newPkgJson = fs4.readJsonSync(pkgJsonPath);
+        newPkgJson.version = existingPkgJson.version;
+        fs4.writeJsonSync(pkgJsonPath, newPkgJson, { spaces: 2 });
+      }
+    }
+  }
+  spinner.succeed(`Updated ${selectedPackages.length} packages`);
+}
+async function updateConfig(projectDir, templateDir) {
+  const spinner = ora3("Updating configuration files...").start();
+  const configFiles = TEMPLATE_DIRS.config;
+  let updated = 0;
+  for (const file of configFiles) {
+    const srcFile = path4.join(templateDir, file);
+    const destFile = path4.join(projectDir, file);
+    if (fs4.existsSync(srcFile)) {
+      fs4.copySync(srcFile, destFile, { overwrite: true });
+      updated++;
+    }
+  }
+  const huskySrc = path4.join(templateDir, ".husky");
+  const huskyDest = path4.join(projectDir, ".husky");
+  if (fs4.existsSync(huskySrc)) {
+    fs4.copySync(huskySrc, huskyDest, { overwrite: true });
+  }
+  const vscodeSrc = path4.join(templateDir, ".vscode");
+  const vscodeDest = path4.join(projectDir, ".vscode");
+  if (fs4.existsSync(vscodeSrc)) {
+    fs4.copySync(vscodeSrc, vscodeDest, { overwrite: true });
+  }
+  spinner.succeed(`Updated ${updated} configuration files`);
+}
+async function updateWorkflows(projectDir, templateDir) {
+  const spinner = ora3("Updating GitHub workflows...").start();
+  const workflowsSrc = path4.join(templateDir, ".github", "workflows");
+  const workflowsDest = path4.join(projectDir, ".github", "workflows");
+  if (fs4.existsSync(workflowsSrc)) {
+    fs4.ensureDirSync(workflowsDest);
+    fs4.copySync(workflowsSrc, workflowsDest, { overwrite: true });
+  }
+  const actionsSrc = path4.join(templateDir, ".github", "actions");
+  const actionsDest = path4.join(projectDir, ".github", "actions");
+  if (fs4.existsSync(actionsSrc)) {
+    fs4.ensureDirSync(actionsDest);
+    fs4.copySync(actionsSrc, actionsDest, { overwrite: true });
+  }
+  const dependabotSrc = path4.join(templateDir, ".github", "dependabot.yml");
+  const dependabotDest = path4.join(projectDir, ".github", "dependabot.yml");
+  if (fs4.existsSync(dependabotSrc)) {
+    fs4.copySync(dependabotSrc, dependabotDest, { overwrite: true });
+  }
+  spinner.succeed("Updated GitHub workflows and actions");
+}
+async function updateServices(projectDir, templateDir) {
+  const spinner = ora3("Updating Docker services...").start();
+  const servicesSrc = path4.join(templateDir, "services");
+  const servicesDest = path4.join(projectDir, "services");
+  if (fs4.existsSync(servicesSrc)) {
+    fs4.ensureDirSync(servicesDest);
+    copyWithMerge(servicesSrc, servicesDest, true);
+  }
+  spinner.succeed("Updated Docker services");
+}
+
+// src/index.ts
+var program = new Command();
+program.name("create-nexu").description("CLI to create and update Nexu monorepo projects").version("1.0.0");
+program.argument("[project-name]", "Name of the project to create").option("-t, --template <template>", "Template to use (default, minimal)", "default").option("--skip-install", "Skip dependency installation").option("--skip-git", "Skip git initialization").action((projectName, options) => {
+  if (!projectName && process.argv.length <= 2) {
+    program.help();
+  } else {
+    return init(projectName, options);
+  }
+});
+program.command("update").description("Update an existing Nexu project with latest features").option("-p, --packages", "Update only shared packages").option("-c, --config", "Update only configuration files").option("-w, --workflows", "Update only GitHub workflows").option("-s, --services", "Update only Docker services").option("--all", "Update everything (default)").option("--dry-run", "Show what would be updated without making changes").action(update);
+program.command("add <component>").description("Add a component to your project (package, service)").option("-n, --name <name>", "Name for the component").action(add);
+program.parse();

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "create-nexu",
+  "version": "1.0.0",
+  "description": "CLI to create and update Nexu monorepo projects",
+  "author": "Nexu Team",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "create-nexu": "./dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "fs-extra": "^11.2.0",
+    "inquirer": "^9.2.0",
+    "chalk": "^5.3.0",
+    "ora": "^8.0.0",
+    "semver": "^7.6.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.0",
+    "@types/inquirer": "^9.0.0",
+    "@types/semver": "^7.5.0",
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
+  }
+}

package/templates/default/.changeset/config.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://unpkg.com/@changesets/config@3.0.0/schema.json",
+  "changelog": "@changesets/cli/changelog",
+  "commit": false,
+  "fixed": [],
+  "linked": [],
+  "access": "restricted",
+  "baseBranch": "main",
+  "updateInternalDependencies": "patch",
+  "ignore": []
+}

package/templates/default/.eslintignore

@@ -0,0 +1,13 @@
+# Config files (not part of TypeScript project)
+.eslintrc.js
+commitlint.config.js
+*.config.js
+*.config.mjs
+*.config.ts
+packages/config/**
+
+# Build outputs
+node_modules
+dist
+.next
+coverage