create-onion-lasagna-app 0.1.0

package/README.md

@@ -0,0 +1,319 @@
+# create-onion-lasagna-app
+
+Scaffold new onion-lasagna projects with a single command.
+
+```bash
+bunx create-onion-lasagna-app my-app
+```
+
+## Quick Start
+
+```bash
+# Interactive mode (recommended)
+bunx create-onion-lasagna-app
+
+# With project name
+bunx create-onion-lasagna-app my-app
+
+# Skip prompts with defaults
+bunx create-onion-lasagna-app my-app --yes
+
+# Full customization
+bunx create-onion-lasagna-app my-app --structure simple -s simple-clean -v zod -f hono --use-pnpm
+```
+
+## How It Works
+
+```mermaid
+flowchart LR
+    A[Run CLI] --> B{Interactive?}
+    B -->|Yes| C[Prompts]
+    B -->|No| D[Use Flags]
+    C --> E[Clone Starter]
+    D --> E
+    E --> F[Inject Dependencies]
+    F --> G[Create Config]
+    G --> H{Install?}
+    H -->|Yes| I[Install with PM]
+    H -->|No| J{Git?}
+    I --> J
+    J -->|Yes| K[git init + commit]
+    J -->|No| L[Done]
+    K --> L
+```
+
+## Options
+
+| Flag           | Alias | Description                                        | Default     |
+| -------------- | ----- | -------------------------------------------------- | ----------- |
+| `--structure`  | -     | Project structure: `simple`, `modules`             | `simple`    |
+| `--starter`    | `-s`  | Starter template (filtered by structure)           | Auto        |
+| `--validator`  | `-v`  | Validation: `zod`, `valibot`, `arktype`, `typebox` | `zod`       |
+| `--framework`  | `-f`  | Framework: `hono`, `elysia`, `fastify`             | `hono`      |
+| `--use-bun`    | -     | Use bun package manager                            | Auto-detect |
+| `--use-npm`    | -     | Use npm package manager                            | -           |
+| `--use-yarn`   | -     | Use yarn package manager                           | -           |
+| `--use-pnpm`   | -     | Use pnpm package manager                           | -           |
+| `--skip-git`   | `-g`  | Skip git initialization                            | `false`     |
+| `--no-install` | -     | Skip dependency installation                       | `false`     |
+| `--dry-run`    | `-d`  | Preview what would be created                      | -           |
+| `--yes`        | `-y`  | Skip prompts, use defaults                         | -           |
+| `--version`    | `-V`  | Show version number                                | -           |
+| `--help`       | `-h`  | Show help                                          | -           |
+
+## Package Manager
+
+The CLI auto-detects your package manager based on how you invoke it:
+
+```bash
+bunx create-onion-lasagna-app my-app   # Uses bun
+npx create-onion-lasagna-app my-app    # Uses npm
+pnpm create onion-lasagna-app my-app   # Uses pnpm
+yarn create onion-lasagna-app my-app   # Uses yarn
+```
+
+Override with explicit flags:
+
+```bash
+bunx create-onion-lasagna-app my-app --use-pnpm
+npx create-onion-lasagna-app my-app --use-bun
+```
+
+## Git Initialization
+
+By default, the CLI initializes a git repository with an initial commit:
+
+```bash
+# Default: git init + initial commit
+bunx create-onion-lasagna-app my-app
+
+# Skip git initialization
+bunx create-onion-lasagna-app my-app --skip-git
+```
+
+## Dry Run Mode
+
+Preview what would be created without making any changes:
+
+```bash
+bunx create-onion-lasagna-app my-app --dry-run
+```
+
+Output includes:
+
+- Project configuration summary
+- Files that would be created
+- Actions that would be performed
+
+```
+DRY RUN  No changes will be made.
+
+Project Configuration:
+──────────────────────────────────────────────────
+  Name:           my-app
+  Directory:      /path/to/my-app
+  Structure:      simple
+  Starter:        simple-clean
+  ...
+
+Files that would be created:
+──────────────────────────────────────────────────
+  + my-app/
+  + my-app/package.json
+  + my-app/.onion-lasagna.json
+  ...
+```
+
+## Project Name Validation
+
+Project names follow npm package naming conventions:
+
+| Rule                        | Invalid        | Suggestion        |
+| --------------------------- | -------------- | ----------------- |
+| Lowercase only              | `MyApp`        | `myapp`           |
+| No spaces                   | `my app`       | `my-app`          |
+| No leading numbers          | `123-app`      | `app-123-app`     |
+| No leading dots/underscores | `_myapp`       | `myapp`           |
+| No reserved names           | `node_modules` | `my-node_modules` |
+| Max 214 characters          | (too long)     | (truncated)       |
+
+Invalid names are caught early with helpful suggestions.
+
+## Directory Conflict Handling
+
+If the target directory exists and isn't empty, interactive mode offers:
+
+```
+? Directory "my-app" already exists and is not empty.
+  How would you like to proceed?
+  ○ Overwrite     - Remove existing files and continue
+  ○ Choose a different name
+  ○ Cancel
+```
+
+In non-interactive mode (`--yes`), existing non-empty directories cause an error.
+
+## Structures & Starters
+
+```mermaid
+graph TD
+    subgraph Structures
+        S[simple] --> SC[simple-clean]
+        M[modules] --> MC[modules-clean]
+    end
+```
+
+### Simple Structure
+
+Flat structure for small to medium projects.
+
+| Starter        | Description                   |
+| -------------- | ----------------------------- |
+| `simple-clean` | Minimal setup, ready to build |
+
+```
+my-app/
+├── packages/
+│   └── backend/
+│       ├── bounded-contexts/
+│       │   └── example/
+│       ├── orchestrations/
+│       └── shared/
+├── .onion-lasagna.json
+└── package.json
+```
+
+### Modules Structure
+
+Module-based structure for large enterprise projects.
+
+| Starter         | Description                   |
+| --------------- | ----------------------------- |
+| `modules-clean` | Minimal setup, ready to build |
+
+```
+my-app/
+├── packages/
+│   ├── backend-modules/
+│   │   ├── user-management/
+│   │   ├── billing/
+│   │   └── notifications/
+│   └── backend-orchestrations/
+├── .onion-lasagna.json
+└── package.json
+```
+
+## Smart Starter Filtering
+
+The CLI automatically filters starters based on your selected structure:
+
+```bash
+# Only shows simple-* starters
+bunx create-onion-lasagna-app my-app --structure simple
+
+# Only shows modules-* starters
+bunx create-onion-lasagna-app my-app --structure modules
+```
+
+If an incompatible starter is specified, the CLI will error:
+
+```bash
+# Error: Starter "modules-clean" is not compatible with structure "simple"
+bunx create-onion-lasagna-app my-app --structure simple -s modules-clean
+```
+
+## Validators
+
+```mermaid
+graph TD
+    subgraph Validators
+        Z[Zod] -->|Most Popular| V[Validation]
+        VB[Valibot] -->|Smallest Bundle| V
+        A[ArkType] -->|Fastest Runtime| V
+        T[TypeBox] -->|JSON Schema| V
+    end
+```
+
+| Library     | Best For                                           |
+| ----------- | -------------------------------------------------- |
+| **Zod**     | TypeScript-first, great inference, large ecosystem |
+| **Valibot** | Bundle size critical apps, tree-shakeable          |
+| **ArkType** | Performance critical, complex schemas              |
+| **TypeBox** | JSON Schema compatibility, OpenAPI                 |
+
+## Frameworks
+
+| Framework   | Runtime                     | Best For                                    |
+| ----------- | --------------------------- | ------------------------------------------- |
+| **Hono**    | Any (Node, Bun, Deno, Edge) | Universal deployment                        |
+| **Elysia**  | Bun                         | Maximum performance, end-to-end type safety |
+| **Fastify** | Node                        | Enterprise, large plugin ecosystem          |
+
+## Generated Files
+
+After scaffolding, you'll find:
+
+| File                            | Purpose                                                                   |
+| ------------------------------- | ------------------------------------------------------------------------- |
+| `.onion-lasagna.json`           | Project config (structure, starter, validator, framework, packageManager) |
+| `.git/`                         | Initialized git repository with initial commit                            |
+| `packages/backend/.env`         | Environment variables                                                     |
+| `packages/backend/.env.example` | Environment template                                                      |
+
+## Examples
+
+```bash
+# Simple API with Hono + Zod (defaults)
+bunx create-onion-lasagna-app api --yes
+
+# Enterprise monolith with Fastify + Valibot + pnpm
+bunx create-onion-lasagna-app platform --structure modules -v valibot -f fastify --use-pnpm
+
+# High-performance Bun app with Elysia + ArkType, no git
+bunx create-onion-lasagna-app service -v arktype -f elysia --skip-git
+
+# CI/CD: npm, no install, no git
+npx create-onion-lasagna-app test-app --yes --no-install --skip-git
+```
+
+## After Scaffolding
+
+```bash
+cd my-app
+bun run dev    # Start development server
+bun run build  # Build for production
+bun run test   # Run tests
+```
+
+Post-install instructions adapt to your selected package manager:
+
+```bash
+# If you used --use-pnpm
+cd my-app
+pnpm dev
+```
+
+## Configuration
+
+The `.onion-lasagna.json` file stores your project settings:
+
+```json
+{
+  "structure": "simple",
+  "starter": "simple-clean",
+  "validator": "zod",
+  "framework": "hono",
+  "packageManager": "bun",
+  "createdAt": "2024-01-15T10:30:00.000Z"
+}
+```
+
+This config is used by `onion-lasagna-cli` for code generation.
+
+## Adding New Starters
+
+New starters can be added to either structure. The naming convention is:
+
+- `{structure}-{name}` (e.g., `simple-clean`, `modules-clean`)
+
+The CLI will automatically pick them up and show them when the matching structure is selected.

package/dist/index.js

@@ -0,0 +1,662 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import fs2 from "fs";
+import path2 from "path";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+
+// src/scaffold.ts
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import degit from "degit";
+var RESERVED_NAMES = /* @__PURE__ */ new Set([
+  "node_modules",
+  "favicon.ico",
+  "package.json",
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "bun.lockb",
+  ".git",
+  ".gitignore",
+  ".env",
+  "src",
+  "dist",
+  "build",
+  "test",
+  "tests",
+  "lib",
+  "bin",
+  "npm",
+  "npx",
+  "node"
+]);
+function validateProjectName(name) {
+  if (!name || name.trim().length === 0) {
+    return { valid: false, error: "Project name cannot be empty" };
+  }
+  if (name.length > 214) {
+    return {
+      valid: false,
+      error: "Project name must be 214 characters or fewer",
+      suggestion: name.slice(0, 50)
+    };
+  }
+  if (RESERVED_NAMES.has(name.toLowerCase())) {
+    return {
+      valid: false,
+      error: `"${name}" is a reserved name`,
+      suggestion: `my-${name}`
+    };
+  }
+  if (name.startsWith(".") || name.startsWith("_")) {
+    return {
+      valid: false,
+      error: "Project name cannot start with a dot or underscore",
+      suggestion: name.replace(/^[._]+/, "")
+    };
+  }
+  if (/^[0-9]/.test(name)) {
+    return {
+      valid: false,
+      error: "Project name cannot start with a number",
+      suggestion: `app-${name}`
+    };
+  }
+  if (/[A-Z]/.test(name)) {
+    return {
+      valid: false,
+      error: "Project name must be lowercase",
+      suggestion: name.toLowerCase()
+    };
+  }
+  if (/\s/.test(name)) {
+    return {
+      valid: false,
+      error: "Project name cannot contain spaces",
+      suggestion: name.replace(/\s+/g, "-")
+    };
+  }
+  if (!/^[a-z0-9][a-z0-9._-]*$/.test(name)) {
+    const sanitized = name.toLowerCase().replace(/[^a-z0-9._-]/g, "-").replace(/^[._-]+/, "").replace(/-+/g, "-");
+    return {
+      valid: false,
+      error: "Project name can only contain lowercase letters, numbers, hyphens, and underscores",
+      suggestion: sanitized || "my-app"
+    };
+  }
+  if (/[._-]$/.test(name)) {
+    return {
+      valid: false,
+      error: "Project name cannot end with a dot, underscore, or hyphen",
+      suggestion: name.replace(/[._-]+$/, "")
+    };
+  }
+  return { valid: true };
+}
+var STARTERS = {
+  "simple-clean": {
+    structure: "simple",
+    label: "Clean",
+    hint: "Minimal setup, ready to build",
+    repoPath: "simple-clean-starter"
+  },
+  "modules-clean": {
+    structure: "modules",
+    label: "Clean",
+    hint: "Minimal setup, ready to build",
+    repoPath: "modules-clean-starter"
+  }
+};
+var REPO = "Cosmneo/onion-lasagna";
+var VALIDATOR_PACKAGES = {
+  zod: "zod",
+  valibot: "valibot",
+  arktype: "arktype",
+  typebox: "@sinclair/typebox"
+};
+var FRAMEWORK_PACKAGES = {
+  hono: ["hono"],
+  elysia: ["elysia"],
+  fastify: ["fastify"]
+};
+var INSTALL_COMMANDS = {
+  npm: "npm install",
+  yarn: "yarn",
+  pnpm: "pnpm install",
+  bun: "bun install"
+};
+function initGitRepository(targetDir) {
+  try {
+    execSync("git init", { cwd: targetDir, stdio: "ignore" });
+    execSync("git add -A", { cwd: targetDir, stdio: "ignore" });
+    execSync('git commit -m "Initial commit from create-onion-lasagna-app"', {
+      cwd: targetDir,
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function scaffold(options) {
+  const { name, structure, starter, validator, framework, packageManager, install, skipGit } = options;
+  const targetDir = path.resolve(process.cwd(), name);
+  if (fs.existsSync(targetDir)) {
+    const files = fs.readdirSync(targetDir);
+    if (files.length > 0) {
+      throw new Error(`Directory "${name}" is not empty`);
+    }
+  }
+  const starterConfig = STARTERS[starter];
+  if (!starterConfig) {
+    throw new Error(`Unknown starter: ${starter}`);
+  }
+  if (starterConfig.structure !== structure) {
+    throw new Error(`Starter "${starter}" is not compatible with structure "${structure}"`);
+  }
+  const starterPath = `${REPO}/starters/${starterConfig.repoPath}`;
+  const emitter = degit(starterPath, {
+    cache: false,
+    force: true,
+    verbose: false
+  });
+  await emitter.clone(targetDir);
+  const rootPackageJsonPath = path.join(targetDir, "package.json");
+  const rootPackageJson = JSON.parse(fs.readFileSync(rootPackageJsonPath, "utf-8"));
+  rootPackageJson.name = name;
+  fs.writeFileSync(rootPackageJsonPath, JSON.stringify(rootPackageJson, null, 2) + "\n");
+  const backendPackageJsonPath = path.join(targetDir, "packages", "backend", "package.json");
+  if (fs.existsSync(backendPackageJsonPath)) {
+    const backendPackageJson = JSON.parse(fs.readFileSync(backendPackageJsonPath, "utf-8"));
+    backendPackageJson.dependencies = backendPackageJson.dependencies || {};
+    backendPackageJson.dependencies[VALIDATOR_PACKAGES[validator]] = "latest";
+    for (const pkg of FRAMEWORK_PACKAGES[framework]) {
+      backendPackageJson.dependencies[pkg] = "latest";
+    }
+    fs.writeFileSync(backendPackageJsonPath, JSON.stringify(backendPackageJson, null, 2) + "\n");
+  }
+  const envExamplePath = path.join(targetDir, "packages", "backend", ".env.example");
+  const envContent = `# Environment variables
+NODE_ENV=development
+PORT=3000
+`;
+  fs.writeFileSync(envExamplePath, envContent);
+  const envPath = path.join(targetDir, "packages", "backend", ".env");
+  fs.writeFileSync(envPath, envContent);
+  const configPath = path.join(targetDir, ".onion-lasagna.json");
+  const config = {
+    structure,
+    starter,
+    validator,
+    framework,
+    packageManager,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  if (install) {
+    const installCmd = INSTALL_COMMANDS[packageManager];
+    execSync(installCmd, {
+      cwd: targetDir,
+      stdio: "ignore"
+    });
+  }
+  if (!skipGit) {
+    initGitRepository(targetDir);
+  }
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+function setupSignalHandlers() {
+  const cleanup = () => {
+    process.stdout.write("\x1B[?25h");
+    console.log("\n");
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+}
+function detectPackageManager() {
+  const userAgent = process.env.npm_config_user_agent || "";
+  if (userAgent.startsWith("yarn")) return "yarn";
+  if (userAgent.startsWith("pnpm")) return "pnpm";
+  if (userAgent.startsWith("bun")) return "bun";
+  if (userAgent.startsWith("npm")) return "npm";
+  return "bun";
+}
+function parseArgs(args) {
+  const result = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      result.help = true;
+    } else if (arg === "--version" || arg === "-V") {
+      result.version = true;
+    } else if (arg === "--yes" || arg === "-y") {
+      result.yes = true;
+    } else if (arg === "--no-install") {
+      result.install = false;
+    } else if (arg === "--skip-git" || arg === "-g") {
+      result.skipGit = true;
+    } else if (arg === "--dry-run" || arg === "-d") {
+      result.dryRun = true;
+    } else if (arg === "--use-npm") {
+      result.packageManager = "npm";
+    } else if (arg === "--use-yarn") {
+      result.packageManager = "yarn";
+    } else if (arg === "--use-pnpm") {
+      result.packageManager = "pnpm";
+    } else if (arg === "--use-bun") {
+      result.packageManager = "bun";
+    } else if (arg === "--structure") {
+      result.structure = args[++i];
+    } else if (arg === "--starter" || arg === "-s") {
+      result.starter = args[++i];
+    } else if (arg === "--validator" || arg === "-v") {
+      result.validator = args[++i];
+    } else if (arg === "--framework" || arg === "-f") {
+      result.framework = args[++i];
+    } else if (!arg?.startsWith("-") && !result.name) {
+      result.name = arg;
+    }
+  }
+  return result;
+}
+function showHelp() {
+  const simpleStarters = Object.entries(STARTERS).filter(([, s]) => s.structure === "simple").map(([key]) => key);
+  const modulesStarters = Object.entries(STARTERS).filter(([, s]) => s.structure === "modules").map(([key]) => key);
+  console.log(`
+${pc.bold("create-onion-lasagna-app")} ${pc.dim(`v${VERSION}`)} - Scaffold a new onion-lasagna project
+
+${pc.bold("Usage:")}
+  create-onion-lasagna-app [project-name] [options]
+
+${pc.bold("Options:")}
+  --structure <type>       Project structure: simple, modules (default: simple)
+  -s, --starter <name>     Starter template (filtered by structure)
+  -v, --validator <lib>    Validation library: zod, valibot, arktype, typebox (default: zod)
+  -f, --framework <fw>     Web framework: hono, elysia, fastify (default: hono)
+
+  --use-bun                Use bun package manager (default)
+  --use-npm                Use npm package manager
+  --use-yarn               Use yarn package manager
+  --use-pnpm               Use pnpm package manager
+
+  -g, --skip-git           Skip git initialization
+  --no-install             Skip dependency installation
+  -d, --dry-run            Show what would be created without making changes
+  -y, --yes                Skip prompts and use defaults
+
+  -V, --version            Show version number
+  -h, --help               Show this help message
+
+${pc.bold("Starters:")}
+  ${pc.dim("simple structure:")}  ${simpleStarters.join(", ")}
+  ${pc.dim("modules structure:")} ${modulesStarters.join(", ")}
+
+${pc.bold("Examples:")}
+  create-onion-lasagna-app my-app
+  create-onion-lasagna-app my-app --use-pnpm --skip-git
+  create-onion-lasagna-app my-app --structure modules -s modules-clean
+  create-onion-lasagna-app my-app --dry-run
+  create-onion-lasagna-app my-app --yes
+`);
+}
+function getStartersForStructure(structure) {
+  return Object.entries(STARTERS).filter(([, s]) => s.structure === structure).map(([key, s]) => ({
+    value: key,
+    label: s.label,
+    hint: s.hint
+  }));
+}
+function getDefaultStarterForStructure(structure) {
+  const starters = Object.entries(STARTERS).filter(([, s]) => s.structure === structure);
+  return starters[0]?.[0];
+}
+function getRunCommand(pm) {
+  return pm === "npm" ? "npm run" : pm;
+}
+function getInstallCommand(pm) {
+  return pm === "yarn" ? "yarn" : `${pm} install`;
+}
+function showDryRunOutput(options) {
+  const targetDir = path2.resolve(process.cwd(), options.name);
+  console.log(`
+${pc.bgYellow(pc.black(" DRY RUN "))} No changes will be made.
+`);
+  console.log(`${pc.bold("Project Configuration:")}`);
+  console.log(pc.dim("\u2500".repeat(50)));
+  console.log(`  ${pc.cyan("Name:")}           ${options.name}`);
+  console.log(`  ${pc.cyan("Directory:")}      ${targetDir}`);
+  console.log(`  ${pc.cyan("Structure:")}      ${options.structure}`);
+  console.log(`  ${pc.cyan("Starter:")}        ${options.starter}`);
+  console.log(`  ${pc.cyan("Validator:")}      ${options.validator}`);
+  console.log(`  ${pc.cyan("Framework:")}      ${options.framework}`);
+  console.log(`  ${pc.cyan("Package Manager:")} ${options.packageManager}`);
+  console.log(`  ${pc.cyan("Install deps:")}   ${options.install ? "yes" : "no"}`);
+  console.log(`  ${pc.cyan("Git init:")}       ${options.skipGit ? "no" : "yes"}`);
+  console.log(`
+${pc.bold("Files that would be created:")}`);
+  console.log(pc.dim("\u2500".repeat(50)));
+  console.log(`  ${pc.green("+")} ${options.name}/`);
+  console.log(`  ${pc.green("+")} ${options.name}/package.json`);
+  console.log(`  ${pc.green("+")} ${options.name}/.onion-lasagna.json`);
+  console.log(`  ${pc.green("+")} ${options.name}/packages/backend/`);
+  console.log(`  ${pc.green("+")} ${options.name}/packages/backend/package.json`);
+  console.log(`  ${pc.green("+")} ${options.name}/packages/backend/.env`);
+  console.log(`  ${pc.green("+")} ${options.name}/packages/backend/.env.example`);
+  if (!options.skipGit) {
+    console.log(`  ${pc.green("+")} ${options.name}/.git/`);
+  }
+  console.log(`
+${pc.bold("Actions that would be performed:")}`);
+  console.log(pc.dim("\u2500".repeat(50)));
+  console.log(`  ${pc.blue("1.")} Clone starter template from GitHub`);
+  console.log(`  ${pc.blue("2.")} Update package.json with project name`);
+  console.log(`  ${pc.blue("3.")} Add ${options.validator} and ${options.framework} dependencies`);
+  console.log(`  ${pc.blue("4.")} Create environment files`);
+  console.log(`  ${pc.blue("5.")} Create .onion-lasagna.json config`);
+  if (options.install) {
+    console.log(`  ${pc.blue("6.")} Run ${getInstallCommand(options.packageManager)}`);
+  }
+  if (!options.skipGit) {
+    console.log(`  ${pc.blue(options.install ? "7." : "6.")} Initialize git repository`);
+  }
+  console.log(`
+${pc.dim("Run without --dry-run to create the project.")}
+`);
+}
+function showRichPostInstall(options) {
+  const { name, packageManager, install, skipGit } = options;
+  const run = getRunCommand(packageManager);
+  console.log(
+    `
+${pc.green("Success!")} Created ${pc.bold(name)} at ${pc.dim(path2.resolve(process.cwd(), name))}`
+  );
+  console.log(`
+${pc.bold("Inside that directory, you can run:")}`);
+  console.log(pc.dim("\u2500".repeat(50)));
+  console.log(`
+  ${pc.cyan(`${run} dev`)}`);
+  console.log(`    ${pc.dim("Start the development server")}`);
+  console.log(`
+  ${pc.cyan(`${run} build`)}`);
+  console.log(`    ${pc.dim("Build for production")}`);
+  console.log(`
+  ${pc.cyan(`${run} test`)}`);
+  console.log(`    ${pc.dim("Run tests")}`);
+  console.log(`
+  ${pc.cyan(`${run} lint`)}`);
+  console.log(`    ${pc.dim("Check for linting errors")}`);
+  console.log(`
+${pc.bold("We suggest you begin by typing:")}`);
+  console.log(pc.dim("\u2500".repeat(50)));
+  console.log(`
+  ${pc.cyan(`cd ${name}`)}`);
+  if (!install) {
+    console.log(`  ${pc.cyan(getInstallCommand(packageManager))}`);
+  }
+  console.log(`  ${pc.cyan(`${run} dev`)}`);
+  if (!skipGit) {
+    console.log(`
+${pc.dim("A git repository has been initialized with an initial commit.")}`);
+  }
+  console.log("");
+}
+async function checkDirectoryConflict(name) {
+  const targetDir = path2.resolve(process.cwd(), name);
+  if (!fs2.existsSync(targetDir)) {
+    return "overwrite";
+  }
+  const files = fs2.readdirSync(targetDir);
+  if (files.length === 0) {
+    return "overwrite";
+  }
+  p.log.warn(`Directory ${pc.cyan(name)} already exists and is not empty.`);
+  const action = await p.select({
+    message: "How would you like to proceed?",
+    options: [
+      { value: "overwrite", label: "Overwrite", hint: "Remove existing files and continue" },
+      { value: "new-name", label: "Choose a different name", hint: "Enter a new project name" },
+      { value: "cancel", label: "Cancel", hint: "Abort the operation" }
+    ]
+  });
+  if (p.isCancel(action)) {
+    return "cancel";
+  }
+  return action;
+}
+function removeDirectory(dir) {
+  if (fs2.existsSync(dir)) {
+    fs2.rmSync(dir, { recursive: true, force: true });
+  }
+}
+async function main() {
+  setupSignalHandlers();
+  const args = parseArgs(process.argv.slice(2));
+  if (args.version) {
+    console.log(`create-onion-lasagna-app v${VERSION}`);
+    process.exit(0);
+  }
+  if (args.help) {
+    showHelp();
+    process.exit(0);
+  }
+  const detectedPm = detectPackageManager();
+  if (args.yes || args.name && args.structure && args.starter && args.validator && args.framework) {
+    const structure = args.structure || "simple";
+    const starter = args.starter || getDefaultStarterForStructure(structure);
+    const packageManager2 = args.packageManager || detectedPm;
+    const nameValidation = validateProjectName(args.name || "my-onion-app");
+    if (!nameValidation.valid) {
+      console.error(pc.red(`Invalid project name: ${nameValidation.error}`));
+      if (nameValidation.suggestion) {
+        console.error(pc.dim(`Suggestion: ${nameValidation.suggestion}`));
+      }
+      process.exit(1);
+    }
+    const starterConfig = STARTERS[starter];
+    if (starterConfig && starterConfig.structure !== structure) {
+      console.error(pc.red(`Starter "${starter}" is not compatible with structure "${structure}"`));
+      console.error(
+        pc.dim(
+          `Available starters for ${structure}: ${getStartersForStructure(structure).map((s2) => s2.value).join(", ")}`
+        )
+      );
+      process.exit(1);
+    }
+    const options = {
+      name: args.name || "my-onion-app",
+      structure,
+      starter,
+      validator: args.validator || "zod",
+      framework: args.framework || "hono",
+      packageManager: packageManager2,
+      install: args.install !== false,
+      skipGit: args.skipGit ?? false
+    };
+    if (args.dryRun) {
+      showDryRunOutput(options);
+      process.exit(0);
+    }
+    const targetDir = path2.resolve(process.cwd(), options.name);
+    if (fs2.existsSync(targetDir)) {
+      const files = fs2.readdirSync(targetDir);
+      if (files.length > 0) {
+        console.error(pc.red(`Directory "${options.name}" already exists and is not empty.`));
+        console.error(pc.dim("Use interactive mode or choose a different name."));
+        process.exit(1);
+      }
+    }
+    console.log(pc.cyan(`
+Creating ${options.name}...
+`));
+    try {
+      await scaffold(options);
+      showRichPostInstall(options);
+    } catch (error) {
+      console.error(pc.red(error instanceof Error ? error.message : String(error)));
+      process.exit(1);
+    }
+    return;
+  }
+  console.clear();
+  p.intro(pc.bgCyan(pc.black(` create-onion-lasagna-app v${VERSION} `)));
+  let projectName = args.name || "my-onion-app";
+  let needsNewName = false;
+  if (args.name) {
+    const nameValidation = validateProjectName(args.name);
+    if (!nameValidation.valid) {
+      p.log.warn(`Invalid project name: ${nameValidation.error}`);
+      if (nameValidation.suggestion) {
+        p.log.info(`Suggestion: ${nameValidation.suggestion}`);
+      }
+      needsNewName = true;
+    }
+  }
+  if (!needsNewName && projectName) {
+    const conflictAction = await checkDirectoryConflict(projectName);
+    if (conflictAction === "cancel") {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    } else if (conflictAction === "overwrite") {
+      const targetDir = path2.resolve(process.cwd(), projectName);
+      if (fs2.existsSync(targetDir) && fs2.readdirSync(targetDir).length > 0) {
+        removeDirectory(targetDir);
+        p.log.info(`Removed existing directory: ${projectName}`);
+      }
+    } else if (conflictAction === "new-name") {
+      needsNewName = true;
+    }
+  }
+  const project = await p.group(
+    {
+      name: () => {
+        if (!needsNewName && args.name) {
+          return Promise.resolve(args.name);
+        }
+        return p.text({
+          message: "Project name",
+          placeholder: "my-onion-app",
+          defaultValue: needsNewName ? "" : projectName,
+          validate: (value) => {
+            if (!value) return "Project name is required";
+            const validation = validateProjectName(value);
+            if (!validation.valid) {
+              return validation.error + (validation.suggestion ? ` (try: ${validation.suggestion})` : "");
+            }
+            const targetDir = path2.resolve(process.cwd(), value);
+            if (fs2.existsSync(targetDir) && fs2.readdirSync(targetDir).length > 0) {
+              return `Directory "${value}" already exists and is not empty`;
+            }
+          }
+        });
+      },
+      structure: () => p.select({
+        message: "Select project structure",
+        initialValue: args.structure,
+        options: [
+          {
+            value: "simple",
+            label: "Simple",
+            hint: "Flat structure, great for small to medium projects"
+          },
+          {
+            value: "modules",
+            label: "Modules",
+            hint: "Module-based structure for large enterprise projects"
+          }
+        ]
+      }),
+      starter: ({ results }) => {
+        const structure = results.structure;
+        const starters = getStartersForStructure(structure);
+        if (starters.length === 1) {
+          return Promise.resolve(starters[0].value);
+        }
+        return p.select({
+          message: "Select a starter template",
+          initialValue: args.starter,
+          options: starters
+        });
+      },
+      validator: () => p.select({
+        message: "Select a validation library",
+        initialValue: args.validator,
+        options: [
+          { value: "zod", label: "Zod", hint: "Most popular, great TypeScript inference" },
+          { value: "valibot", label: "Valibot", hint: "Smallest bundle size" },
+          { value: "arktype", label: "ArkType", hint: "Fastest runtime validation" },
+          { value: "typebox", label: "TypeBox", hint: "JSON Schema compatible" }
+        ]
+      }),
+      framework: () => p.select({
+        message: "Select a web framework",
+        initialValue: args.framework,
+        options: [
+          { value: "hono", label: "Hono", hint: "Fast, lightweight, works everywhere" },
+          { value: "elysia", label: "Elysia", hint: "Bun-optimized, end-to-end type safety" },
+          { value: "fastify", label: "Fastify", hint: "Mature, plugin ecosystem" }
+        ]
+      }),
+      packageManager: () => p.select({
+        message: "Select a package manager",
+        initialValue: args.packageManager || detectedPm,
+        options: [
+          { value: "bun", label: "bun", hint: "Fast, all-in-one toolkit" },
+          { value: "pnpm", label: "pnpm", hint: "Fast, disk space efficient" },
+          { value: "npm", label: "npm", hint: "Node.js default package manager" },
+          { value: "yarn", label: "yarn", hint: "Classic alternative to npm" }
+        ]
+      }),
+      install: () => p.confirm({
+        message: "Install dependencies?",
+        initialValue: args.install !== false
+      })
+    },
+    {
+      onCancel: () => {
+        p.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+    }
+  );
+  const packageManager = project.packageManager;
+  const scaffoldOptions = {
+    name: project.name,
+    structure: project.structure,
+    starter: project.starter,
+    validator: project.validator,
+    framework: project.framework,
+    packageManager,
+    install: project.install,
+    skipGit: args.skipGit ?? false
+  };
+  if (args.dryRun) {
+    showDryRunOutput(scaffoldOptions);
+    p.outro(pc.dim("Dry run complete. No changes were made."));
+    process.exit(0);
+  }
+  const s = p.spinner();
+  try {
+    s.start("Scaffolding project...");
+    await scaffold(scaffoldOptions);
+    s.stop("Project scaffolded!");
+    showRichPostInstall({
+      name: project.name,
+      packageManager,
+      install: project.install,
+      skipGit: args.skipGit ?? false
+    });
+    p.outro(pc.green("Happy coding!"));
+  } catch (error) {
+    s.stop("Failed to scaffold project");
+    p.log.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "create-onion-lasagna-app",
+  "version": "0.1.0",
+  "description": "CLI to scaffold new onion-lasagna projects",
+  "type": "module",
+  "license": "MIT",
+  "author": "Cosmneo",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Cosmneo/onion-lasagna.git",
+    "directory": "packages/create-onion-lasagna-app"
+  },
+  "homepage": "https://github.com/Cosmneo/onion-lasagna/tree/main/packages/create-onion-lasagna-app#readme",
+  "bugs": {
+    "url": "https://github.com/Cosmneo/onion-lasagna/issues"
+  },
+  "keywords": [
+    "cli",
+    "scaffold",
+    "onion-architecture",
+    "hexagonal-architecture",
+    "ddd",
+    "create-app",
+    "boilerplate",
+    "starter",
+    "typescript"
+  ],
+  "bin": {
+    "create-onion-lasagna-app": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "start": "bun run src/index.ts"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.9.1",
+    "degit": "^2.8.4",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/degit": "^2.8.6",
+    "@types/node": "^22.10.2",
+    "tsup": "^8.5.1",
+    "typescript": "^5.8.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}