create-nexu 1.0.2 → 1.1.0

package/dist/index.js

@@ -80,6 +80,16 @@ function exec(command, cwd) {
     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 copyWithMerge(src, dest, overwrite = false) {
   if (fs.existsSync(dest) && !overwrite) {
     if (fs.statSync(src).isDirectory() && fs.statSync(dest).isDirectory()) {
@@ -107,6 +117,28 @@ function log(message, type = "info") {
   };
   console.log(`${colors[type](icons[type])} ${message}`);
 }
+function getRunCommand(pm) {
+  switch (pm) {
+    case "pnpm":
+      return "pnpm";
+    case "yarn":
+      return "yarn";
+    case "npm":
+    default:
+      return "npm run";
+  }
+}
+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);
@@ -327,6 +359,23 @@ async function init(projectName, options) {
       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",
@@ -364,9 +413,22 @@ async function init(projectName, options) {
     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 packageJson = fs3.readJsonSync(packageJsonPath);
+  packageJson.name = projectName;
+  delete packageJson.packageManager;
+  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 });
   const packagesToRemove = SHARED_PACKAGES.filter((pkg) => !selectedPackages.includes(pkg));
   if (packagesToRemove.length > 0) {
     const removeSpinner = ora2("Removing unselected packages...").start();
@@ -394,20 +456,19 @@ async function init(projectName, options) {
   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"];
+  if (packageManager === "yarn") {
+    fs3.removeSync(path3.join(projectDir, "pnpm-workspace.yaml"));
+    fs3.removeSync(path3.join(projectDir, ".npmrc"));
+    const updatedPkg = fs3.readJsonSync(packageJsonPath);
+    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.workspaces = ["apps/*", "packages/*"];
+    fs3.writeJsonSync(packageJsonPath, updatedPkg, { spaces: 2 });
   }
-  fs3.writeJsonSync(packageJsonPath, packageJson, { spaces: 2 });
   if (!options.skipGit) {
     const gitSpinner = ora2("Initializing git repository...").start();
     try {
@@ -419,13 +480,21 @@ async function init(projectName, options) {
       gitSpinner.warn("Failed to initialize git repository");
     }
   }
+  const runCmd = getRunCommand(packageManager);
   if (!options.skipInstall) {
-    const installSpinner = ora2("Installing dependencies...").start();
+    console.log(chalk3.blue(`
+\u{1F4E6} Installing dependencies with ${packageManager}...
+`));
     try {
-      exec("pnpm install", projectDir);
-      installSpinner.succeed("Dependencies installed");
+      execInherit(getInstallCommand(packageManager), projectDir);
+      console.log(chalk3.green("\n\u2713 Dependencies installed"));
     } catch {
-      installSpinner.warn('Failed to install dependencies. Run "pnpm install" manually.');
+      console.log(
+        chalk3.yellow(
+          `
+! Failed to install dependencies. Run "${getInstallCommand(packageManager)}" manually.`
+        )
+      );
     }
   }
   console.log("\n" + chalk3.green.bold("\u2728 Project created successfully!\n"));
@@ -434,11 +503,11 @@ async function init(projectName, options) {
     console.log(chalk3.cyan(`  cd ${projectName}`));
   }
   if (options.skipInstall) {
-    console.log(chalk3.cyan("  pnpm install"));
+    console.log(chalk3.cyan(`  ${getInstallCommand(packageManager)}`));
   }
-  console.log(chalk3.cyan("  pnpm dev"));
+  console.log(chalk3.cyan(`  ${runCmd} dev`));
   console.log("\nTo create an app:");
-  console.log(chalk3.cyan("  pnpm generate:app <name> <port>"));
+  console.log(chalk3.cyan(`  ${runCmd} generate:app <name> <port>`));
   console.log("\nTo update with latest features:");
   console.log(chalk3.cyan("  npx create-nexu update"));
   console.log("");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-nexu",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "CLI to create and update Nexu monorepo projects",
   "author": "Nexu Team",
   "license": "MIT",

package/templates/default/.eslintrc.js

@@ -61,6 +61,7 @@ module.exports = {
     '*.config.js',
     '*.config.mjs',
     '.eslintrc.js',
+    '.lintstagedrc.cjs',
     'commitlint.config.js',
   ],
 };

package/templates/default/.github/workflows/deploy-dev.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Quality Check
         uses: ./.github/actions/quality
@@ -30,7 +30,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Build
         uses: ./.github/actions/build

package/templates/default/.github/workflows/deploy-prod.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Quality Check
         uses: ./.github/actions/quality
@@ -30,7 +30,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Build
         uses: ./.github/actions/build

package/templates/default/.github/workflows/deploy-rec.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Quality Check
         uses: ./.github/actions/quality
@@ -30,7 +30,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Build
         uses: ./.github/actions/build

package/templates/default/package.json

@@ -17,40 +17,29 @@
     "docker:dev": "docker-compose -f docker/docker-compose.dev.yml up",
     "docker:build": "docker-compose -f docker/docker-compose.prod.yml build",
     "docker:prod": "docker-compose -f docker/docker-compose.prod.yml up -d",
-    "generate:app": "./scripts/generate-app.sh",
-    "generate:template": "./scripts/generate-template.sh",
-    "publish:cli": "./scripts/publish-cli.sh",
+    "generate:app": "node scripts/generate-app.mjs",
     "changeset": "changeset",
     "version-packages": "changeset version",
     "release": "changeset publish"
   },
   "devDependencies": {
     "@changesets/cli": "^2.27.0",
-    "@commitlint/cli": "^19.0.0",
-    "@commitlint/config-conventional": "^19.0.0",
+    "@commitlint/cli": "^20.3.1",
+    "@commitlint/config-conventional": "^20.3.1",
     "@typescript-eslint/eslint-plugin": "^7.0.0",
     "@typescript-eslint/parser": "^7.0.0",
     "@vitest/coverage-v8": "^2.0.0",
     "@vitest/ui": "^2.0.0",
     "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
+    "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-import": "^2.29.0",
-    "eslint-plugin-unused-imports": "^3.1.0",
+    "eslint-plugin-unused-imports": "^4.3.0",
     "husky": "^9.0.0",
-    "lint-staged": "^15.0.0",
-    "prettier": "^3.2.0",
-    "prettier-plugin-tailwindcss": "^0.5.0",
-    "turbo": "^2.0.0",
+    "lint-staged": "^16.2.7",
+    "prettier": "^3.8.0",
+    "prettier-plugin-tailwindcss": "^0.7.2",
+    "turbo": "^2.7.5",
     "typescript": "^5.4.0",
     "vitest": "^2.0.0"
-  },
-  "lint-staged": {
-    "*.{ts,tsx,js,jsx}": [
-      "eslint --fix",
-      "prettier --write"
-    ],
-    "*.{json,md,yml,yaml}": [
-      "prettier --write"
-    ]
   }
 }

package/templates/default/packages/logger/package.json

@@ -20,7 +20,7 @@
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
-    "@types/node": "^20.0.0",
+    "@types/node": "^25.0.9",
     "tsup": "^8.0.0",
     "typescript": "^5.4.0"
   }

package/templates/default/packages/ui/package.json

@@ -25,14 +25,14 @@
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
-    "@types/react": "^18.2.0",
-    "@types/react-dom": "^18.2.0",
-    "react": "^18.2.0",
+    "@types/react": "^19.2.8",
+    "@types/react-dom": "^19.2.3",
+    "react": "^19.2.3",
     "tsup": "^8.0.0",
     "typescript": "^5.4.0"
   },
   "peerDependencies": {
-    "react": "^18.2.0",
+    "react": "^19.2.3",
     "react-dom": "^18.2.0"
   }
 }

package/templates/default/packages/ui/src/components/Button.tsx

@@ -31,19 +31,12 @@ export const Button: React.FC<ButtonProps> = ({
 }) => {
   return (
     <button
-      className={`
-        inline-flex items-center justify-center rounded-lg font-medium
-        transition-colors duration-200 focus:outline-none focus:ring-2 focus:ring-offset-2
-        disabled:cursor-not-allowed disabled:opacity-50
-        ${variantStyles[variant]}
-        ${sizeStyles[size]}
-        ${className}
-      `}
+      className={`inline-flex items-center justify-center rounded-lg font-medium transition-colors duration-200 focus:ring-2 focus:ring-offset-2 focus:outline-none disabled:cursor-not-allowed disabled:opacity-50 ${variantStyles[variant]} ${sizeStyles[size]} ${className} `}
       disabled={disabled || isLoading}
       {...props}
     >
       {isLoading && (
-        <svg className="-ml-1 mr-2 h-4 w-4 animate-spin" fill="none" viewBox="0 0 24 24">
+        <svg className="mr-2 -ml-1 h-4 w-4 animate-spin" fill="none" viewBox="0 0 24 24">
           <circle
             className="opacity-25"
             cx="12"

package/templates/default/packages/ui/src/components/Card.tsx

@@ -28,12 +28,7 @@ export const Card: React.FC<CardProps> = ({
 }) => {
   return (
     <div
-      className={`
-        rounded-lg
-        ${variantStyles[variant]}
-        ${paddingStyles[padding]}
-        ${className}
-      `}
+      className={`rounded-lg ${variantStyles[variant]} ${paddingStyles[padding]} ${className} `}
       {...props}
     >
       {children}

package/templates/default/packages/ui/src/components/Input.tsx

@@ -20,13 +20,7 @@ export const Input = React.forwardRef<HTMLInputElement, InputProps>(
         <input
           ref={ref}
           id={inputId}
-          className={`
-            w-full rounded-lg border px-3 py-2 shadow-sm
-            focus:border-blue-500 focus:outline-none focus:ring-2 focus:ring-blue-500
-            disabled:cursor-not-allowed disabled:bg-gray-100
-            ${error ? 'border-red-500 focus:border-red-500 focus:ring-red-500' : 'border-gray-300'}
-            ${className}
-          `}
+          className={`w-full rounded-lg border px-3 py-2 shadow-sm focus:border-blue-500 focus:ring-2 focus:ring-blue-500 focus:outline-none disabled:cursor-not-allowed disabled:bg-gray-100 ${error ? 'border-red-500 focus:border-red-500 focus:ring-red-500' : 'border-gray-300'} ${className} `}
           aria-invalid={error ? 'true' : 'false'}
           aria-describedby={
             error ? `${inputId}-error` : helperText ? `${inputId}-helper` : undefined

package/templates/default/scripts/deploy.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import { detectPackageManager, getRunCommand } from './lib/package-manager.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const ROOT_DIR = path.resolve(__dirname, '..');
+
+const environment = process.argv[2] || 'staging';
+const pm = detectPackageManager(ROOT_DIR);
+const runCmd = getRunCommand(pm);
+
+console.log(`🚀 Deploying to ${environment}...`);
+console.log(`📦 Using package manager: ${pm}`);
+
+function run(cmd) {
+  console.log(`> ${cmd}`);
+  execSync(cmd, { stdio: 'inherit', cwd: ROOT_DIR });
+}
+
+// Build all packages
+console.log('🔨 Building packages...');
+run(`${runCmd} build`);
+
+// Build Docker images
+console.log('🐳 Building Docker images...');
+run('docker-compose -f docker/docker-compose.prod.yml build');
+
+// Push images (if deploying to production)
+if (environment === 'production') {
+  console.log('📤 Pushing images to registry...');
+  run('docker-compose -f docker/docker-compose.prod.yml push');
+}
+
+console.log('');
+console.log(`✅ Deployment to ${environment} complete!`);
+console.log('');

package/templates/default/scripts/generate-app.mjs

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Colors for console output
+const colors = {
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  blue: '\x1b[34m',
+  yellow: '\x1b[33m',
+  reset: '\x1b[0m',
+};
+
+const log = {
+  info: (msg) => console.log(`${colors.blue}${msg}${colors.reset}`),
+  success: (msg) => console.log(`${colors.green}${msg}${colors.reset}`),
+  warn: (msg) => console.log(`${colors.yellow}${msg}${colors.reset}`),
+  error: (msg) => console.log(`${colors.red}${msg}${colors.reset}`),
+};
+
+// Get directories
+const ROOT_DIR = path.resolve(__dirname, '..');
+const APPS_DIR = path.join(ROOT_DIR, 'apps');
+const DOCKER_DIR = path.join(ROOT_DIR, 'docker');
+
+// Get arguments
+const args = process.argv.slice(2);
+const appName = args[0];
+const port = args[1] || '3000';
+
+// Show usage
+if (!appName) {
+  log.info('Usage: pnpm generate:app <app-name> [port]');
+  console.log('');
+  log.info('Examples:');
+  console.log('  pnpm generate:app web 3000');
+  console.log('  pnpm generate:app api 4000');
+  process.exit(1);
+}
+
+const APP_DIR = path.join(APPS_DIR, appName);
+
+// Check if app already exists
+if (fs.existsSync(APP_DIR)) {
+  log.error(`Error: L'application '${appName}' existe déjà dans apps/`);
+  process.exit(1);
+}
+
+log.info(`Creating app: ${appName} (port: ${port})`);
+
+// Create app directory structure
+fs.mkdirSync(path.join(APP_DIR, 'src'), { recursive: true });
+fs.mkdirSync(path.join(APP_DIR, 'docker'), { recursive: true });
+
+// Create Dockerfile
+const dockerfile = `# ====== Base ======
+FROM node:20-alpine AS base
+RUN corepack enable && corepack prepare pnpm@9.0.0 --activate
+WORKDIR /app
+
+# ====== Dependencies ======
+FROM base AS deps
+COPY pnpm-lock.yaml pnpm-workspace.yaml package.json ./
+COPY apps/${appName}/package.json ./apps/${appName}/
+COPY packages/*/package.json ./packages/
+RUN pnpm install --frozen-lockfile
+
+# ====== Development ======
+FROM base AS development
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+WORKDIR /app/apps/${appName}
+EXPOSE ${port}
+CMD ["pnpm", "dev"]
+
+# ====== Builder ======
+FROM base AS builder
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+RUN pnpm turbo build --filter=@repo/${appName}
+
+# ====== Production ======
+FROM node:20-alpine AS production
+WORKDIR /app
+ENV NODE_ENV=production
+
+COPY --from=builder /app/apps/${appName}/dist ./dist
+COPY --from=builder /app/apps/${appName}/package.json ./
+
+RUN npm install --omit=dev
+
+EXPOSE ${port}
+CMD ["node", "dist/index.js"]
+`;
+
+fs.writeFileSync(path.join(APP_DIR, 'docker', 'Dockerfile'), dockerfile);
+
+// Create docker-compose.yml for the app
+const dockerCompose = `services:
+  ${appName}:
+    build:
+      context: ../..
+      dockerfile: apps/${appName}/docker/Dockerfile
+      target: development
+    ports:
+      - "${port}:${port}"
+    environment:
+      - NODE_ENV=development
+      - PORT=${port}
+    volumes:
+      - ../../apps/${appName}:/app/apps/${appName}
+      - ../../packages:/app/packages
+      - /app/node_modules
+      - /app/apps/${appName}/node_modules
+    command: pnpm dev
+`;
+
+fs.writeFileSync(path.join(APP_DIR, 'docker-compose.yml'), dockerCompose);
+
+// Create docker-compose.prod.yml for the app
+const dockerComposeProd = `services:
+  ${appName}:
+    build:
+      context: ../..
+      dockerfile: apps/${appName}/docker/Dockerfile
+      target: production
+    ports:
+      - "${port}:${port}"
+    environment:
+      - NODE_ENV=production
+      - PORT=${port}
+    restart: unless-stopped
+`;
+
+fs.writeFileSync(path.join(APP_DIR, 'docker-compose.prod.yml'), dockerComposeProd);
+
+// Update main docker-compose.yml
+function updateMainCompose() {
+  const mainComposePath = path.join(DOCKER_DIR, 'docker-compose.yml');
+  const includePath = `../apps/${appName}/docker-compose.yml`;
+
+  // Create docker directory if it doesn't exist
+  if (!fs.existsSync(DOCKER_DIR)) {
+    fs.mkdirSync(DOCKER_DIR, { recursive: true });
+  }
+
+  // Create main compose if it doesn't exist
+  if (!fs.existsSync(mainComposePath)) {
+    const content = `# Main docker-compose - includes all apps
+# Each app has its own docker-compose.yml in apps/<app-name>/
+
+include:
+  - path: ${includePath}
+`;
+    fs.writeFileSync(mainComposePath, content);
+    return;
+  }
+
+  // Read existing file
+  let content = fs.readFileSync(mainComposePath, 'utf-8');
+
+  // Check if app is already included
+  if (content.includes(`apps/${appName}/docker-compose.yml`)) {
+    return;
+  }
+
+  // If include is empty array [], replace it
+  if (content.includes('include: []')) {
+    content = content.replace('include: []', `include:\n  - path: ${includePath}`);
+    fs.writeFileSync(mainComposePath, content);
+  } else {
+    // Append to existing include list
+    content = content.trimEnd() + `\n  - path: ${includePath}\n`;
+    fs.writeFileSync(mainComposePath, content);
+  }
+}
+
+updateMainCompose();
+
+log.success(`\n✓ Created app: apps/${appName}`);
+console.log('');
+log.warn('Files created:');
+console.log(`  - apps/${appName}/docker/Dockerfile`);
+console.log(`  - apps/${appName}/docker-compose.yml`);
+console.log(`  - apps/${appName}/docker-compose.prod.yml`);
+console.log('');
+log.warn('Commands:');
+console.log(`  Dev (app only):  cd apps/${appName} && docker compose up`);
+console.log('  Dev (all apps):  pnpm docker:dev');
+console.log(`  Prod (app only): cd apps/${appName} && docker compose -f docker-compose.prod.yml up -d`);

package/templates/default/scripts/lib/package-manager.mjs

@@ -0,0 +1,186 @@
+/**
+ * Package manager detection and utilities
+ * Supports: npm, yarn, pnpm
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { execSync, spawnSync } from 'child_process';
+
+/**
+ * Detect which package manager is being used in a project
+ * @param {string} projectDir - The project directory to check
+ * @returns {'pnpm' | 'yarn' | 'npm'} The detected package manager
+ */
+export function detectPackageManager(projectDir = process.cwd()) {
+  // Check for lock files
+  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';
+  }
+
+  // Check packageManager field in package.json
+  const packageJsonPath = path.join(projectDir, 'package.json');
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+      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 {
+      // Ignore parse errors
+    }
+  }
+
+  // Check npm_config_user_agent environment variable (set by package managers)
+  const userAgent = process.env.npm_config_user_agent || '';
+  if (userAgent.includes('pnpm')) return 'pnpm';
+  if (userAgent.includes('yarn')) return 'yarn';
+
+  // Default to npm
+  return 'npm';
+}
+
+/**
+ * Check if a package manager is installed
+ * @param {string} pm - Package manager name
+ * @returns {boolean}
+ */
+export function isPackageManagerInstalled(pm) {
+  try {
+    const result = spawnSync(process.platform === 'win32' ? 'where' : 'which', [pm], {
+      stdio: 'pipe',
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get the run command for a package manager
+ * @param {'pnpm' | 'yarn' | 'npm'} pm
+ * @returns {string}
+ */
+export function getRunCommand(pm) {
+  switch (pm) {
+    case 'pnpm':
+      return 'pnpm';
+    case 'yarn':
+      return 'yarn';
+    case 'npm':
+    default:
+      return 'npm run';
+  }
+}
+
+/**
+ * Get the execute command (for running binaries)
+ * @param {'pnpm' | 'yarn' | 'npm'} pm
+ * @returns {string}
+ */
+export function getExecCommand(pm) {
+  switch (pm) {
+    case 'pnpm':
+      return 'pnpm exec';
+    case 'yarn':
+      return 'yarn';
+    case 'npm':
+    default:
+      return 'npx';
+  }
+}
+
+/**
+ * Get the install command
+ * @param {'pnpm' | 'yarn' | 'npm'} pm
+ * @param {object} options
+ * @param {boolean} options.frozen - Use frozen lockfile
+ * @returns {string}
+ */
+export function getInstallCommand(pm, options = {}) {
+  const { frozen = false } = options;
+
+  switch (pm) {
+    case 'pnpm':
+      return frozen ? 'pnpm install --frozen-lockfile' : 'pnpm install';
+    case 'yarn':
+      return frozen ? 'yarn install --frozen-lockfile' : 'yarn install';
+    case 'npm':
+    default:
+      return frozen ? 'npm ci' : 'npm install';
+  }
+}
+
+/**
+ * Get the add dependency command
+ * @param {'pnpm' | 'yarn' | 'npm'} pm
+ * @param {string} pkg - Package name
+ * @param {object} options
+ * @param {boolean} options.dev - Install as dev dependency
+ * @returns {string}
+ */
+export function getAddCommand(pm, pkg, options = {}) {
+  const { dev = false } = options;
+
+  switch (pm) {
+    case 'pnpm':
+      return dev ? `pnpm add -D ${pkg}` : `pnpm add ${pkg}`;
+    case 'yarn':
+      return dev ? `yarn add -D ${pkg}` : `yarn add ${pkg}`;
+    case 'npm':
+    default:
+      return dev ? `npm install -D ${pkg}` : `npm install ${pkg}`;
+  }
+}
+
+/**
+ * Get workspace filter command
+ * @param {'pnpm' | 'yarn' | 'npm'} pm
+ * @param {string} workspace - Workspace name
+ * @returns {string}
+ */
+export function getWorkspaceFilter(pm, workspace) {
+  switch (pm) {
+    case 'pnpm':
+      return `--filter=${workspace}`;
+    case 'yarn':
+      return `workspace ${workspace}`;
+    case 'npm':
+    default:
+      return `-w ${workspace}`;
+  }
+}
+
+/**
+ * Run a command with the detected package manager
+ * @param {string} script - Script to run
+ * @param {object} options
+ * @param {string} options.cwd - Working directory
+ * @param {'pnpm' | 'yarn' | 'npm'} options.pm - Package manager (auto-detected if not provided)
+ */
+export function runScript(script, options = {}) {
+  const { cwd = process.cwd(), pm = detectPackageManager(cwd) } = options;
+  const runCmd = getRunCommand(pm);
+  const cmd = `${runCmd} ${script}`;
+  console.log(`> ${cmd}`);
+  execSync(cmd, { stdio: 'inherit', cwd });
+}
+
+export default {
+  detectPackageManager,
+  isPackageManagerInstalled,
+  getRunCommand,
+  getExecCommand,
+  getInstallCommand,
+  getAddCommand,
+  getWorkspaceFilter,
+  runScript,
+};

package/templates/default/scripts/setup.mjs

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import {
+  detectPackageManager,
+  isPackageManagerInstalled,
+  getInstallCommand,
+  getRunCommand,
+} from './lib/package-manager.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const ROOT_DIR = path.resolve(__dirname, '..');
+
+// Detect package manager
+const pm = detectPackageManager(ROOT_DIR);
+const runCmd = getRunCommand(pm);
+
+console.log('🚀 Setting up monorepo...');
+console.log(`📦 Using package manager: ${pm}`);
+
+function run(cmd) {
+  console.log(`> ${cmd}`);
+  execSync(cmd, { stdio: 'inherit', cwd: ROOT_DIR });
+}
+
+// Check if package manager is installed
+if (!isPackageManagerInstalled(pm)) {
+  console.log(`📦 Installing ${pm}...`);
+  if (pm === 'pnpm') {
+    run('npm install -g pnpm');
+  } else if (pm === 'yarn') {
+    run('npm install -g yarn');
+  }
+}
+
+// Install dependencies
+console.log('📦 Installing dependencies...');
+run(getInstallCommand(pm));
+
+// Setup husky
+console.log('🐶 Setting up Husky...');
+run(`${runCmd} prepare`);
+
+// Create environment files
+console.log('🔐 Creating environment files...');
+
+const envPath = path.join(ROOT_DIR, '.env');
+if (!fs.existsSync(envPath)) {
+  const envContent = `# Database
+DATABASE_URL=postgresql://postgres:postgres@localhost:5432/nexu
+DB_USER=postgres
+DB_PASSWORD=postgres
+DB_NAME=nexu
+
+# API
+API_URL=http://localhost:4000
+
+# App
+NODE_ENV=development
+`;
+  fs.writeFileSync(envPath, envContent);
+  console.log('✅ Created .env file');
+}
+
+const webEnvPath = path.join(ROOT_DIR, 'apps', 'web', '.env.local');
+const webAppsDir = path.join(ROOT_DIR, 'apps', 'web');
+if (fs.existsSync(webAppsDir) && !fs.existsSync(webEnvPath)) {
+  const webEnvContent = `NEXT_PUBLIC_API_URL=http://localhost:4000
+`;
+  fs.writeFileSync(webEnvPath, webEnvContent);
+  console.log('✅ Created apps/web/.env.local');
+}
+
+const apiEnvPath = path.join(ROOT_DIR, 'apps', 'api', '.env');
+const apiAppsDir = path.join(ROOT_DIR, 'apps', 'api');
+if (fs.existsSync(apiAppsDir) && !fs.existsSync(apiEnvPath)) {
+  const apiEnvContent = `DATABASE_URL=postgresql://postgres:postgres@localhost:5432/nexu
+PORT=4000
+NODE_ENV=development
+`;
+  fs.writeFileSync(apiEnvPath, apiEnvContent);
+  console.log('✅ Created apps/api/.env');
+}
+
+// Build packages
+console.log('🔨 Building packages...');
+run(`${runCmd} build`);
+
+console.log('');
+console.log('✅ Setup complete!');
+console.log('');
+console.log('Available commands:');
+console.log(`  ${runCmd} dev          - Start development servers`);
+console.log(`  ${runCmd} build        - Build all packages`);
+console.log(`  ${runCmd} lint         - Run linting`);
+console.log(`  ${runCmd} test         - Run tests`);
+console.log(`  ${runCmd} docker:dev   - Start with Docker (dev)`);
+console.log('');

package/templates/default/scripts/deploy.sh

@@ -1,25 +0,0 @@
-#!/bin/bash
-
-set -e
-
-ENVIRONMENT=${1:-staging}
-
-echo "🚀 Deploying to $ENVIRONMENT..."
-
-# Build all packages
-echo "🔨 Building packages..."
-pnpm build
-
-# Build Docker images
-echo "🐳 Building Docker images..."
-docker-compose -f docker/docker-compose.prod.yml build
-
-# Push images (if deploying to production)
-if [ "$ENVIRONMENT" = "production" ]; then
-    echo "📤 Pushing images to registry..."
-    docker-compose -f docker/docker-compose.prod.yml push
-fi
-
-echo ""
-echo "✅ Deployment to $ENVIRONMENT complete!"
-echo ""

package/templates/default/scripts/generate-app.sh

@@ -1,166 +0,0 @@
-#!/bin/bash
-
-set -e
-
-# Colors
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-BLUE='\033[0;34m'
-YELLOW='\033[1;33m'
-NC='\033[0m'
-
-# Get script directory
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-ROOT_DIR="$(dirname "$SCRIPT_DIR")"
-APPS_DIR="$ROOT_DIR/apps"
-DOCKER_DIR="$ROOT_DIR/docker"
-
-# Show usage
-if [ -z "$1" ]; then
-  echo -e "${BLUE}Usage:${NC} pnpm generate:app <app-name> [port]"
-  echo ""
-  echo -e "${BLUE}Exemples:${NC}"
-  echo "  pnpm generate:app web 3000"
-  echo "  pnpm generate:app api 4000"
-  exit 1
-fi
-
-APP_NAME=$1
-PORT=${2:-3000}
-APP_DIR="$APPS_DIR/$APP_NAME"
-
-# Check if app already exists
-if [ -d "$APP_DIR" ]; then
-  echo -e "${RED}Error:${NC} L'application '$APP_NAME' existe déjà dans apps/"
-  exit 1
-fi
-
-echo -e "${BLUE}Creating${NC} app: $APP_NAME (port: $PORT)"
-
-# Create app directory structure
-mkdir -p "$APP_DIR/src"
-mkdir -p "$APP_DIR/docker"
-
-# Create Dockerfile
-cat > "$APP_DIR/docker/Dockerfile" << EOF
-# ====== Base ======
-FROM node:20-alpine AS base
-RUN corepack enable && corepack prepare pnpm@9.0.0 --activate
-WORKDIR /app
-
-# ====== Dependencies ======
-FROM base AS deps
-COPY pnpm-lock.yaml pnpm-workspace.yaml package.json ./
-COPY apps/$APP_NAME/package.json ./apps/$APP_NAME/
-COPY packages/*/package.json ./packages/
-RUN pnpm install --frozen-lockfile
-
-# ====== Development ======
-FROM base AS development
-COPY --from=deps /app/node_modules ./node_modules
-COPY . .
-WORKDIR /app/apps/$APP_NAME
-EXPOSE $PORT
-CMD ["pnpm", "dev"]
-
-# ====== Builder ======
-FROM base AS builder
-COPY --from=deps /app/node_modules ./node_modules
-COPY . .
-RUN pnpm turbo build --filter=@repo/$APP_NAME
-
-# ====== Production ======
-FROM node:20-alpine AS production
-WORKDIR /app
-ENV NODE_ENV=production
-
-COPY --from=builder /app/apps/$APP_NAME/dist ./dist
-COPY --from=builder /app/apps/$APP_NAME/package.json ./
-
-RUN npm install --omit=dev
-
-EXPOSE $PORT
-CMD ["node", "dist/index.js"]
-EOF
-
-# Create docker-compose.yml for the app
-cat > "$APP_DIR/docker-compose.yml" << EOF
-services:
-  $APP_NAME:
-    build:
-      context: ../..
-      dockerfile: apps/$APP_NAME/docker/Dockerfile
-      target: development
-    ports:
-      - "$PORT:$PORT"
-    environment:
-      - NODE_ENV=development
-      - PORT=$PORT
-    volumes:
-      - ../../apps/$APP_NAME:/app/apps/$APP_NAME
-      - ../../packages:/app/packages
-      - /app/node_modules
-      - /app/apps/$APP_NAME/node_modules
-    command: pnpm dev
-EOF
-
-# Create docker-compose.prod.yml for the app
-cat > "$APP_DIR/docker-compose.prod.yml" << EOF
-services:
-  $APP_NAME:
-    build:
-      context: ../..
-      dockerfile: apps/$APP_NAME/docker/Dockerfile
-      target: production
-    ports:
-      - "$PORT:$PORT"
-    environment:
-      - NODE_ENV=production
-      - PORT=$PORT
-    restart: unless-stopped
-EOF
-
-# Update main docker-compose.yml
-update_main_compose() {
-  MAIN_COMPOSE="$DOCKER_DIR/docker-compose.yml"
-  INCLUDE_PATH="../apps/$APP_NAME/docker-compose.yml"
-
-  # Create main compose if it doesn't exist
-  if [ ! -f "$MAIN_COMPOSE" ]; then
-    cat > "$MAIN_COMPOSE" << MAINEOF
-# Main docker-compose - includes all apps
-# Each app has its own docker-compose.yml in apps/<app-name>/
-
-include:
-  - path: $INCLUDE_PATH
-MAINEOF
-    return
-  fi
-
-  # Check if app is already included
-  if grep -q "apps/$APP_NAME/docker-compose.yml" "$MAIN_COMPOSE" 2>/dev/null; then
-    return
-  fi
-
-  # If include is empty array [], replace it
-  if grep -q "include: \[\]" "$MAIN_COMPOSE"; then
-    sed -i '' "s|include: \[\]|include:\n  - path: $INCLUDE_PATH|" "$MAIN_COMPOSE"
-  else
-    # Append to existing include list
-    echo "  - path: $INCLUDE_PATH" >> "$MAIN_COMPOSE"
-  fi
-}
-
-update_main_compose
-
-echo -e "${GREEN}✓${NC} Created app: apps/$APP_NAME"
-echo ""
-echo -e "${YELLOW}Files created:${NC}"
-echo "  - apps/$APP_NAME/docker/Dockerfile"
-echo "  - apps/$APP_NAME/docker-compose.yml"
-echo "  - apps/$APP_NAME/docker-compose.prod.yml"
-echo ""
-echo -e "${YELLOW}Commands:${NC}"
-echo "  Dev (app only):  cd apps/$APP_NAME && docker compose up"
-echo "  Dev (all apps):  pnpm docker:dev"
-echo "  Prod (app only): cd apps/$APP_NAME && docker compose -f docker-compose.prod.yml up -d"

package/templates/default/scripts/publish-cli.sh

@@ -1,95 +0,0 @@
-#!/bin/bash
-
-# Publish create-nexu CLI to npm
-# This script generates the template, builds, and publishes
-
-set -e
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-ROOT_DIR="$(dirname "$SCRIPT_DIR")"
-CLI_DIR="$ROOT_DIR/create-nexu"
-
-echo "📦 Publishing create-nexu..."
-echo ""
-
-# Step 1: Generate template
-echo "1️⃣  Generating template..."
-"$SCRIPT_DIR/generate-template.sh"
-echo ""
-
-# Step 2: Build CLI
-echo "2️⃣  Building CLI..."
-cd "$CLI_DIR"
-pnpm build
-echo ""
-
-# Step 3: Run checks
-echo "3️⃣  Running checks..."
-pnpm typecheck
-pnpm lint
-echo "✅ All checks passed"
-echo ""
-
-# Step 4: Version bump
-CURRENT_VERSION=$(node -p "require('./package.json').version")
-echo "4️⃣  Current version: $CURRENT_VERSION"
-echo ""
-echo "Select version bump:"
-echo "  1) patch (bug fixes)"
-echo "  2) minor (new features)"
-echo "  3) major (breaking changes)"
-echo "  4) skip (keep current version)"
-echo ""
-read -p "Choice [1-4]: " -n 1 -r VERSION_CHOICE
-echo ""
-
-case $VERSION_CHOICE in
-    1)
-        npm version patch --no-git-tag-version
-        ;;
-    2)
-        npm version minor --no-git-tag-version
-        ;;
-    3)
-        npm version major --no-git-tag-version
-        ;;
-    4)
-        echo "Keeping version $CURRENT_VERSION"
-        ;;
-    *)
-        echo "Invalid choice, keeping current version"
-        ;;
-esac
-
-NEW_VERSION=$(node -p "require('./package.json').version")
-echo ""
-echo "Version: $NEW_VERSION"
-echo ""
-
-# Step 5: Show package info
-echo "5️⃣  Package info:"
-cat package.json | grep -E '"name"|"version"'
-echo ""
-
-# Step 6: Confirm publish
-read -p "Publish v$NEW_VERSION to npm? (y/N) " -n 1 -r
-echo ""
-
-if [[ $REPLY =~ ^[Yy]$ ]]; then
-    echo "6️⃣  Publishing to npm..."
-    npm publish --access public
-    echo ""
-    echo "✅ Published create-nexu@$NEW_VERSION successfully!"
-    echo ""
-    echo "Users can now run:"
-    echo "  npm create nexu my-app"
-    echo "  # or"
-    echo "  npx create-nexu my-app"
-else
-    echo "❌ Publish cancelled"
-    # Revert version if changed
-    if [ "$CURRENT_VERSION" != "$NEW_VERSION" ]; then
-        npm version "$CURRENT_VERSION" --no-git-tag-version --allow-same-version
-        echo "Version reverted to $CURRENT_VERSION"
-    fi
-fi

package/templates/default/scripts/setup.sh

@@ -1,70 +0,0 @@
-#!/bin/bash
-
-set -e
-
-echo "🚀 Setting up monorepo..."
-
-# Check if pnpm is installed
-if ! command -v pnpm &> /dev/null; then
-    echo "📦 Installing pnpm..."
-    npm install -g pnpm
-fi
-
-# Install dependencies
-echo "📦 Installing dependencies..."
-pnpm install
-
-# Setup husky
-echo "🐶 Setting up Husky..."
-pnpm prepare
-
-# Create environment files
-echo "🔐 Creating environment files..."
-
-if [ ! -f ".env" ]; then
-    cat > .env << EOF
-# Database
-DATABASE_URL=postgresql://postgres:postgres@localhost:5432/nexu
-DB_USER=postgres
-DB_PASSWORD=postgres
-DB_NAME=nexu
-
-# API
-API_URL=http://localhost:4000
-
-# App
-NODE_ENV=development
-EOF
-    echo "✅ Created .env file"
-fi
-
-if [ ! -f "apps/web/.env.local" ]; then
-    cat > apps/web/.env.local << EOF
-NEXT_PUBLIC_API_URL=http://localhost:4000
-EOF
-    echo "✅ Created apps/web/.env.local"
-fi
-
-if [ ! -f "apps/api/.env" ]; then
-    cat > apps/api/.env << EOF
-DATABASE_URL=postgresql://postgres:postgres@localhost:5432/nexu
-PORT=4000
-NODE_ENV=development
-EOF
-    echo "✅ Created apps/api/.env"
-fi
-
-# Build packages
-echo "🔨 Building packages..."
-pnpm build
-
-echo ""
-echo "✅ Setup complete!"
-echo ""
-echo "Available commands:"
-echo "  pnpm dev          - Start development servers"
-echo "  pnpm build        - Build all packages"
-echo "  pnpm lint         - Run linting"
-echo "  pnpm test         - Run tests"
-echo "  pnpm docker:dev   - Start with Docker (dev)"
-echo ""