nexu-app 2.0.0

package/dist/index.js

@@ -0,0 +1,1192 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+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",
+    ".nexu-version",
+    "tsconfig.json",
+    "turbo.json",
+    "vitest.config.ts",
+    "commitlint.config.js"
+  ],
+  husky: ".husky",
+  vscode: ".vscode",
+  docker: "docker",
+  scripts: "scripts",
+  changeset: ".changeset"
+};
+var SHARED_PACKAGES = [
+  "auth",
+  "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 packageJson2 = fs.readJsonSync(packageJsonPath);
+    return packageJson2.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 execInherit(command, cwd) {
+  try {
+    execSync(command, {
+      cwd,
+      stdio: "inherit"
+    });
+  } catch (error) {
+    throw new Error(`Command failed: ${command}`);
+  }
+}
+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}`);
+}
+function detectPackageManager(projectDir = process.cwd()) {
+  if (fs.existsSync(path.join(projectDir, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (fs.existsSync(path.join(projectDir, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (fs.existsSync(path.join(projectDir, "package-lock.json"))) {
+    return "npm";
+  }
+  const packageJsonPath = path.join(projectDir, "package.json");
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const pkg = fs.readJsonSync(packageJsonPath);
+      if (pkg.packageManager) {
+        if (pkg.packageManager.startsWith("pnpm")) return "pnpm";
+        if (pkg.packageManager.startsWith("yarn")) return "yarn";
+        if (pkg.packageManager.startsWith("npm")) return "npm";
+      }
+    } catch {
+    }
+  }
+  const userAgent = process.env.npm_config_user_agent || "";
+  if (userAgent.includes("pnpm")) return "pnpm";
+  if (userAgent.includes("yarn")) return "yarn";
+  return "npm";
+}
+function getRunCommand(pm) {
+  switch (pm) {
+    case "pnpm":
+      return "pnpm";
+    case "yarn":
+      return "yarn";
+    case "npm":
+    default:
+      return "npm run";
+  }
+}
+function getPackageManagerVersion(pm) {
+  try {
+    const version = execSync(`${pm} --version`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return version;
+  } catch {
+    return null;
+  }
+}
+function getPackageManagerField(pm) {
+  const version = getPackageManagerVersion(pm);
+  if (!version) return null;
+  return `${pm}@${version}`;
+}
+function getInstallCommand(pm) {
+  switch (pm) {
+    case "pnpm":
+      return "pnpm install";
+    case "yarn":
+      return "yarn install";
+    case "npm":
+    default:
+      return "npm install";
+  }
+}
+
+// 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"));
+  const useCurrentDir = projectName === ".";
+  let projectDir;
+  if (useCurrentDir) {
+    projectDir = process.cwd();
+    projectName = path3.basename(projectDir);
+    const files = fs3.readdirSync(projectDir).filter((f) => !f.startsWith("."));
+    if (files.length > 0) {
+      const { proceed } = await inquirer2.prompt([
+        {
+          type: "confirm",
+          name: "proceed",
+          message: `Current directory is not empty. Continue anyway?`,
+          default: false
+        }
+      ]);
+      if (!proceed) {
+        log("Aborted.", "warn");
+        process.exit(0);
+      }
+    }
+  } else {
+    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;
+    }
+    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);
+    }
+  }
+  let packageManager = options.packageManager;
+  if (!packageManager) {
+    const { pm } = await inquirer2.prompt([
+      {
+        type: "list",
+        name: "pm",
+        message: "Select package manager:",
+        choices: [
+          { name: "pnpm (recommended)", value: "pnpm" },
+          { name: "npm", value: "npm" },
+          { name: "yarn", value: "yarn" }
+        ],
+        default: "pnpm"
+      }
+    ]);
+    packageManager = pm;
+  }
+  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);
+    const dotfilesToRename = [
+      { src: path3.join(projectDir, "gitignore"), dest: path3.join(projectDir, ".gitignore") },
+      {
+        src: path3.join(projectDir, "lintstagedrc.cjs"),
+        dest: path3.join(projectDir, ".lintstagedrc.cjs")
+      },
+      {
+        src: path3.join(projectDir, "apps", "gitkeep"),
+        dest: path3.join(projectDir, "apps", ".gitkeep")
+      },
+      {
+        src: path3.join(projectDir, "services", "postgres", "init", "gitkeep"),
+        dest: path3.join(projectDir, "services", "postgres", "init", ".gitkeep")
+      }
+    ];
+    for (const { src, dest } of dotfilesToRename) {
+      if (fs3.existsSync(src)) {
+        fs3.renameSync(src, dest);
+      }
+    }
+    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");
+  const packageJson2 = fs3.readJsonSync(packageJsonPath);
+  packageJson2.name = projectName;
+  const pmField = getPackageManagerField(packageManager);
+  if (pmField) {
+    packageJson2.packageManager = pmField;
+  } else {
+    delete packageJson2.packageManager;
+  }
+  if (!features.includes("changesets")) {
+    delete packageJson2.scripts["changeset"];
+    delete packageJson2.scripts["version-packages"];
+    delete packageJson2.scripts["release"];
+    delete packageJson2.devDependencies["@changesets/cli"];
+  }
+  if (!features.includes("husky")) {
+    delete packageJson2.scripts["prepare"];
+    delete packageJson2.devDependencies["husky"];
+    delete packageJson2.devDependencies["lint-staged"];
+    delete packageJson2["lint-staged"];
+  }
+  fs3.writeJsonSync(packageJsonPath, packageJson2, { spaces: 2 });
+  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"));
+  }
+  if (packageManager === "yarn") {
+    fs3.removeSync(path3.join(projectDir, "pnpm-workspace.yaml"));
+    fs3.removeSync(path3.join(projectDir, ".npmrc"));
+    const updatedPkg = fs3.readJsonSync(packageJsonPath);
+    updatedPkg.private = true;
+    updatedPkg.workspaces = ["apps/*", "packages/*"];
+    fs3.writeJsonSync(packageJsonPath, updatedPkg, { spaces: 2 });
+  } else if (packageManager === "npm") {
+    fs3.removeSync(path3.join(projectDir, "pnpm-workspace.yaml"));
+    fs3.removeSync(path3.join(projectDir, ".npmrc"));
+    const updatedPkg = fs3.readJsonSync(packageJsonPath);
+    updatedPkg.private = true;
+    updatedPkg.workspaces = ["apps/*", "packages/*"];
+    fs3.writeJsonSync(packageJsonPath, updatedPkg, { 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 nexu-app"', projectDir);
+      gitSpinner.succeed("Git repository initialized");
+    } catch {
+      gitSpinner.warn("Failed to initialize git repository");
+    }
+  }
+  const runCmd = getRunCommand(packageManager);
+  if (!options.skipInstall) {
+    console.log(chalk3.blue(`
+\u{1F4E6} Installing dependencies with ${packageManager}...
+`));
+    try {
+      execInherit(getInstallCommand(packageManager), projectDir);
+      console.log(chalk3.green("\n\u2713 Dependencies installed"));
+    } catch {
+      console.log(
+        chalk3.yellow(
+          `
+! Failed to install dependencies. Run "${getInstallCommand(packageManager)}" manually.`
+        )
+      );
+    }
+  }
+  console.log("\n" + chalk3.green.bold("\u2728 Project created successfully!\n"));
+  console.log("Next steps:\n");
+  if (!useCurrentDir) {
+    console.log(chalk3.cyan(`  cd ${projectName}`));
+  }
+  if (options.skipInstall) {
+    console.log(chalk3.cyan(`  ${getInstallCommand(packageManager)}`));
+  }
+  console.log(chalk3.cyan(`  ${runCmd} dev`));
+  console.log("\nTo create an app:");
+  console.log(chalk3.cyan(`  ${runCmd} generate:app <name> <port>`));
+  console.log("\nTo update with latest features:");
+  console.log(chalk3.cyan("  npx nexu-app update"));
+  console.log("");
+}
+
+// src/commands/update.ts
+import path4 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import chalk4 from "chalk";
+import { diffLines } from "diff";
+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.");
+}
+function compareFiles(srcPath, destPath) {
+  if (!fs4.existsSync(destPath)) return false;
+  if (!fs4.existsSync(srcPath)) return false;
+  const srcStat = fs4.statSync(srcPath);
+  const destStat = fs4.statSync(destPath);
+  if (srcStat.isDirectory() || destStat.isDirectory()) return false;
+  const srcContent = fs4.readFileSync(srcPath, "utf-8");
+  const destContent = fs4.readFileSync(destPath, "utf-8");
+  return srcContent === destContent;
+}
+function collectFileChanges(srcDir, destDir, category, basePath = "", checkDeleted = true) {
+  const changes = [];
+  if (fs4.existsSync(srcDir)) {
+    const entries = fs4.readdirSync(srcDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcPath = path4.join(srcDir, entry.name);
+      const destPath = path4.join(destDir, entry.name);
+      const relativePath = basePath ? path4.join(basePath, entry.name) : entry.name;
+      if (entry.isDirectory()) {
+        changes.push(
+          ...collectFileChanges(srcPath, destPath, category, relativePath, checkDeleted)
+        );
+      } else {
+        if (!fs4.existsSync(destPath)) {
+          changes.push({ type: "add", relativePath, srcPath, destPath, category });
+        } else if (!compareFiles(srcPath, destPath)) {
+          changes.push({ type: "modify", relativePath, srcPath, destPath, category });
+        }
+      }
+    }
+  }
+  if (checkDeleted && fs4.existsSync(destDir)) {
+    const destEntries = fs4.readdirSync(destDir, { withFileTypes: true });
+    for (const entry of destEntries) {
+      const srcPath = path4.join(srcDir, entry.name);
+      const destPath = path4.join(destDir, entry.name);
+      const relativePath = basePath ? path4.join(basePath, entry.name) : entry.name;
+      if (shouldExcludeFromDeletion(entry.name, relativePath)) {
+        continue;
+      }
+      if (fs4.existsSync(srcPath)) continue;
+      if (entry.isDirectory()) {
+        changes.push(...collectDeletedFiles(destPath, category, relativePath));
+      } else {
+        changes.push({ type: "delete", relativePath, srcPath, destPath, category });
+      }
+    }
+  }
+  return changes;
+}
+var EXCLUDE_FROM_DELETION = [
+  "node_modules",
+  ".git",
+  ".turbo",
+  "dist",
+  "build",
+  ".next",
+  "coverage",
+  ".husky/_",
+  // Husky internal files
+  ".DS_Store"
+];
+function shouldExcludeFromDeletion(name, relativePath) {
+  if (EXCLUDE_FROM_DELETION.includes(name)) {
+    return true;
+  }
+  for (const pattern of EXCLUDE_FROM_DELETION) {
+    if (relativePath.startsWith(pattern + "/") || relativePath.startsWith(pattern + path4.sep)) {
+      return true;
+    }
+    if (relativePath === pattern) {
+      return true;
+    }
+  }
+  return false;
+}
+function collectDeletedFiles(destDir, category, basePath) {
+  const changes = [];
+  if (!fs4.existsSync(destDir)) return changes;
+  const entries = fs4.readdirSync(destDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const destPath = path4.join(destDir, entry.name);
+    const relativePath = path4.join(basePath, entry.name);
+    if (shouldExcludeFromDeletion(entry.name, relativePath)) {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      changes.push(...collectDeletedFiles(destPath, category, relativePath));
+    } else {
+      changes.push({ type: "delete", relativePath, srcPath: "", destPath, category });
+    }
+  }
+  return changes;
+}
+function showFileDiff(srcPath, destPath) {
+  if (!fs4.existsSync(destPath)) {
+    console.log(chalk4.green("  (new file)"));
+    return;
+  }
+  const srcContent = fs4.readFileSync(srcPath, "utf-8");
+  const destContent = fs4.readFileSync(destPath, "utf-8");
+  const differences = diffLines(destContent, srcContent);
+  let hasChanges2 = false;
+  for (const part of differences) {
+    if (part.added || part.removed) {
+      hasChanges2 = true;
+      const lines = part.value.split("\n").filter((l) => l.length > 0);
+      for (const line of lines.slice(0, 5)) {
+        if (part.added) {
+          console.log(chalk4.green(`  + ${line.substring(0, 80)}`));
+        } else {
+          console.log(chalk4.red(`  - ${line.substring(0, 80)}`));
+        }
+      }
+      if (lines.length > 5) {
+        console.log(chalk4.gray(`  ... and ${lines.length - 5} more lines`));
+      }
+    }
+  }
+  if (!hasChanges2) {
+    console.log(chalk4.gray("  (no visible changes)"));
+  }
+}
+function collectDependencyChanges(templatePkgPath, projectPkgPath) {
+  if (!fs4.existsSync(templatePkgPath) || !fs4.existsSync(projectPkgPath)) {
+    return null;
+  }
+  const templatePkg = fs4.readJsonSync(templatePkgPath);
+  const projectPkg = fs4.readJsonSync(projectPkgPath);
+  const changes = {
+    type: "package.json",
+    changes: {
+      added: { dependencies: {}, devDependencies: {}, scripts: {} },
+      updated: { dependencies: {}, devDependencies: {}, scripts: {} }
+    }
+  };
+  for (const depType of ["dependencies", "devDependencies"]) {
+    if (templatePkg[depType]) {
+      for (const [pkg, version] of Object.entries(templatePkg[depType])) {
+        if (!projectPkg[depType]?.[pkg]) {
+          changes.changes.added[depType][pkg] = version;
+        } else if (projectPkg[depType][pkg] !== version) {
+          changes.changes.updated[depType][pkg] = {
+            from: projectPkg[depType][pkg],
+            to: version
+          };
+        }
+      }
+    }
+  }
+  if (templatePkg.scripts) {
+    for (const [script, cmd] of Object.entries(templatePkg.scripts)) {
+      if (!projectPkg.scripts?.[script]) {
+        changes.changes.added.scripts[script] = cmd;
+      } else if (projectPkg.scripts[script] !== cmd) {
+        changes.changes.updated.scripts[script] = {
+          from: projectPkg.scripts[script],
+          to: cmd
+        };
+      }
+    }
+  }
+  return changes;
+}
+function displayDependencyChanges(changes) {
+  const { added, updated } = changes.changes;
+  if (Object.keys(added.dependencies).length > 0) {
+    console.log(chalk4.cyan("\n  New dependencies:"));
+    for (const [pkg, version] of Object.entries(added.dependencies)) {
+      console.log(chalk4.green(`    + ${pkg}: ${version}`));
+    }
+  }
+  if (Object.keys(added.devDependencies).length > 0) {
+    console.log(chalk4.cyan("\n  New devDependencies:"));
+    for (const [pkg, version] of Object.entries(added.devDependencies)) {
+      console.log(chalk4.green(`    + ${pkg}: ${version}`));
+    }
+  }
+  if (Object.keys(updated.dependencies).length > 0) {
+    console.log(chalk4.cyan("\n  Updated dependencies:"));
+    for (const [pkg, { from, to }] of Object.entries(updated.dependencies)) {
+      console.log(chalk4.yellow(`    ~ ${pkg}: ${from} \u2192 ${to}`));
+    }
+  }
+  if (Object.keys(updated.devDependencies).length > 0) {
+    console.log(chalk4.cyan("\n  Updated devDependencies:"));
+    for (const [pkg, { from, to }] of Object.entries(updated.devDependencies)) {
+      console.log(chalk4.yellow(`    ~ ${pkg}: ${from} \u2192 ${to}`));
+    }
+  }
+  if (Object.keys(added.scripts).length > 0) {
+    console.log(chalk4.cyan("\n  New scripts:"));
+    for (const [script, cmd] of Object.entries(added.scripts)) {
+      console.log(chalk4.green(`    + ${script}: ${String(cmd).substring(0, 50)}...`));
+    }
+  }
+  if (Object.keys(updated.scripts).length > 0) {
+    console.log(chalk4.cyan("\n  Updated scripts:"));
+    for (const [script, { from, to }] of Object.entries(updated.scripts)) {
+      console.log(chalk4.yellow(`    ~ ${script}:`));
+      console.log(chalk4.red(`      - ${from.substring(0, 60)}${from.length > 60 ? "..." : ""}`));
+      console.log(chalk4.green(`      + ${to.substring(0, 60)}${to.length > 60 ? "..." : ""}`));
+    }
+  }
+}
+function hasChanges(changes) {
+  const { added, updated } = changes.changes;
+  return Object.keys(added.dependencies).length > 0 || Object.keys(added.devDependencies).length > 0 || Object.keys(added.scripts).length > 0 || Object.keys(updated.dependencies).length > 0 || Object.keys(updated.devDependencies).length > 0 || Object.keys(updated.scripts).length > 0;
+}
+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 templateDir = getTemplateDir3();
+  const updateAll = options.all || !options.packages && !options.config && !options.workflows && !options.services && !options.scripts && !options.dependencies;
+  const updateTargets = {
+    packages: updateAll || options.packages,
+    config: updateAll || options.config,
+    workflows: updateAll || options.workflows,
+    services: updateAll || options.services,
+    scripts: updateAll || options.scripts,
+    dependencies: updateAll || options.dependencies
+  };
+  const spinner = ora3("Analyzing changes...").start();
+  const allFileChanges = [];
+  let dependencyChanges = null;
+  if (updateTargets.config) {
+    for (const file of TEMPLATE_DIRS.config) {
+      const srcFile = path4.join(templateDir, file);
+      const destFile = path4.join(projectDir, file);
+      if (fs4.existsSync(srcFile)) {
+        if (!fs4.existsSync(destFile)) {
+          allFileChanges.push({
+            type: "add",
+            relativePath: file,
+            srcPath: srcFile,
+            destPath: destFile,
+            category: "config"
+          });
+        } else if (!compareFiles(srcFile, destFile)) {
+          allFileChanges.push({
+            type: "modify",
+            relativePath: file,
+            srcPath: srcFile,
+            destPath: destFile,
+            category: "config"
+          });
+        }
+      }
+    }
+    allFileChanges.push(
+      ...collectFileChanges(
+        path4.join(templateDir, ".husky"),
+        path4.join(projectDir, ".husky"),
+        "config",
+        ".husky"
+      )
+    );
+    allFileChanges.push(
+      ...collectFileChanges(
+        path4.join(templateDir, ".vscode"),
+        path4.join(projectDir, ".vscode"),
+        "config",
+        ".vscode"
+      )
+    );
+  }
+  if (updateTargets.workflows) {
+    allFileChanges.push(
+      ...collectFileChanges(
+        path4.join(templateDir, ".github"),
+        path4.join(projectDir, ".github"),
+        "workflows",
+        ".github"
+      )
+    );
+  }
+  if (updateTargets.services) {
+    allFileChanges.push(
+      ...collectFileChanges(
+        path4.join(templateDir, "services"),
+        path4.join(projectDir, "services"),
+        "services",
+        "services"
+      )
+    );
+    allFileChanges.push(
+      ...collectFileChanges(
+        path4.join(templateDir, "docker"),
+        path4.join(projectDir, "docker"),
+        "services",
+        "docker"
+      )
+    );
+  }
+  if (updateTargets.scripts) {
+    allFileChanges.push(
+      ...collectFileChanges(
+        path4.join(templateDir, "scripts"),
+        path4.join(projectDir, "scripts"),
+        "scripts",
+        "scripts"
+      )
+    );
+  }
+  if (updateTargets.packages) {
+    const existingPackages = fs4.existsSync(path4.join(projectDir, "packages")) ? fs4.readdirSync(path4.join(projectDir, "packages")).filter((f) => fs4.statSync(path4.join(projectDir, "packages", f)).isDirectory()) : [];
+    for (const pkg of SHARED_PACKAGES) {
+      if (existingPackages.includes(pkg)) {
+        allFileChanges.push(
+          ...collectFileChanges(
+            path4.join(templateDir, "packages", pkg),
+            path4.join(projectDir, "packages", pkg),
+            "packages",
+            path4.join("packages", pkg)
+          )
+        );
+      }
+    }
+  }
+  if (updateTargets.dependencies) {
+    dependencyChanges = collectDependencyChanges(
+      path4.join(templateDir, "package.json"),
+      path4.join(projectDir, "package.json")
+    );
+  }
+  spinner.stop();
+  const addedFiles = allFileChanges.filter((c) => c.type === "add");
+  const modifiedFiles = allFileChanges.filter((c) => c.type === "modify");
+  const deletedFiles = allFileChanges.filter((c) => c.type === "delete");
+  if (addedFiles.length === 0 && modifiedFiles.length === 0 && deletedFiles.length === 0 && (!dependencyChanges || !hasChanges(dependencyChanges))) {
+    console.log(chalk4.green("\u2713 Your project is up to date! No changes needed.\n"));
+    return;
+  }
+  console.log(chalk4.bold("\u{1F4CB} Changes to apply:\n"));
+  const categories = [...new Set(allFileChanges.map((c) => c.category))];
+  for (const category of categories) {
+    const categoryChanges = allFileChanges.filter((c) => c.category === category);
+    if (categoryChanges.length === 0) continue;
+    const categoryNames = {
+      config: "Configuration files",
+      workflows: "GitHub workflows",
+      services: "Docker services",
+      scripts: "Scripts",
+      packages: "Shared packages"
+    };
+    console.log(chalk4.cyan.bold(`
+${categoryNames[category] || category}:`));
+    const added = categoryChanges.filter((c) => c.type === "add");
+    const modified = categoryChanges.filter((c) => c.type === "modify");
+    const deleted = categoryChanges.filter((c) => c.type === "delete");
+    if (added.length > 0) {
+      console.log(chalk4.green(`  New files (${added.length}):`));
+      for (const change of added.slice(0, 10)) {
+        console.log(chalk4.green(`    + ${change.relativePath}`));
+      }
+      if (added.length > 10) {
+        console.log(chalk4.gray(`    ... and ${added.length - 10} more files`));
+      }
+    }
+    if (modified.length > 0) {
+      console.log(chalk4.yellow(`  Modified files (${modified.length}):`));
+      for (const change of modified.slice(0, 10)) {
+        console.log(chalk4.yellow(`    ~ ${change.relativePath}`));
+      }
+      if (modified.length > 10) {
+        console.log(chalk4.gray(`    ... and ${modified.length - 10} more files`));
+      }
+    }
+    if (deleted.length > 0) {
+      console.log(chalk4.red(`  Deleted files (${deleted.length}):`));
+      for (const change of deleted.slice(0, 10)) {
+        console.log(chalk4.red(`    - ${change.relativePath}`));
+      }
+      if (deleted.length > 10) {
+        console.log(chalk4.gray(`    ... and ${deleted.length - 10} more files`));
+      }
+    }
+  }
+  if (dependencyChanges && hasChanges(dependencyChanges)) {
+    console.log(chalk4.cyan.bold("\nPackage.json changes:"));
+    displayDependencyChanges(dependencyChanges);
+  }
+  console.log("");
+  if (options.preview) {
+    const { showDiff } = await inquirer3.prompt([
+      {
+        type: "confirm",
+        name: "showDiff",
+        message: "Show detailed file differences?",
+        default: false
+      }
+    ]);
+    if (showDiff) {
+      for (const change of modifiedFiles) {
+        console.log(chalk4.bold(`
+${change.relativePath}:`));
+        showFileDiff(change.srcPath, change.destPath);
+      }
+    }
+  }
+  if (options.dryRun) {
+    console.log(chalk4.blue("\ni Dry run mode - no changes were made.\n"));
+    return;
+  }
+  const { selectedCategories } = await inquirer3.prompt([
+    {
+      type: "checkbox",
+      name: "selectedCategories",
+      message: "Select which changes to apply:",
+      choices: [
+        ...categories.map((cat) => {
+          const count = allFileChanges.filter((c) => c.category === cat).length;
+          const categoryNames = {
+            config: "Configuration files",
+            workflows: "GitHub workflows",
+            services: "Docker services",
+            scripts: "Scripts",
+            packages: "Shared packages"
+          };
+          return {
+            name: `${categoryNames[cat] || cat} (${count} files)`,
+            value: cat,
+            checked: true
+          };
+        }),
+        ...dependencyChanges && hasChanges(dependencyChanges) ? [
+          {
+            name: "Package.json dependencies",
+            value: "dependencies",
+            checked: true
+          }
+        ] : []
+      ]
+    }
+  ]);
+  if (selectedCategories.length === 0) {
+    log("No changes selected. Update cancelled.", "warn");
+    return;
+  }
+  const { confirm } = await inquirer3.prompt([
+    {
+      type: "confirm",
+      name: "confirm",
+      message: `Apply ${selectedCategories.length} category(ies) of changes?`,
+      default: true
+    }
+  ]);
+  if (!confirm) {
+    log("Update cancelled.", "warn");
+    return;
+  }
+  const applySpinner = ora3("Applying changes...").start();
+  let appliedFiles = 0;
+  let deletedFilesCount = 0;
+  for (const change of allFileChanges) {
+    if (!selectedCategories.includes(change.category)) continue;
+    if (change.type === "delete") {
+      if (fs4.existsSync(change.destPath)) {
+        fs4.removeSync(change.destPath);
+        deletedFilesCount++;
+      }
+    } else {
+      fs4.ensureDirSync(path4.dirname(change.destPath));
+      fs4.copySync(change.srcPath, change.destPath, { overwrite: true });
+      appliedFiles++;
+    }
+  }
+  if (deletedFilesCount > 0) {
+    cleanEmptyDirectories(projectDir);
+  }
+  const dotfilesToRename = [
+    { src: path4.join(projectDir, "gitignore"), dest: path4.join(projectDir, ".gitignore") },
+    {
+      src: path4.join(projectDir, "lintstagedrc.cjs"),
+      dest: path4.join(projectDir, ".lintstagedrc.cjs")
+    },
+    {
+      src: path4.join(projectDir, "apps", "gitkeep"),
+      dest: path4.join(projectDir, "apps", ".gitkeep")
+    },
+    {
+      src: path4.join(projectDir, "services", "postgres", "init", "gitkeep"),
+      dest: path4.join(projectDir, "services", "postgres", "init", ".gitkeep")
+    }
+  ];
+  for (const { src, dest } of dotfilesToRename) {
+    if (fs4.existsSync(src)) {
+      fs4.renameSync(src, dest);
+    }
+  }
+  if (selectedCategories.includes("dependencies") && dependencyChanges) {
+    const templatePkgPath = path4.join(templateDir, "package.json");
+    const projectPkgPath = path4.join(projectDir, "package.json");
+    const templatePkg = fs4.readJsonSync(templatePkgPath);
+    const projectPkg = fs4.readJsonSync(projectPkgPath);
+    if (templatePkg.devDependencies) {
+      projectPkg.devDependencies = {
+        ...projectPkg.devDependencies,
+        ...templatePkg.devDependencies
+      };
+    }
+    if (templatePkg.dependencies) {
+      projectPkg.dependencies = {
+        ...projectPkg.dependencies,
+        ...templatePkg.dependencies
+      };
+    }
+    if (templatePkg.scripts) {
+      projectPkg.scripts = {
+        ...projectPkg.scripts,
+        ...templatePkg.scripts
+      };
+    }
+    if (projectPkg.dependencies) {
+      projectPkg.dependencies = sortObject(projectPkg.dependencies);
+    }
+    if (projectPkg.devDependencies) {
+      projectPkg.devDependencies = sortObject(projectPkg.devDependencies);
+    }
+    fs4.writeJsonSync(projectPkgPath, projectPkg, { spaces: 2 });
+  }
+  const summary = [];
+  if (appliedFiles > 0) summary.push(`${appliedFiles} files updated`);
+  if (deletedFilesCount > 0) summary.push(`${deletedFilesCount} files deleted`);
+  applySpinner.succeed(summary.join(", ") || "No file changes applied");
+  if (selectedCategories.includes("dependencies") && dependencyChanges && hasChanges(dependencyChanges)) {
+    const pm = detectPackageManager(projectDir);
+    const installCmd = getInstallCommand(pm);
+    console.log(chalk4.blue(`
+\u{1F4E6} Installing dependencies with ${pm}...
+`));
+    try {
+      execInherit(installCmd, projectDir);
+      console.log(chalk4.green("\n\u2713 Dependencies installed"));
+    } catch {
+      console.log(
+        chalk4.yellow(`
+! Failed to install dependencies. Run "${installCmd}" manually.`)
+      );
+    }
+  }
+  console.log("\n" + chalk4.green.bold("\u2728 Update complete!\n"));
+}
+function cleanEmptyDirectories(dir) {
+  if (!fs4.existsSync(dir)) return;
+  const entries = fs4.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const fullPath = path4.join(dir, entry.name);
+      cleanEmptyDirectories(fullPath);
+      const remaining = fs4.readdirSync(fullPath);
+      if (remaining.length === 0) {
+        fs4.rmdirSync(fullPath);
+      }
+    }
+  }
+}
+function sortObject(obj) {
+  return Object.keys(obj).sort().reduce(
+    (acc, key) => {
+      acc[key] = obj[key];
+      return acc;
+    },
+    {}
+  );
+}
+
+// src/index.ts
+var __dirname4 = dirname(fileURLToPath4(import.meta.url));
+var packageJson = JSON.parse(readFileSync(join(__dirname4, "../package.json"), "utf-8"));
+var program = new Command();
+program.name("nexu-app").description("CLI to create and update Nexu monorepo projects").version(packageJson.version);
+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("init [project-name]").description("Initialize a new Nexu monorepo project").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) => {
+  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("--scripts", "Update only scripts").option("-d, --dependencies", "Update only package.json dependencies").option("--all", "Update everything (default)").option("--dry-run", "Show what would be updated without making changes").option("--preview", "Show detailed file differences before applying").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();