@buenojs/bueno 0.8.0

package/dist/cli/index.js

@@ -0,0 +1,3233 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/cli/core/args.ts
+function parseArgs(argv = process.argv.slice(2)) {
+  const result = {
+    command: "",
+    positionals: [],
+    options: {},
+    flags: new Set
+  };
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg)
+      continue;
+    if (arg.startsWith("--")) {
+      const eqIndex = arg.indexOf("=");
+      if (eqIndex !== -1) {
+        const name = arg.slice(2, eqIndex);
+        const value = arg.slice(eqIndex + 1);
+        result.options[name] = value;
+      } else {
+        const name = arg.slice(2);
+        const nextArg = argv[i + 1];
+        if (!nextArg || nextArg.startsWith("-")) {
+          result.options[name] = true;
+          result.flags.add(name);
+        } else {
+          result.options[name] = nextArg;
+          i++;
+        }
+      }
+    } else if (arg.startsWith("-") && arg.length > 1) {
+      const chars = arg.slice(1);
+      if (chars.length > 1) {
+        for (const char of chars) {
+          result.options[char] = true;
+          result.flags.add(char);
+        }
+      } else {
+        const name = chars;
+        const nextArg = argv[i + 1];
+        if (!nextArg || nextArg.startsWith("-")) {
+          result.options[name] = true;
+          result.flags.add(name);
+        } else {
+          result.options[name] = nextArg;
+          i++;
+        }
+      }
+    } else {
+      if (!result.command) {
+        result.command = arg;
+      } else {
+        result.positionals.push(arg);
+      }
+    }
+  }
+  return result;
+}
+function getOption(parsed, name, definition) {
+  const value = parsed.options[name] ?? parsed.options[definition.alias ?? ""];
+  if (value === undefined) {
+    return definition.default;
+  }
+  if (definition.type === "boolean") {
+    return value === true || value === "true";
+  }
+  if (definition.type === "number") {
+    return typeof value === "number" ? value : typeof value === "string" ? parseInt(value, 10) : NaN;
+  }
+  return value;
+}
+function hasFlag(parsed, name, alias) {
+  return parsed.flags.has(name) || (alias ? parsed.flags.has(alias) : false);
+}
+function getOptionValues(parsed, name, alias) {
+  const values = [];
+  const argv = process.argv.slice(2);
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg)
+      continue;
+    if (arg === `--${name}`) {
+      const nextArg = argv[i + 1];
+      if (nextArg && !nextArg.startsWith("-")) {
+        values.push(nextArg);
+        i++;
+      }
+    } else if (arg.startsWith(`--${name}=`)) {
+      const value = arg.slice(name.length + 3);
+      values.push(value);
+    } else if (alias && arg === `-${alias}`) {
+      const nextArg = argv[i + 1];
+      if (nextArg && !nextArg.startsWith("-")) {
+        values.push(nextArg);
+        i++;
+      }
+    }
+  }
+  return values;
+}
+function generateHelpText(command, cliName = "bueno") {
+  const lines = [];
+  lines.push(`
+${command.description}
+`);
+  lines.push("Usage:");
+  let usage = `  ${cliName} ${command.name}`;
+  if (command.positionals) {
+    for (const pos of command.positionals) {
+      usage += pos.required ? ` <${pos.name}>` : ` [${pos.name}]`;
+    }
+  }
+  usage += " [options]";
+  lines.push(usage + `
+`);
+  if (command.positionals && command.positionals.length > 0) {
+    lines.push("Arguments:");
+    for (const pos of command.positionals) {
+      const required = pos.required ? " (required)" : "";
+      lines.push(`  ${pos.name.padEnd(20)} ${pos.description}${required}`);
+    }
+    lines.push("");
+  }
+  if (command.options && command.options.length > 0) {
+    lines.push("Options:");
+    for (const opt of command.options) {
+      let flag = `--${opt.name}`;
+      if (opt.alias) {
+        flag = `-${opt.alias}, ${flag}`;
+      }
+      let defaultValue = "";
+      if (opt.default !== undefined) {
+        defaultValue = ` (default: ${opt.default})`;
+      }
+      lines.push(`  ${flag.padEnd(20)} ${opt.description}${defaultValue}`);
+    }
+    lines.push("");
+  }
+  if (command.examples && command.examples.length > 0) {
+    lines.push("Examples:");
+    for (const example of command.examples) {
+      lines.push(`  ${example}`);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function generateGlobalHelpText(commands, cliName = "bueno") {
+  const lines = [];
+  lines.push(`
+${cliName} - A Bun-Native Full-Stack Framework CLI
+`);
+  lines.push("Usage:");
+  lines.push(`  ${cliName} <command> [options]
+`);
+  lines.push("Commands:");
+  for (const cmd of commands) {
+    const name = cmd.alias ? `${cmd.name} (${cmd.alias})` : cmd.name;
+    lines.push(`  ${name.padEnd(20)} ${cmd.description}`);
+  }
+  lines.push("");
+  lines.push("Global Options:");
+  lines.push("  --help, -h          Show help for command");
+  lines.push("  --version, -v       Show CLI version");
+  lines.push("  --verbose           Enable verbose output");
+  lines.push("  --quiet             Suppress non-essential output");
+  lines.push("  --no-color          Disable colored output");
+  lines.push("");
+  lines.push(`Run '${cliName} <command> --help' for more information about a command.
+`);
+  return lines.join(`
+`);
+}
+
+// src/cli/core/console.ts
+var COLORS = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  italic: "\x1B[3m",
+  underline: "\x1B[4m",
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  brightRed: "\x1B[91m",
+  brightGreen: "\x1B[92m",
+  brightYellow: "\x1B[93m",
+  brightBlue: "\x1B[94m",
+  brightMagenta: "\x1B[95m",
+  brightCyan: "\x1B[96m",
+  brightWhite: "\x1B[97m",
+  bgBlack: "\x1B[40m",
+  bgRed: "\x1B[41m",
+  bgGreen: "\x1B[42m",
+  bgYellow: "\x1B[43m",
+  bgBlue: "\x1B[44m",
+  bgMagenta: "\x1B[45m",
+  bgCyan: "\x1B[46m",
+  bgWhite: "\x1B[47m"
+};
+var colorEnabled = !process.env.NO_COLOR && process.env.BUENO_NO_COLOR !== "true" && process.stdout.isTTY;
+function setColorEnabled(enabled) {
+  colorEnabled = enabled;
+}
+function isColorEnabled() {
+  return colorEnabled;
+}
+function colorize(text, color) {
+  if (!colorEnabled)
+    return text;
+  return `${COLORS[color]}${text}${COLORS.reset}`;
+}
+var colors = {
+  red: (text) => colorize(text, "red"),
+  green: (text) => colorize(text, "green"),
+  yellow: (text) => colorize(text, "yellow"),
+  blue: (text) => colorize(text, "blue"),
+  magenta: (text) => colorize(text, "magenta"),
+  cyan: (text) => colorize(text, "cyan"),
+  white: (text) => colorize(text, "white"),
+  brightRed: (text) => colorize(text, "brightRed"),
+  brightGreen: (text) => colorize(text, "brightGreen"),
+  brightYellow: (text) => colorize(text, "brightYellow"),
+  brightBlue: (text) => colorize(text, "brightBlue"),
+  brightCyan: (text) => colorize(text, "brightCyan"),
+  dim: (text) => colorize(text, "dim"),
+  bold: (text) => colorize(text, "bold"),
+  underline: (text) => colorize(text, "underline"),
+  italic: (text) => colorize(text, "italic")
+};
+var cliConsole = {
+  log(message, ...args) {
+    globalThis.console.log(message, ...args);
+  },
+  info(message, ...args) {
+    globalThis.console.log(colors.cyan("\u2139"), message, ...args);
+  },
+  success(message, ...args) {
+    globalThis.console.log(colors.green("\u2713"), message, ...args);
+  },
+  warn(message, ...args) {
+    globalThis.console.log(colors.yellow("\u26A0"), message, ...args);
+  },
+  error(message, ...args) {
+    globalThis.console.error(colors.red("\u2717"), message, ...args);
+  },
+  debug(message, ...args) {
+    if (process.env.BUENO_VERBOSE === "true") {
+      globalThis.console.log(colors.dim("\u22EF"), colors.dim(message), ...args);
+    }
+  },
+  header(title) {
+    globalThis.console.log();
+    globalThis.console.log(colors.bold(colors.cyan(title)));
+    globalThis.console.log();
+  },
+  subheader(title) {
+    globalThis.console.log();
+    globalThis.console.log(colors.bold(title));
+  },
+  newline() {
+    globalThis.console.log();
+  },
+  clear() {
+    process.stdout.write("\x1B[2J\x1B[0f");
+  }
+};
+function formatTable(headers, rows, options = {}) {
+  const padding = options.padding ?? 2;
+  const widths = headers.map((h, i) => {
+    const maxRowWidth = Math.max(...rows.map((r) => r[i]?.length ?? 0));
+    return Math.max(h.length, maxRowWidth);
+  });
+  const pad = " ".repeat(padding);
+  const headerLine = headers.map((h, i) => h.padEnd(widths[i] ?? 0)).join(pad);
+  const separator = widths.map((w) => "\u2500".repeat(w)).join(pad);
+  const rowLines = rows.map((row) => row.map((cell, i) => (cell ?? "").padEnd(widths[i] ?? 0)).join(pad));
+  return [
+    colors.bold(headerLine),
+    colors.dim(separator),
+    ...rowLines
+  ].join(`
+`);
+}
+function printTable(headers, rows, options) {
+  globalThis.console.log(formatTable(headers, rows, options));
+}
+function formatSize(bytes) {
+  const units = ["B", "KB", "MB", "GB"];
+  let size = bytes;
+  let unitIndex = 0;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+  return `${size.toFixed(1)} ${units[unitIndex]}`;
+}
+function formatDuration(ms) {
+  if (ms < 1000)
+    return `${ms}ms`;
+  if (ms < 60000)
+    return `${(ms / 1000).toFixed(1)}s`;
+  return `${(ms / 60000).toFixed(1)}m`;
+}
+
+// src/cli/commands/index.ts
+class CommandRegistry {
+  commands = new Map;
+  aliases = new Map;
+  register(definition, handler) {
+    this.commands.set(definition.name, {
+      definition,
+      handler
+    });
+    if (definition.alias) {
+      this.aliases.set(definition.alias, definition.name);
+    }
+  }
+  get(name) {
+    const commandName = this.aliases.get(name) ?? name;
+    return this.commands.get(commandName);
+  }
+  has(name) {
+    const commandName = this.aliases.get(name) ?? name;
+    return this.commands.has(commandName);
+  }
+  getAll() {
+    return Array.from(this.commands.values()).map((c) => c.definition);
+  }
+  getCommands() {
+    return new Map(this.commands);
+  }
+  async execute(name, args) {
+    const command = this.get(name);
+    if (!command) {
+      throw new Error(`Unknown command: ${name}`);
+    }
+    await command.handler(args);
+  }
+}
+var registry = new CommandRegistry;
+function defineCommand(definition, handler) {
+  registry.register(definition, handler);
+}
+
+// src/cli/core/prompt.ts
+import * as readline from "readline";
+function isInteractive() {
+  return !!(process.stdin.isTTY && process.stdout.isTTY);
+}
+function createRL() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+async function prompt(message, options = {}) {
+  const defaultValue = options.default;
+  const promptText = defaultValue ? `${colors.cyan("?")} ${message} ${colors.dim(`(${defaultValue})`)}: ` : `${colors.cyan("?")} ${message}: `;
+  if (!isInteractive()) {
+    return defaultValue ?? "";
+  }
+  return new Promise((resolve) => {
+    const rl = createRL();
+    rl.question(promptText, (answer) => {
+      rl.close();
+      const value = answer.trim() || defaultValue || "";
+      if (options.validate) {
+        const result = options.validate(value);
+        if (result !== true) {
+          const errorMsg = typeof result === "string" ? result : "Invalid value";
+          process.stdout.write(`${colors.red("\u2717")} ${errorMsg}
+`);
+          prompt(message, options).then(resolve);
+          return;
+        }
+      }
+      resolve(value);
+    });
+  });
+}
+async function confirm(message, options = {}) {
+  const defaultValue = options.default ?? false;
+  const hint = defaultValue ? "Y/n" : "y/N";
+  if (!isInteractive()) {
+    return defaultValue;
+  }
+  const answer = await prompt(`${message} ${colors.dim(`(${hint})`)}`, {
+    default: defaultValue ? "y" : "n",
+    validate: (value) => {
+      if (!value)
+        return true;
+      return ["y", "yes", "n", "no"].includes(value.toLowerCase()) || "Please enter y or n";
+    }
+  });
+  return ["y", "yes"].includes(answer.toLowerCase());
+}
+async function select(message, choices, options = {}) {
+  if (!isInteractive()) {
+    return options.default ?? choices[0]?.value;
+  }
+  const pageSize = options.pageSize ?? 10;
+  let selectedIndex = choices.findIndex((c) => c.value === options.default && !c.disabled);
+  if (selectedIndex === -1) {
+    selectedIndex = choices.findIndex((c) => !c.disabled);
+  }
+  return new Promise((resolve) => {
+    process.stdout.write("\x1B[?25l");
+    const render = () => {
+      const lines = Math.min(choices.length, pageSize);
+      process.stdout.write(`\x1B[${lines + 1}A\x1B[0J`);
+      process.stdout.write(`${colors.cyan("?")} ${message}
+`);
+      const start = Math.max(0, selectedIndex - pageSize + 1);
+      const end = Math.min(choices.length, start + pageSize);
+      for (let i = start;i < end; i++) {
+        const choice = choices[i];
+        if (!choice)
+          continue;
+        const isSelected = i === selectedIndex;
+        const prefix = isSelected ? `${colors.cyan("\u276F")} ` : "  ";
+        const name = choice.name ?? choice.value;
+        const text = choice.disabled ? colors.dim(`${name} (disabled)`) : isSelected ? colors.cyan(name) : name;
+        process.stdout.write(`${prefix}${text}
+`);
+      }
+    };
+    process.stdout.write(`${colors.cyan("?")} ${message}
+`);
+    render();
+    const stdin = process.stdin;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const cleanup = () => {
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.removeListener("data", handler);
+      process.stdout.write("\x1B[?25h");
+    };
+    const handler = (key) => {
+      if (key === "\x1B[A" || key === "k") {
+        do {
+          selectedIndex = (selectedIndex - 1 + choices.length) % choices.length;
+        } while (choices[selectedIndex]?.disabled);
+        render();
+      } else if (key === "\x1B[B" || key === "j") {
+        do {
+          selectedIndex = (selectedIndex + 1) % choices.length;
+        } while (choices[selectedIndex]?.disabled);
+        render();
+      } else if (key === "\r" || key === `
+`) {
+        cleanup();
+        const selected = choices[selectedIndex];
+        if (selected) {
+          process.stdout.write(`\x1B[${Math.min(choices.length, pageSize) + 1}A\x1B[0J`);
+          process.stdout.write(`${colors.cyan("?")} ${message} ${colors.cyan(selected.name ?? selected.value)}
+`);
+          resolve(selected.value);
+        }
+      } else if (key === "\x1B" || key === "\x03") {
+        cleanup();
+        process.stdout.write(`
+`);
+        process.exit(130);
+      }
+    };
+    stdin.on("data", handler);
+  });
+}
+
+// src/cli/core/spinner.ts
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var SPINNER_INTERVAL = 80;
+
+class Spinner {
+  text;
+  color;
+  frameIndex = 0;
+  interval = null;
+  isSpinning = false;
+  stream = process.stdout;
+  constructor(options = {}) {
+    this.text = options.text ?? "";
+    this.color = options.color ?? "cyan";
+  }
+  start(text) {
+    if (text)
+      this.text = text;
+    if (this.isSpinning)
+      return this;
+    this.isSpinning = true;
+    this.frameIndex = 0;
+    this.stream.write("\x1B[?25l");
+    this.interval = setInterval(() => {
+      this.render();
+    }, SPINNER_INTERVAL);
+    return this;
+  }
+  update(text) {
+    this.text = text;
+    if (this.isSpinning) {
+      this.render();
+    }
+    return this;
+  }
+  success(text) {
+    return this.stop(colors.green("\u2713"), text);
+  }
+  error(text) {
+    return this.stop(colors.red("\u2717"), text);
+  }
+  warn(text) {
+    return this.stop(colors.yellow("\u26A0"), text);
+  }
+  info(text) {
+    return this.stop(colors.cyan("\u2139"), text);
+  }
+  stop(symbol, text) {
+    if (!this.isSpinning)
+      return this;
+    this.isSpinning = false;
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    this.stream.write("\r\x1B[K");
+    const finalText = text ?? this.text;
+    if (symbol) {
+      this.stream.write(`${symbol} ${finalText}
+`);
+    } else {
+      this.stream.write(`${finalText}
+`);
+    }
+    this.stream.write("\x1B[?25h");
+    return this;
+  }
+  clear() {
+    if (!this.isSpinning)
+      return this;
+    this.stream.write("\r\x1B[K");
+    return this;
+  }
+  render() {
+    if (!isColorEnabled()) {
+      const dots = ".".repeat(this.frameIndex % 3 + 1);
+      this.stream.write(`\r${this.text}${dots}   `);
+      this.frameIndex++;
+      return;
+    }
+    const frame = SPINNER_FRAMES[this.frameIndex % SPINNER_FRAMES.length];
+    const coloredFrame = colors[this.color](frame);
+    this.stream.write(`\r${coloredFrame} ${this.text}`);
+    this.frameIndex++;
+  }
+}
+function spinner(text, options) {
+  return new Spinner({ text, ...options }).start();
+}
+
+class ProgressBar {
+  total;
+  width;
+  text;
+  completeChar;
+  incompleteChar;
+  current = 0;
+  stream = process.stdout;
+  constructor(options) {
+    this.total = options.total;
+    this.width = options.width ?? 40;
+    this.text = options.text ?? "";
+    this.completeChar = options.completeChar ?? "\u2588";
+    this.incompleteChar = options.incompleteChar ?? "\u2591";
+  }
+  start() {
+    this.current = 0;
+    this.render();
+    return this;
+  }
+  update(current) {
+    this.current = Math.min(current, this.total);
+    this.render();
+    return this;
+  }
+  increment(amount = 1) {
+    return this.update(this.current + amount);
+  }
+  complete() {
+    this.current = this.total;
+    this.render();
+    this.stream.write(`
+`);
+    return this;
+  }
+  render() {
+    const percent = this.current / this.total;
+    const completeWidth = Math.round(this.width * percent);
+    const incompleteWidth = this.width - completeWidth;
+    const complete = this.completeChar.repeat(completeWidth);
+    const incomplete = this.incompleteChar.repeat(incompleteWidth);
+    const bar = colors.green(complete) + colors.dim(incomplete);
+    const percentText = `${Math.round(percent * 100)}%`.padStart(4);
+    const line = `\r${this.text} [${bar}] ${percentText} ${this.current}/${this.total}`;
+    this.stream.write(`\r\x1B[K${line}`);
+  }
+}
+async function runTasks(tasks) {
+  for (const task of tasks) {
+    const s = spinner(task.text);
+    try {
+      await task.task();
+      s.success();
+    } catch (error) {
+      s.error();
+      throw error;
+    }
+  }
+}
+
+// src/cli/utils/fs.ts
+import * as fs from "fs";
+import * as path from "path";
+async function fileExists(filePath) {
+  try {
+    return await Bun.file(filePath).exists();
+  } catch {
+    return false;
+  }
+}
+async function createDirectory(dirPath) {
+  await fs.promises.mkdir(dirPath, { recursive: true });
+}
+async function readFile(filePath) {
+  return await Bun.file(filePath).text();
+}
+async function writeFile(filePath, content) {
+  const dir = path.dirname(filePath);
+  await createDirectory(dir);
+  await Bun.write(filePath, content);
+}
+async function deleteDirectory(dirPath) {
+  await fs.promises.rm(dirPath, { recursive: true, force: true });
+}
+async function listFiles(dirPath, options = {}) {
+  const files = [];
+  async function walk(dir) {
+    const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory() && options.recursive) {
+        await walk(fullPath);
+      } else if (entry.isFile()) {
+        if (!options.pattern || options.pattern.test(entry.name)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  }
+  await walk(dirPath);
+  return files;
+}
+async function findFileUp(startDir, fileName, options = {}) {
+  let currentDir = startDir;
+  const stopAt = options.stopAt ?? "/";
+  while (currentDir !== stopAt && currentDir !== "/") {
+    const filePath = path.join(currentDir, fileName);
+    if (await fileExists(filePath)) {
+      return filePath;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+  return null;
+}
+async function getProjectRoot(startDir = process.cwd()) {
+  const packageJsonPath = await findFileUp(startDir, "package.json");
+  if (packageJsonPath) {
+    return path.dirname(packageJsonPath);
+  }
+  return null;
+}
+async function isBuenoProject(dir = process.cwd()) {
+  const root = await getProjectRoot(dir);
+  if (!root)
+    return false;
+  const configPath = path.join(root, "bueno.config.ts");
+  if (await fileExists(configPath))
+    return true;
+  const packageJsonPath = path.join(root, "package.json");
+  if (await fileExists(packageJsonPath)) {
+    const content = await readFile(packageJsonPath);
+    try {
+      const pkg = JSON.parse(content);
+      return !!(pkg.dependencies?.bueno || pkg.devDependencies?.bueno);
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function joinPaths(...paths) {
+  return path.join(...paths);
+}
+function processTemplate(template, data) {
+  let result = template;
+  result = result.replace(/\{\{#if\s+(\w+)\}\}([\s\S]*?)\{\{\/if\}\}/g, (_, key, content) => {
+    const value = data[key];
+    return value ? content : "";
+  });
+  result = result.replace(/\{\{#each\s+(\w+)\}\}([\s\S]*?)\{\{\/each\}\}/g, (_, key, content) => {
+    const items = data[key];
+    if (!Array.isArray(items))
+      return "";
+    return items.map((item) => {
+      let itemContent = content;
+      if (typeof item === "object" && item !== null) {
+        for (const [k, v] of Object.entries(item)) {
+          itemContent = itemContent.replace(new RegExp(`\\{\\{${k}\\}\\}`, "g"), String(v));
+        }
+      }
+      return itemContent;
+    }).join("");
+  });
+  const helpers = {
+    camelCase: (v) => v.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^(.)/, (c) => c.toLowerCase()),
+    pascalCase: (v) => v.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^(.)/, (c) => c.toUpperCase()),
+    kebabCase: (v) => v.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[-_\s]+/g, "-").toLowerCase(),
+    snakeCase: (v) => v.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase(),
+    upperCase: (v) => v.toUpperCase(),
+    lowerCase: (v) => v.toLowerCase(),
+    capitalize: (v) => v.charAt(0).toUpperCase() + v.slice(1),
+    pluralize: (v) => {
+      if (v.endsWith("y") && !["ay", "ey", "iy", "oy", "uy"].some((e) => v.endsWith(e))) {
+        return v.slice(0, -1) + "ies";
+      }
+      if (v.endsWith("s") || v.endsWith("x") || v.endsWith("z") || v.endsWith("ch") || v.endsWith("sh")) {
+        return v + "es";
+      }
+      return v + "s";
+    }
+  };
+  for (const [helperName, helperFn] of Object.entries(helpers)) {
+    const regex = new RegExp(`\\{\\{${helperName}\\s+(\\w+)\\}\\}`, "g");
+    result = result.replace(regex, (_, key) => {
+      const value = data[key];
+      if (typeof value === "string") {
+        return helperFn(value);
+      }
+      return String(value);
+    });
+  }
+  for (const [key, value] of Object.entries(data)) {
+    const regex = new RegExp(`\\{\\{${key}\\}\\}`, "g");
+    result = result.replace(regex, String(value));
+  }
+  result = result.replace(/^\s*\n/gm, `
+`);
+  result = result.replace(/\n{3,}/g, `
+
+`);
+  return result.trim();
+}
+
+// src/cli/utils/strings.ts
+function kebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[-_\s]+/g, "-").toLowerCase();
+}
+
+// src/cli/templates/docker.ts
+function getDockerfileTemplate(projectName, database) {
+  return `# ${projectName} - Production Dockerfile
+# Multi-stage build for optimized production image
+
+# Stage 1: Install dependencies
+FROM oven/bun:1 AS deps
+
+WORKDIR /app
+
+# Copy package files first for better layer caching
+COPY package.json bun.lock* ./
+
+# Install dependencies
+RUN bun install --frozen-lockfile --production
+
+# Stage 2: Build the application
+FROM oven/bun:1 AS builder
+
+WORKDIR /app
+
+# Copy package files
+COPY package.json bun.lock* ./
+
+# Install all dependencies (including devDependencies for build)
+RUN bun install --frozen-lockfile
+
+# Copy source code
+COPY . .
+
+# Build the application
+RUN bun run build
+
+# Stage 3: Production image
+FROM oven/bun:1 AS runner
+
+WORKDIR /app
+
+# Set production environment
+ENV NODE_ENV=production
+ENV BUN_ENV=production
+
+# Create non-root user for security
+RUN addgroup --system --gid 1001 bunjs \\
+    && adduser --system --uid 1001 --ingroup bunjs bunuser
+
+# Copy built application from builder
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/package.json ./
+
+# Copy config files if they exist
+COPY --from=builder /app/bueno.config.ts* ./
+
+# Set proper ownership
+RUN chown -R bunuser:bunjs /app
+
+# Switch to non-root user
+USER bunuser
+
+# Expose the application port
+EXPOSE 3000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \\
+    CMD curl -f http://localhost:3000/health || exit 1
+
+# Start the application
+CMD ["bun", "run", "dist/main.js"]
+`;
+}
+function getDockerignoreTemplate() {
+  return `# Dependencies
+node_modules/
+
+# Build output
+dist/
+
+# Environment files
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Git
+.git/
+.gitignore
+
+# Docker
+Dockerfile
+docker-compose*.yml
+.dockerignore
+
+# Test files
+tests/
+coverage/
+*.test.ts
+*.spec.ts
+
+# Documentation
+*.md
+!README.md
+
+# Database files (local)
+*.db
+*.sqlite
+*.sqlite3
+
+# Logs
+*.log
+logs/
+
+# Misc
+.editorconfig
+.eslintrc*
+.prettierrc*
+tsconfig.json
+`;
+}
+function getDockerComposeTemplate(projectName, database) {
+  const kebabName = projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  let databaseServices = "";
+  let dependsOn = "";
+  if (database === "postgresql") {
+    databaseServices = `
+  # PostgreSQL Database
+  postgres:
+    image: postgres:16-alpine
+    container_name: ${kebabName}-postgres
+    restart: unless-stopped
+    environment:
+      POSTGRES_USER: \${POSTGRES_USER:-postgres}
+      POSTGRES_PASSWORD: \${POSTGRES_PASSWORD:-postgres}
+      POSTGRES_DB: \${POSTGRES_DB:-${kebabName}}
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    ports:
+      - "\${POSTGRES_PORT:-5432}:5432"
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U \${POSTGRES_USER:-postgres} -d \${POSTGRES_DB:-${kebabName}}"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    networks:
+      - bueno-network
+
+`;
+    dependsOn = `
+    depends_on:
+      postgres:
+        condition: service_healthy
+`;
+  } else if (database === "mysql") {
+    databaseServices = `
+  # MySQL Database
+  mysql:
+    image: mysql:8.0
+    container_name: ${kebabName}-mysql
+    restart: unless-stopped
+    environment:
+      MYSQL_ROOT_PASSWORD: \${MYSQL_ROOT_PASSWORD:-root}
+      MYSQL_USER: \${MYSQL_USER:-mysql}
+      MYSQL_PASSWORD: \${MYSQL_PASSWORD:-mysql}
+      MYSQL_DATABASE: \${MYSQL_DATABASE:-${kebabName}}
+    volumes:
+      - mysql_data:/var/lib/mysql
+    ports:
+      - "\${MYSQL_PORT:-3306}:3306"
+    healthcheck:
+      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "root", "-p\${MYSQL_ROOT_PASSWORD:-root}"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    networks:
+      - bueno-network
+
+`;
+    dependsOn = `
+    depends_on:
+      mysql:
+        condition: service_healthy
+`;
+  }
+  const volumes = database === "postgresql" ? `
+volumes:
+  postgres_data:
+    driver: local
+` : database === "mysql" ? `
+volumes:
+  mysql_data:
+    driver: local
+` : "";
+  const databaseEnv = database === "postgresql" ? `      DATABASE_URL: postgresql://\${POSTGRES_USER:-postgres}:\${POSTGRES_PASSWORD:-postgres}@postgres:5432/\${POSTGRES_DB:-${kebabName}}
+` : database === "mysql" ? `      DATABASE_URL: mysql://\${MYSQL_USER:-mysql}:\${MYSQL_PASSWORD:-mysql}@mysql:3306/\${MYSQL_DATABASE:-${kebabName}}
+` : "";
+  return `# ${projectName} - Docker Compose for Local Development
+# Usage: docker-compose up -d
+
+services:
+  # Application Service
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: ${kebabName}-app
+    restart: unless-stopped
+    ports:
+      - "\${APP_PORT:-3000}:3000"
+    environment:
+      NODE_ENV: production
+      BUN_ENV: production
+${databaseEnv}${dependsOn}    networks:
+      - bueno-network
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 10s
+${databaseServices}networks:
+  bueno-network:
+    driver: bridge
+${volumes}
+`;
+}
+function getDockerEnvTemplate(projectName, database) {
+  const kebabName = projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  let dbEnv = "";
+  if (database === "postgresql") {
+    dbEnv = `
+# PostgreSQL Configuration
+POSTGRES_USER=postgres
+POSTGRES_PASSWORD=postgres
+POSTGRES_DB=${kebabName}
+POSTGRES_PORT=5432
+DATABASE_URL=postgresql://postgres:postgres@localhost:5432/${kebabName}
+`;
+  } else if (database === "mysql") {
+    dbEnv = `
+# MySQL Configuration
+MYSQL_ROOT_PASSWORD=root
+MYSQL_USER=mysql
+MYSQL_PASSWORD=mysql
+MYSQL_DATABASE=${kebabName}
+MYSQL_PORT=3306
+DATABASE_URL=mysql://mysql:mysql@localhost:3306/${kebabName}
+`;
+  }
+  return `# ${projectName} - Docker Environment Variables
+# Copy this file to .env and update values as needed
+
+# Application
+APP_PORT=3000
+NODE_ENV=production
+${dbEnv}`;
+}
+
+// src/cli/templates/deploy.ts
+function getRenderYamlTemplate(projectName, database) {
+  const kebabName = projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  let databaseSection = "";
+  let envVars = "";
+  if (database === "postgresql") {
+    databaseSection = `
+  # PostgreSQL Database
+  - type: pserv
+    name: ${kebabName}-db
+    env: docker
+    region: oregon
+    plan: starter
+    envVars:
+      - key: POSTGRES_USER
+        generateValue: true
+      - key: POSTGRES_PASSWORD
+        generateValue: true
+      - key: POSTGRES_DB
+        value: ${kebabName}
+    disk:
+      name: postgres-data
+      mountPath: /var/lib/postgresql/data
+      sizeGB: 10
+
+`;
+    envVars = `
+    envVars:
+      - key: DATABASE_URL
+        fromDatabase:
+          name: ${kebabName}-db
+          property: connectionString
+      - key: NODE_ENV
+        value: production
+      - key: BUN_ENV
+        value: production
+`;
+  } else if (database === "mysql") {
+    databaseSection = `
+  # MySQL Database (using Render's managed MySQL)
+  - type: pserv
+    name: ${kebabName}-db
+    env: docker
+    region: oregon
+    plan: starter
+    envVars:
+      - key: MYSQL_ROOT_PASSWORD
+        generateValue: true
+      - key: MYSQL_USER
+        generateValue: true
+      - key: MYSQL_PASSWORD
+        generateValue: true
+      - key: MYSQL_DATABASE
+        value: ${kebabName}
+    disk:
+      name: mysql-data
+      mountPath: /var/lib/mysql
+      sizeGB: 10
+
+`;
+    envVars = `
+    envVars:
+      - key: DATABASE_URL
+        fromDatabase:
+          name: ${kebabName}-db
+          property: connectionString
+      - key: NODE_ENV
+        value: production
+      - key: BUN_ENV
+        value: production
+`;
+  } else {
+    envVars = `
+    envVars:
+      - key: NODE_ENV
+        value: production
+      - key: BUN_ENV
+        value: production
+`;
+  }
+  return `# ${projectName} - Render.com Deployment Configuration
+# https://render.com/docs/blueprint-spec
+
+services:
+  # Web Service
+  - type: web
+    name: ${kebabName}
+    env: docker
+    region: oregon
+    plan: starter
+    branch: main
+    dockerfilePath: ./Dockerfile
+    # dockerContext: .
+    numInstances: 1
+    healthCheckPath: /health
+${envVars}    # Auto-deploy on push to main branch
+    autoDeploy: true
+${databaseSection}
+# Blueprint metadata
+metadata:
+  name: ${projectName}
+  description: A Bueno application deployed on Render
+`;
+}
+function getFlyTomlTemplate(projectName) {
+  const kebabName = projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  return `# ${projectName} - Fly.io Deployment Configuration
+# https://fly.io/docs/reference/configuration/
+
+app = "${kebabName}"
+primary_region = "sea"
+
+[build]
+  dockerfile = "Dockerfile"
+
+[env]
+  NODE_ENV = "production"
+  BUN_ENV = "production"
+  PORT = "3000"
+
+[http_service]
+  internal_port = 3000
+  force_https = true
+  auto_stop_machines = "stop"
+  auto_start_machines = true
+  min_machines_running = 0
+  processes = ["app"]
+
+[http_service.concurrency]
+  type = "connections"
+  hard_limit = 100
+  soft_limit = 80
+
+[[http_service.checks]]
+  grace_period = "10s"
+  interval = "30s"
+  method = "GET"
+  timeout = "5s"
+  path = "/health"
+
+  [http_service.checks.headers]
+    Content-Type = "application/json"
+
+[[vm]]
+  cpu_kind = "shared"
+  cpus = 1
+  memory_mb = 512
+
+[[mounts]]
+  source = "data"
+  destination = "/app/data"
+  initial_size = "1GB"
+
+# Scale configuration
+# Use: fly scale count 2  # Scale to 2 machines
+# Use: fly scale vm shared-cpu-2x --memory 1024  # Upgrade VM
+
+# Secrets (set via: fly secrets set KEY=VALUE)
+# DATABASE_URL=your-database-url
+# Any other sensitive environment variables
+`;
+}
+function getRailwayTomlTemplate(projectName) {
+  const kebabName = projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  return `# ${projectName} - Railway Deployment Configuration
+# https://docs.railway.app/reference/config-as-code
+
+[build]
+builder = "DOCKERFILE"
+dockerfilePath = "Dockerfile"
+
+[deploy]
+startCommand = "bun run dist/main.js"
+healthcheckPath = "/health"
+healthcheckTimeout = 300
+restartPolicyType = "ON_FAILURE"
+restartPolicyMaxRetries = 3
+
+# Environment variables
+# Set these in Railway dashboard or via CLI:
+# railway variables set NODE_ENV=production
+# railway variables set DATABASE_URL=your-database-url
+
+[[services]]
+name = "${kebabName}"
+
+[services.variables]
+NODE_ENV = "production"
+BUN_ENV = "production"
+PORT = "3000"
+
+# Health check configuration
+[[services.healthchecks]]
+path = "/health"
+interval = 30
+timeout = 10
+threshold = 3
+
+# Resource configuration
+# Adjust in Railway dashboard or via CLI:
+# railway up --memory 512 --cpu 0.5
+
+# Scaling configuration
+# Use Railway's autoscaling in dashboard:
+# Min instances: 0 (scale to zero)
+# Max instances: 3
+# Target CPU: 70%
+# Target Memory: 80%
+`;
+}
+function getDeployTemplate(platform, projectName, database) {
+  switch (platform) {
+    case "render":
+      return getRenderYamlTemplate(projectName, database);
+    case "fly":
+      return getFlyTomlTemplate(projectName);
+    case "railway":
+      return getRailwayTomlTemplate(projectName);
+    default:
+      throw new Error(`Unknown deployment platform: ${platform}`);
+  }
+}
+function getDeployFilename(platform) {
+  switch (platform) {
+    case "render":
+      return "render.yaml";
+    case "fly":
+      return "fly.toml";
+    case "railway":
+      return "railway.toml";
+    default:
+      throw new Error(`Unknown deployment platform: ${platform}`);
+  }
+}
+function getDeployPlatformName(platform) {
+  switch (platform) {
+    case "render":
+      return "Render.com";
+    case "fly":
+      return "Fly.io";
+    case "railway":
+      return "Railway";
+    default:
+      return platform;
+  }
+}
+
+// src/cli/commands/new.ts
+function validateProjectName(name) {
+  if (!name || name.length === 0) {
+    return "Project name is required";
+  }
+  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+    return "Project name can only contain letters, numbers, hyphens, and underscores";
+  }
+  if (name.startsWith("-") || name.startsWith("_")) {
+    return "Project name cannot start with a hyphen or underscore";
+  }
+  if (name.length > 100) {
+    return "Project name is too long (max 100 characters)";
+  }
+  return true;
+}
+function getPackageJsonTemplate(config) {
+  const dependencies = {
+    bueno: "^0.1.0"
+  };
+  const devDependencies = {
+    "@types/bun": "latest",
+    typescript: "^5.3.0"
+  };
+  if (config.template === "fullstack" || config.template === "default") {
+    dependencies.zod = "^4.0.0";
+  }
+  const scripts = {
+    dev: "bun run --watch server/main.ts",
+    build: "bun build ./server/main.ts --outdir ./dist --target bun",
+    start: "bun run dist/main.js",
+    test: "bun test"
+  };
+  if (config.template === "fullstack") {
+    scripts["dev:frontend"] = "bun run --watch client/index.html";
+  }
+  return JSON.stringify({
+    name: kebabCase(config.name),
+    version: "0.1.0",
+    type: "module",
+    scripts,
+    dependencies,
+    devDependencies
+  }, null, 2);
+}
+function getTsConfigTemplate() {
+  return JSON.stringify({
+    compilerOptions: {
+      target: "ESNext",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      strict: true,
+      skipLibCheck: true,
+      esModuleInterop: true,
+      allowSyntheticDefaultImports: true,
+      jsx: "react-jsx",
+      paths: {
+        bueno: ["./node_modules/bueno/dist/index.d.ts"]
+      }
+    },
+    include: ["server/**/*", "client/**/*"],
+    exclude: ["node_modules", "dist"]
+  }, null, 2);
+}
+function getMainTemplate(config) {
+  if (config.template === "minimal") {
+    return `import { createServer } from 'bueno';
+
+const app = createServer();
+
+app.router.get('/', () => {
+  return { message: 'Hello, Bueno!' };
+});
+
+await app.listen(3000);
+`;
+  }
+  return `import { createApp, Module, Controller, Get, Injectable } from 'bueno';
+import type { Context } from 'bueno';
+
+// Services
+@Injectable()
+export class AppService {
+  findAll() {
+    return { message: 'Welcome to Bueno!', items: [] };
+  }
+}
+
+// Controllers
+@Controller()
+export class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get()
+  findAll(ctx: Context) {
+    return this.appService.findAll();
+  }
+
+  @Get('health')
+  health(ctx: Context) {
+    return { status: 'ok', timestamp: new Date().toISOString() };
+  }
+}
+
+// Module
+@Module({
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}
+
+// Bootstrap
+const app = createApp(AppModule);
+await app.listen(3000);
+`;
+}
+function getConfigTemplate(config) {
+  const dbConfig = config.database === "sqlite" ? `{ url: 'sqlite:./data.db' }` : `{ url: process.env.DATABASE_URL ?? '${config.database}://localhost/${kebabCase(config.name)}' }`;
+  return `import { defineConfig } from 'bueno';
+
+export default defineConfig({
+  server: {
+    port: 3000,
+    host: 'localhost',
+  },
+
+  database: ${dbConfig},
+
+  logger: {
+    level: 'info',
+    pretty: true,
+  },
+
+  health: {
+    enabled: true,
+    healthPath: '/health',
+    readyPath: '/ready',
+  },
+});
+`;
+}
+function getEnvExampleTemplate(config) {
+  if (config.database === "sqlite") {
+    return `# Bueno Environment Variables
+NODE_ENV=development
+`;
+  }
+  return `# Bueno Environment Variables
+NODE_ENV=development
+DATABASE_URL=${config.database}://user:password@localhost:5432/${kebabCase(config.name)}
+`;
+}
+function getGitignoreTemplate() {
+  return `# Dependencies
+node_modules/
+
+# Build output
+dist/
+
+# Environment files
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+
+# Test coverage
+coverage/
+`;
+}
+function getReadmeTemplate(config) {
+  return `# ${config.name}
+
+A Bueno application.
+
+## Getting Started
+
+\`\`\`bash
+# Install dependencies
+bun install
+
+# Start development server
+bun run dev
+
+# Build for production
+bun run build
+
+# Start production server
+bun run start
+\`\`\`
+
+## Project Structure
+
+\`\`\`
+\u251C\u2500\u2500 server/           # Server-side code
+\u2502   \u251C\u2500\u2500 main.ts       # Entry point
+\u2502   \u251C\u2500\u2500 modules/      # Feature modules
+\u2502   \u2514\u2500\u2500 database/     # Database files
+\u251C\u2500\u2500 client/           # Client-side code (if applicable)
+\u251C\u2500\u2500 tests/            # Test files
+\u2514\u2500\u2500 bueno.config.ts   # Configuration
+\`\`\`
+
+## Learn More
+
+- [Bueno Documentation](https://github.com/sivaraj/bueno#readme)
+- [Bun Documentation](https://bun.sh/docs)
+`;
+}
+async function createProjectFiles(projectPath, config) {
+  const tasks = [];
+  tasks.push({
+    text: "Creating project structure",
+    task: async () => {
+      await createDirectory(joinPaths(projectPath, "server", "modules", "app"));
+      await createDirectory(joinPaths(projectPath, "server", "common", "middleware"));
+      await createDirectory(joinPaths(projectPath, "server", "common", "guards"));
+      await createDirectory(joinPaths(projectPath, "server", "common", "interceptors"));
+      await createDirectory(joinPaths(projectPath, "server", "common", "pipes"));
+      await createDirectory(joinPaths(projectPath, "server", "common", "filters"));
+      await createDirectory(joinPaths(projectPath, "server", "database", "migrations"));
+      await createDirectory(joinPaths(projectPath, "server", "config"));
+      await createDirectory(joinPaths(projectPath, "tests", "unit"));
+      await createDirectory(joinPaths(projectPath, "tests", "integration"));
+    }
+  });
+  tasks.push({
+    text: "Creating package.json",
+    task: async () => {
+      await writeFile(joinPaths(projectPath, "package.json"), getPackageJsonTemplate(config));
+    }
+  });
+  tasks.push({
+    text: "Creating tsconfig.json",
+    task: async () => {
+      await writeFile(joinPaths(projectPath, "tsconfig.json"), getTsConfigTemplate());
+    }
+  });
+  tasks.push({
+    text: "Creating server/main.ts",
+    task: async () => {
+      await writeFile(joinPaths(projectPath, "server", "main.ts"), getMainTemplate(config));
+    }
+  });
+  tasks.push({
+    text: "Creating bueno.config.ts",
+    task: async () => {
+      await writeFile(joinPaths(projectPath, "bueno.config.ts"), getConfigTemplate(config));
+    }
+  });
+  tasks.push({
+    text: "Creating .env.example",
+    task: async () => {
+      await writeFile(joinPaths(projectPath, ".env.example"), getEnvExampleTemplate(config));
+    }
+  });
+  tasks.push({
+    text: "Creating .gitignore",
+    task: async () => {
+      await writeFile(joinPaths(projectPath, ".gitignore"), getGitignoreTemplate());
+    }
+  });
+  tasks.push({
+    text: "Creating README.md",
+    task: async () => {
+      await writeFile(joinPaths(projectPath, "README.md"), getReadmeTemplate(config));
+    }
+  });
+  if (config.docker) {
+    tasks.push({
+      text: "Creating Dockerfile",
+      task: async () => {
+        await writeFile(joinPaths(projectPath, "Dockerfile"), getDockerfileTemplate(config.name, config.database));
+      }
+    });
+    tasks.push({
+      text: "Creating .dockerignore",
+      task: async () => {
+        await writeFile(joinPaths(projectPath, ".dockerignore"), getDockerignoreTemplate());
+      }
+    });
+    tasks.push({
+      text: "Creating docker-compose.yml",
+      task: async () => {
+        await writeFile(joinPaths(projectPath, "docker-compose.yml"), getDockerComposeTemplate(config.name, config.database));
+      }
+    });
+    tasks.push({
+      text: "Creating .env.docker",
+      task: async () => {
+        await writeFile(joinPaths(projectPath, ".env.docker"), getDockerEnvTemplate(config.name, config.database));
+      }
+    });
+  }
+  for (const platform of config.deploy) {
+    const filename = getDeployFilename(platform);
+    tasks.push({
+      text: `Creating ${filename} for ${getDeployPlatformName(platform)}`,
+      task: async () => {
+        await writeFile(joinPaths(projectPath, filename), getDeployTemplate(platform, config.name, config.database));
+      }
+    });
+  }
+  await runTasks(tasks);
+}
+async function handleNew(args) {
+  let name = args.positionals[0];
+  const useDefaults = hasFlag(args, "yes") || hasFlag(args, "y");
+  if (!name && isInteractive()) {
+    name = await prompt("Project name:", {
+      validate: validateProjectName
+    });
+  }
+  if (!name) {
+    throw new CLIError("Project name is required. Usage: bueno new <project-name>", "INVALID_ARGS" /* INVALID_ARGS */);
+  }
+  const validation = validateProjectName(name);
+  if (validation !== true) {
+    throw new CLIError(validation, "INVALID_ARGS" /* INVALID_ARGS */);
+  }
+  let template = getOption(args, "template", {
+    name: "template",
+    alias: "t",
+    type: "string",
+    description: ""
+  });
+  let framework = getOption(args, "framework", {
+    name: "framework",
+    alias: "f",
+    type: "string",
+    description: ""
+  });
+  let database = getOption(args, "database", {
+    name: "database",
+    alias: "d",
+    type: "string",
+    description: ""
+  });
+  const skipInstall = hasFlag(args, "skip-install");
+  const skipGit = hasFlag(args, "skip-git");
+  const docker = hasFlag(args, "docker");
+  const deployPlatforms = getOptionValues(args, "deploy");
+  const validPlatforms = ["render", "fly", "railway"];
+  const deploy = [];
+  for (const platform of deployPlatforms) {
+    if (validPlatforms.includes(platform)) {
+      if (!deploy.includes(platform)) {
+        deploy.push(platform);
+      }
+    } else {
+      throw new CLIError(`Invalid deployment platform: ${platform}. Valid options are: ${validPlatforms.join(", ")}`, "INVALID_ARGS" /* INVALID_ARGS */);
+    }
+  }
+  if (!useDefaults && isInteractive()) {
+    if (!template) {
+      template = await select("Select a template:", [
+        { value: "default", name: "Default - Standard project with modules and database" },
+        { value: "minimal", name: "Minimal - Bare minimum project structure" },
+        { value: "fullstack", name: "Fullstack - Full-stack project with SSR and auth" },
+        { value: "api", name: "API - API-only project without frontend" }
+      ], { default: "default" });
+    }
+    if ((template === "fullstack" || template === "default") && !framework) {
+      framework = await select("Select a frontend framework:", [
+        { value: "react", name: "React" },
+        { value: "vue", name: "Vue" },
+        { value: "svelte", name: "Svelte" },
+        { value: "solid", name: "Solid" }
+      ], { default: "react" });
+    }
+    if (!database) {
+      database = await select("Select a database:", [
+        { value: "sqlite", name: "SQLite - Local file-based database" },
+        { value: "postgresql", name: "PostgreSQL - Production-ready relational database" },
+        { value: "mysql", name: "MySQL - Popular relational database" }
+      ], { default: "sqlite" });
+    }
+  }
+  template = template || "default";
+  framework = framework || "react";
+  database = database || "sqlite";
+  const config = {
+    name,
+    template,
+    framework,
+    database,
+    skipInstall,
+    skipGit,
+    docker,
+    deploy
+  };
+  const projectPath = joinPaths(process.cwd(), kebabCase(name));
+  if (await fileExists(projectPath)) {
+    throw new CLIError(`Directory already exists: ${kebabCase(name)}`, "FILE_EXISTS" /* FILE_EXISTS */);
+  }
+  cliConsole.header(`Creating a new Bueno project: ${colors.cyan(name)}`);
+  const rows = [
+    ["Template", template],
+    ["Framework", framework],
+    ["Database", database],
+    ["Docker", docker ? colors.green("Yes") : colors.red("No")],
+    ["Deploy", deploy.length > 0 ? colors.green(deploy.map(getDeployPlatformName).join(", ")) : colors.red("None")],
+    ["Install dependencies", skipInstall ? colors.red("No") : colors.green("Yes")],
+    ["Initialize git", skipGit ? colors.red("No") : colors.green("Yes")]
+  ];
+  printTable(["Setting", "Value"], rows);
+  cliConsole.log("");
+  cliConsole.subheader("Creating project files...");
+  await createProjectFiles(projectPath, config);
+  if (!skipInstall) {
+    cliConsole.subheader("Installing dependencies...");
+    const installSpinner = spinner("Running bun install...");
+    try {
+      const proc = Bun.spawn(["bun", "install"], {
+        cwd: projectPath,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const exitCode = await proc.exited;
+      if (exitCode === 0) {
+        installSpinner.success("Dependencies installed");
+      } else {
+        installSpinner.warn("Failed to install dependencies. Run `bun install` manually.");
+      }
+    } catch {
+      installSpinner.warn("Failed to install dependencies. Run `bun install` manually.");
+    }
+  }
+  if (!skipGit) {
+    cliConsole.subheader("Initializing git repository...");
+    const gitSpinner = spinner("Running git init...");
+    try {
+      const proc = Bun.spawn(["git", "init"], {
+        cwd: projectPath,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const exitCode = await proc.exited;
+      if (exitCode === 0) {
+        Bun.spawn(["git", "add", "."], { cwd: projectPath });
+        Bun.spawn(["git", "commit", "-m", "Initial commit from Bueno CLI"], {
+          cwd: projectPath
+        });
+        gitSpinner.success("Git repository initialized");
+      } else {
+        gitSpinner.warn("Failed to initialize git. Run `git init` manually.");
+      }
+    } catch {
+      gitSpinner.warn("Failed to initialize git. Run `git init` manually.");
+    }
+  }
+  cliConsole.log("");
+  cliConsole.success(`Project created successfully!`);
+  cliConsole.log("");
+  cliConsole.log("Next steps:");
+  cliConsole.log(`  ${colors.cyan(`cd ${kebabCase(name)}`)}`);
+  cliConsole.log(`  ${colors.cyan("bun run dev")}`);
+  cliConsole.log("");
+  cliConsole.log(`Documentation: ${colors.dim("https://github.com/sivaraj/bueno")}`);
+}
+defineCommand({
+  name: "new",
+  description: "Create a new Bueno project",
+  positionals: [
+    {
+      name: "name",
+      required: false,
+      description: "Project name"
+    }
+  ],
+  options: [
+    {
+      name: "template",
+      alias: "t",
+      type: "string",
+      description: "Project template (default, minimal, fullstack, api)"
+    },
+    {
+      name: "framework",
+      alias: "f",
+      type: "string",
+      description: "Frontend framework (react, vue, svelte, solid)"
+    },
+    {
+      name: "database",
+      alias: "d",
+      type: "string",
+      description: "Database driver (sqlite, postgresql, mysql)"
+    },
+    {
+      name: "skip-install",
+      type: "boolean",
+      default: false,
+      description: "Skip dependency installation"
+    },
+    {
+      name: "skip-git",
+      type: "boolean",
+      default: false,
+      description: "Skip git initialization"
+    },
+    {
+      name: "docker",
+      type: "boolean",
+      default: false,
+      description: "Include Docker configuration (Dockerfile, docker-compose.yml)"
+    },
+    {
+      name: "deploy",
+      type: "string",
+      description: "Deployment platform configuration (render, fly, railway). Can be specified multiple times."
+    },
+    {
+      name: "yes",
+      alias: "y",
+      type: "boolean",
+      default: false,
+      description: "Use default options without prompts"
+    }
+  ],
+  examples: [
+    "bueno new my-app",
+    "bueno new my-api --template api",
+    "bueno new my-fullstack --template fullstack --framework react",
+    "bueno new my-project --database postgresql",
+    "bueno new my-app --docker",
+    "bueno new my-app --docker --database postgresql",
+    "bueno new my-app --deploy render",
+    "bueno new my-app --deploy fly",
+    "bueno new my-app --deploy render --deploy fly",
+    "bueno new my-app --docker --deploy render",
+    "bueno new my-app --docker --database postgresql --deploy render",
+    "bueno new my-app -y"
+  ]
+}, handleNew);
+
+// src/cli/commands/generate.ts
+var GENERATOR_ALIASES = {
+  c: "controller",
+  s: "service",
+  m: "module",
+  gu: "guard",
+  i: "interceptor",
+  p: "pipe",
+  f: "filter",
+  d: "dto",
+  mw: "middleware",
+  mi: "migration"
+};
+function getTemplate(type) {
+  const templates = {
+    controller: `import { Controller, Get, Post, Put, Delete{{#if path}} } from 'bueno'{{/if}}{{#if service}}, { {{pascalCase service}}Service } from './{{kebabCase service}}.service'{{/if}};
+import type { Context } from 'bueno';
+
+@Controller('{{path}}')
+export class {{pascalCase name}}Controller {
+  {{#if service}}
+  constructor(private readonly {{camelCase service}}Service: {{pascalCase service}}Service) {}
+  {{/if}}
+
+  @Get()
+  async findAll(ctx: Context) {
+    return { message: '{{pascalCase name}} controller' };
+  }
+
+  @Get(':id')
+  async findOne(ctx: Context) {
+    const id = ctx.params.id;
+    return { id, message: '{{pascalCase name}} item' };
+  }
+
+  @Post()
+  async create(ctx: Context) {
+    const body = await ctx.body();
+    return { message: 'Created', data: body };
+  }
+
+  @Put(':id')
+  async update(ctx: Context) {
+    const id = ctx.params.id;
+    const body = await ctx.body();
+    return { id, message: 'Updated', data: body };
+  }
+
+  @Delete(':id')
+  async remove(ctx: Context) {
+    const id = ctx.params.id;
+    return { id, message: 'Deleted' };
+  }
+}
+`,
+    service: `import { Injectable } from 'bueno';
+
+@Injectable()
+export class {{pascalCase name}}Service {
+  async findAll() {
+    // TODO: Implement findAll
+    return [];
+  }
+
+  async findOne(id: string) {
+    // TODO: Implement findOne
+    return { id };
+  }
+
+  async create(data: unknown) {
+    // TODO: Implement create
+    return data;
+  }
+
+  async update(id: string, data: unknown) {
+    // TODO: Implement update
+    return { id, ...data };
+  }
+
+  async remove(id: string) {
+    // TODO: Implement remove
+    return { id };
+  }
+}
+`,
+    module: `import { Module } from 'bueno';
+import { {{pascalCase name}}Controller } from './{{kebabCase name}}.controller';
+import { {{pascalCase name}}Service } from './{{kebabCase name}}.service';
+
+@Module({
+  controllers: [{{pascalCase name}}Controller],
+  providers: [{{pascalCase name}}Service],
+  exports: [{{pascalCase name}}Service],
+})
+export class {{pascalCase name}}Module {}
+`,
+    guard: `import { Injectable, type CanActivate, type Context } from 'bueno';
+
+@Injectable()
+export class {{pascalCase name}}Guard implements CanActivate {
+  async canActivate(ctx: Context): Promise<boolean> {
+    // TODO: Implement guard logic
+    // Return true to allow access, false to deny
+    return true;
+  }
+}
+`,
+    interceptor: `import { Injectable, type NestInterceptor, type CallHandler, type Context } from 'bueno';
+import type { Observable } from 'rxjs';
+
+@Injectable()
+export class {{pascalCase name}}Interceptor implements NestInterceptor {
+  async intercept(ctx: Context, next: CallHandler): Promise<Observable<unknown>> {
+    // Before handler execution
+    console.log('{{pascalCase name}}Interceptor - Before');
+
+    // Call the handler
+    const result = await next.handle();
+
+    // After handler execution
+    console.log('{{pascalCase name}}Interceptor - After');
+
+    return result;
+  }
+}
+`,
+    pipe: `import { Injectable, type PipeTransform, type Context } from 'bueno';
+
+@Injectable()
+export class {{pascalCase name}}Pipe implements PipeTransform {
+  async transform(value: unknown, ctx: Context): Promise<unknown> {
+    // TODO: Implement transformation/validation logic
+    // Throw an error to reject the value
+    return value;
+  }
+}
+`,
+    filter: `import { Injectable, type ExceptionFilter, type Context } from 'bueno';
+import type { Response } from 'bueno';
+
+@Injectable()
+export class {{pascalCase name}}Filter implements ExceptionFilter {
+  async catch(exception: Error, ctx: Context): Promise<Response> {
+    // TODO: Implement exception handling
+    console.error('{{pascalCase name}}Filter caught:', exception);
+
+    return new Response(
+      JSON.stringify({
+        statusCode: 500,
+        message: 'Internal Server Error',
+        error: exception.message,
+      }),
+      {
+        status: 500,
+        headers: { 'Content-Type': 'application/json' },
+      }
+    );
+  }
+}
+`,
+    dto: `/**
+ * {{pascalCase name}} DTO
+ */
+export interface {{pascalCase name}}Dto {
+  // TODO: Define properties
+  id?: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+/**
+ * Create {{pascalCase name}} DTO
+ */
+export interface Create{{pascalCase name}}Dto {
+  // TODO: Define required properties for creation
+}
+
+/**
+ * Update {{pascalCase name}} DTO
+ */
+export interface Update{{pascalCase name}}Dto extends Partial<Create{{pascalCase name}}Dto> {
+  // TODO: Define optional properties for update
+}
+`,
+    middleware: `import type { Middleware, Context, Handler } from 'bueno';
+
+/**
+ * {{pascalCase name}} Middleware
+ */
+export const {{camelCase name}}Middleware: Middleware = async (
+  ctx: Context,
+  next: Handler
+) => {
+  // Before handler execution
+  console.log('{{pascalCase name}}Middleware - Before');
+
+  // Call the next handler
+  const result = await next();
+
+  // After handler execution
+  console.log('{{pascalCase name}}Middleware - After');
+
+  return result;
+};
+`,
+    migration: `import { createMigration, type MigrationRunner } from 'bueno';
+
+export default createMigration('{{migrationId}}', '{{migrationName}}')
+  .up(async (db: MigrationRunner) => {
+    // TODO: Add migration logic
+    // Example:
+    // await db.createTable({
+    //   name: '{{tableName}}',
+    //   columns: [
+    //     { name: 'id', type: 'uuid', primary: true },
+    //     { name: 'created_at', type: 'timestamp', default: 'NOW()' },
+    //   ],
+    // });
+  })
+  .down(async (db: MigrationRunner) => {
+    // TODO: Add rollback logic
+    // Example:
+    // await db.dropTable('{{tableName}}');
+  });
+`
+  };
+  return templates[type];
+}
+function getFileExtension(type) {
+  return type === "dto" ? ".dto.ts" : ".ts";
+}
+function getDefaultDirectory(type) {
+  switch (type) {
+    case "controller":
+    case "service":
+    case "module":
+    case "dto":
+      return "modules";
+    case "guard":
+      return "common/guards";
+    case "interceptor":
+      return "common/interceptors";
+    case "pipe":
+      return "common/pipes";
+    case "filter":
+      return "common/filters";
+    case "middleware":
+      return "common/middleware";
+    case "migration":
+      return "database/migrations";
+    default:
+      return "";
+  }
+}
+async function generateFile(config) {
+  const { type, name, module, path: customPath, dryRun, force } = config;
+  const projectRoot = await getProjectRoot();
+  if (!projectRoot) {
+    throw new CLIError("Not in a Bueno project directory", "NOT_FOUND" /* NOT_FOUND */);
+  }
+  const kebabName = kebabCase(name);
+  const defaultDir = getDefaultDirectory(type);
+  let targetDir;
+  if (customPath) {
+    targetDir = joinPaths(projectRoot, customPath);
+  } else if (module) {
+    targetDir = joinPaths(projectRoot, "server", defaultDir, kebabCase(module));
+  } else if (type === "migration") {
+    targetDir = joinPaths(projectRoot, "server", defaultDir);
+  } else {
+    targetDir = joinPaths(projectRoot, "server", defaultDir, kebabName);
+  }
+  const fileName = type === "migration" ? `${generateMigrationId()}_${kebabName}${getFileExtension(type)}` : `${kebabName}${getFileExtension(type)}`;
+  const filePath = joinPaths(targetDir, fileName);
+  if (!force && await fileExists(filePath)) {
+    if (isInteractive()) {
+      const shouldOverwrite = await confirm(`File ${colors.cyan(filePath)} already exists. Overwrite?`, { default: false });
+      if (!shouldOverwrite) {
+        throw new CLIError("File already exists. Use --force to overwrite.", "FILE_EXISTS" /* FILE_EXISTS */);
+      }
+    } else {
+      throw new CLIError(`File already exists: ${filePath}. Use --force to overwrite.`, "FILE_EXISTS" /* FILE_EXISTS */);
+    }
+  }
+  const template = getTemplate(type);
+  const content = processTemplate(template, {
+    name,
+    module: module ?? "",
+    path: customPath ?? kebabName,
+    service: type === "controller" ? name : "",
+    migrationId: generateMigrationId(),
+    migrationName: name,
+    tableName: kebabName
+  });
+  if (dryRun) {
+    cliConsole.log(`
+${colors.bold("File:")} ${filePath}`);
+    cliConsole.log(colors.bold("Content:"));
+    cliConsole.log(content);
+    cliConsole.log("");
+  } else {
+    await writeFile(filePath, content);
+  }
+  return filePath;
+}
+function generateMigrationId() {
+  const now = new Date;
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  const hour = String(now.getHours()).padStart(2, "0");
+  const minute = String(now.getMinutes()).padStart(2, "0");
+  const second = String(now.getSeconds()).padStart(2, "0");
+  return `${year}${month}${day}${hour}${minute}${second}`;
+}
+async function handleGenerate(args) {
+  const typeArg = args.positionals[0];
+  if (!typeArg) {
+    throw new CLIError("Generator type is required. Usage: bueno generate <type> <name>", "INVALID_ARGS" /* INVALID_ARGS */);
+  }
+  const type = GENERATOR_ALIASES[typeArg] ?? typeArg;
+  if (!getTemplate(type)) {
+    throw new CLIError(`Unknown generator type: ${typeArg}. Available types: controller, service, module, guard, interceptor, pipe, filter, dto, middleware, migration`, "INVALID_ARGS" /* INVALID_ARGS */);
+  }
+  const name = args.positionals[1];
+  if (!name) {
+    throw new CLIError("Name is required. Usage: bueno generate <type> <name>", "INVALID_ARGS" /* INVALID_ARGS */);
+  }
+  const config = {
+    type,
+    name,
+    module: getOption(args, "module", {
+      name: "module",
+      type: "string",
+      description: ""
+    }),
+    path: getOption(args, "path", {
+      name: "path",
+      type: "string",
+      description: ""
+    }),
+    dryRun: hasFlag(args, "dry-run"),
+    force: hasFlag(args, "force")
+  };
+  if (!config.dryRun && !await isBuenoProject()) {
+    throw new CLIError("Not in a Bueno project directory. Run this command from a Bueno project.", "NOT_FOUND" /* NOT_FOUND */);
+  }
+  const s = spinner(`Generating ${colors.cyan(type)} ${colors.cyan(name)}...`);
+  try {
+    const filePath = await generateFile(config);
+    if (config.dryRun) {
+      s.info("Dry run complete");
+    } else {
+      s.success(`Created ${colors.green(filePath)}`);
+    }
+  } catch (error) {
+    s.error();
+    throw error;
+  }
+}
+defineCommand({
+  name: "generate",
+  alias: "g",
+  description: "Generate code artifacts (controllers, services, modules, etc.)",
+  positionals: [
+    {
+      name: "type",
+      required: true,
+      description: "Type of artifact to generate (controller, service, module, guard, interceptor, pipe, filter, dto, middleware, migration)"
+    },
+    {
+      name: "name",
+      required: true,
+      description: "Name of the artifact"
+    }
+  ],
+  options: [
+    {
+      name: "module",
+      alias: "m",
+      type: "string",
+      description: "Parent module to register with"
+    },
+    {
+      name: "path",
+      type: "string",
+      description: "Custom path for controller routes"
+    },
+    {
+      name: "dry-run",
+      type: "boolean",
+      default: false,
+      description: "Show what would be created without writing"
+    },
+    {
+      name: "force",
+      type: "boolean",
+      default: false,
+      description: "Overwrite existing files"
+    }
+  ],
+  examples: [
+    "bueno generate controller users",
+    "bueno g service auth",
+    "bueno g module posts",
+    "bueno g guard auth-guard --module auth",
+    "bueno g dto create-user --module users"
+  ]
+}, handleGenerate);
+
+// src/cli/commands/migration.ts
+function generateMigrationId2() {
+  const now = new Date;
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  const hour = String(now.getHours()).padStart(2, "0");
+  const minute = String(now.getMinutes()).padStart(2, "0");
+  const second = String(now.getSeconds()).padStart(2, "0");
+  return `${year}${month}${day}${hour}${minute}${second}`;
+}
+async function getMigrationsDir() {
+  const projectRoot = await getProjectRoot();
+  if (!projectRoot) {
+    throw new CLIError("Not in a project directory", "NOT_FOUND" /* NOT_FOUND */);
+  }
+  const possibleDirs = [
+    joinPaths(projectRoot, "server", "database", "migrations"),
+    joinPaths(projectRoot, "database", "migrations"),
+    joinPaths(projectRoot, "migrations")
+  ];
+  for (const dir of possibleDirs) {
+    if (await fileExists(dir)) {
+      return dir;
+    }
+  }
+  return possibleDirs[0] ?? "";
+}
+async function getMigrationFiles(dir) {
+  if (!await fileExists(dir)) {
+    return [];
+  }
+  const files = await listFiles(dir, {
+    recursive: false,
+    pattern: /\.ts$/
+  });
+  return files.sort();
+}
+function parseMigrationFile(filename) {
+  const match = filename.match(/^(\d+)_(.+)\.ts$/);
+  if (!match || !match[1] || !match[2]) {
+    return { id: filename, name: filename };
+  }
+  return { id: match[1], name: match[2] };
+}
+async function createMigration(name, dryRun) {
+  const migrationsDir = await getMigrationsDir();
+  const id = generateMigrationId2();
+  const kebabName = name.toLowerCase().replace(/\s+/g, "-");
+  const fileName = `${id}_${kebabName}.ts`;
+  const filePath = joinPaths(migrationsDir, fileName);
+  const template = `import { createMigration, type MigrationRunner } from 'bueno';
+
+export default createMigration('${id}', '${kebabName}')
+  .up(async (db: MigrationRunner) => {
+    // TODO: Add migration logic
+    // Example:
+    // await db.createTable({
+    //   name: '${kebabName}',
+    //   columns: [
+    //     { name: 'id', type: 'uuid', primary: true },
+    //     { name: 'created_at', type: 'timestamp', default: 'NOW()' },
+    //   ],
+    // });
+  })
+  .down(async (db: MigrationRunner) => {
+    // TODO: Add rollback logic
+    // Example:
+    // await db.dropTable('${kebabName}');
+  });
+`;
+  if (dryRun) {
+    cliConsole.log(`
+${colors.bold("File:")} ${filePath}`);
+    cliConsole.log(colors.bold("Content:"));
+    cliConsole.log(template);
+    cliConsole.log("");
+    return filePath;
+  }
+  await writeFile(filePath, template);
+  return filePath;
+}
+async function showStatus() {
+  const migrationsDir = await getMigrationsDir();
+  const files = await getMigrationFiles(migrationsDir);
+  if (files.length === 0) {
+    cliConsole.info("No migrations found");
+    return;
+  }
+  cliConsole.header("Migration Status");
+  const rows = files.map((file) => {
+    const info = parseMigrationFile(file.split("/").pop() ?? "");
+    return [info.id, info.name, colors.yellow("Pending")];
+  });
+  printTable(["ID", "Name", "Status"], rows);
+  cliConsole.log("");
+  cliConsole.log(`Total: ${files.length} migration(s)`);
+}
+async function handleMigration(args) {
+  const action = args.positionals[0];
+  if (!action) {
+    throw new CLIError("Action is required. Usage: bueno migration <action>", "INVALID_ARGS" /* INVALID_ARGS */);
+  }
+  const validActions = ["create", "up", "down", "reset", "refresh", "status"];
+  if (!validActions.includes(action)) {
+    throw new CLIError(`Unknown action: ${action}. Valid actions: ${validActions.join(", ")}`, "INVALID_ARGS" /* INVALID_ARGS */);
+  }
+  const dryRun = hasFlag(args, "dry-run");
+  const steps = getOption(args, "steps", {
+    name: "steps",
+    alias: "n",
+    type: "number",
+    default: 1,
+    description: ""
+  });
+  if (action !== "create" || !dryRun) {
+    if (!await isBuenoProject()) {
+      throw new CLIError("Not in a Bueno project directory. Run this command from a Bueno project.", "NOT_FOUND" /* NOT_FOUND */);
+    }
+  }
+  switch (action) {
+    case "create": {
+      const name = args.positionals[1];
+      if (!name) {
+        throw new CLIError("Migration name is required. Usage: bueno migration create <name>", "INVALID_ARGS" /* INVALID_ARGS */);
+      }
+      const s = spinner(`Creating migration ${colors.cyan(name)}...`);
+      try {
+        const filePath = await createMigration(name, dryRun);
+        if (dryRun) {
+          s.info("Dry run complete");
+        } else {
+          s.success(`Created ${colors.green(filePath)}`);
+        }
+      } catch (error) {
+        s.error();
+        throw error;
+      }
+      break;
+    }
+    case "up": {
+      cliConsole.info("Running pending migrations...");
+      cliConsole.log("");
+      cliConsole.warn("Migration execution requires database connection. Use the MigrationRunner in your application code.");
+      cliConsole.log("");
+      cliConsole.log("Example:");
+      cliConsole.log(colors.cyan(`
+import { createMigrationRunner, loadMigrations } from 'bueno';
+import { db } from './database';
+
+const runner = createMigrationRunner(db);
+const migrations = await loadMigrations('./database/migrations');
+await runner.migrate(migrations);
+`));
+      break;
+    }
+    case "down": {
+      cliConsole.info(`Rolling back ${steps} migration(s)...`);
+      cliConsole.log("");
+      cliConsole.warn("Migration rollback requires database connection. Use the MigrationRunner in your application code.");
+      cliConsole.log("");
+      cliConsole.log("Example:");
+      cliConsole.log(colors.cyan(`
+import { createMigrationRunner, loadMigrations } from 'bueno';
+import { db } from './database';
+
+const runner = createMigrationRunner(db);
+const migrations = await loadMigrations('./database/migrations');
+await runner.rollback(migrations, ${steps});
+`));
+      break;
+    }
+    case "reset": {
+      cliConsole.info("Rolling back all migrations...");
+      cliConsole.log("");
+      cliConsole.warn("Migration reset requires database connection. Use the MigrationRunner in your application code.");
+      cliConsole.log("");
+      cliConsole.log("Example:");
+      cliConsole.log(colors.cyan(`
+import { createMigrationRunner, loadMigrations } from 'bueno';
+import { db } from './database';
+
+const runner = createMigrationRunner(db);
+const migrations = await loadMigrations('./database/migrations');
+await runner.reset(migrations);
+`));
+      break;
+    }
+    case "refresh": {
+      cliConsole.info("Refreshing all migrations...");
+      cliConsole.log("");
+      cliConsole.warn("Migration refresh requires database connection. Use the MigrationRunner in your application code.");
+      cliConsole.log("");
+      cliConsole.log("Example:");
+      cliConsole.log(colors.cyan(`
+import { createMigrationRunner, loadMigrations } from 'bueno';
+import { db } from './database';
+
+const runner = createMigrationRunner(db);
+const migrations = await loadMigrations('./database/migrations');
+await runner.refresh(migrations);
+`));
+      break;
+    }
+    case "status": {
+      await showStatus();
+      break;
+    }
+  }
+}
+defineCommand({
+  name: "migration",
+  description: "Manage database migrations",
+  positionals: [
+    {
+      name: "action",
+      required: true,
+      description: "Action to perform (create, up, down, reset, refresh, status)"
+    },
+    {
+      name: "name",
+      required: false,
+      description: "Migration name (required for create action)"
+    }
+  ],
+  options: [
+    {
+      name: "steps",
+      alias: "n",
+      type: "number",
+      default: 1,
+      description: "Number of migrations to rollback"
+    },
+    {
+      name: "dry-run",
+      type: "boolean",
+      default: false,
+      description: "Show what would happen without executing"
+    }
+  ],
+  examples: [
+    "bueno migration create add-users-table",
+    "bueno migration up",
+    "bueno migration down --steps 3",
+    "bueno migration reset",
+    "bueno migration refresh",
+    "bueno migration status"
+  ]
+}, handleMigration);
+
+// src/cli/commands/dev.ts
+async function findEntryPoint(projectRoot) {
+  const possibleEntries = [
+    "server/main.ts",
+    "src/main.ts",
+    "src/index.ts",
+    "main.ts",
+    "index.ts",
+    "server.ts",
+    "app.ts"
+  ];
+  for (const entry of possibleEntries) {
+    const entryPath = joinPaths(projectRoot, entry);
+    if (await fileExists(entryPath)) {
+      return entry;
+    }
+  }
+  return null;
+}
+async function handleDev(args) {
+  const port = getOption(args, "port", {
+    name: "port",
+    alias: "p",
+    type: "number",
+    default: 3000,
+    description: ""
+  });
+  const host = getOption(args, "host", {
+    name: "host",
+    alias: "H",
+    type: "string",
+    default: "localhost",
+    description: ""
+  });
+  const hmr = !hasFlag(args, "no-hmr");
+  const watch = !hasFlag(args, "no-watch");
+  const openBrowser = hasFlag(args, "open") || hasFlag(args, "o");
+  const configPath = getOption(args, "config", {
+    name: "config",
+    alias: "c",
+    type: "string",
+    description: ""
+  });
+  const projectRoot = await getProjectRoot();
+  if (!projectRoot) {
+    throw new CLIError("Not in a project directory. Run this command from a Bueno project.", "NOT_FOUND" /* NOT_FOUND */);
+  }
+  if (!await isBuenoProject()) {
+    throw new CLIError("Not a Bueno project. Make sure you have a bueno.config.ts or bueno in your dependencies.", "NOT_FOUND" /* NOT_FOUND */);
+  }
+  const entryPoint = await findEntryPoint(projectRoot);
+  if (!entryPoint) {
+    throw new CLIError("Could not find entry point. Make sure you have a main.ts or index.ts file.", "FILE_NOT_FOUND" /* FILE_NOT_FOUND */);
+  }
+  const bunArgs = [];
+  if (watch) {
+    bunArgs.push("--watch");
+  }
+  if (hmr) {
+    cliConsole.debug("HMR enabled");
+  }
+  bunArgs.push(entryPoint);
+  const env = {
+    NODE_ENV: "development",
+    PORT: String(port),
+    HOST: host
+  };
+  if (configPath) {
+    env.BUENO_CONFIG = configPath;
+  }
+  cliConsole.header("Starting Development Server");
+  cliConsole.log(`${colors.bold("Entry:")} ${entryPoint}`);
+  cliConsole.log(`${colors.bold("Port:")} ${port}`);
+  cliConsole.log(`${colors.bold("Host:")} ${host}`);
+  cliConsole.log(`${colors.bold("Watch:")} ${watch ? colors.green("enabled") : colors.red("disabled")}`);
+  cliConsole.log(`${colors.bold("HMR:")} ${hmr ? colors.green("enabled") : colors.red("disabled")}`);
+  cliConsole.log("");
+  const s = spinner("Starting development server...");
+  try {
+    const proc = Bun.spawn(["bun", "run", ...bunArgs], {
+      cwd: projectRoot,
+      env: { ...process.env, ...env },
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+    s.success(`Development server running at ${colors.cyan(`http://${host}:${port}`)}`);
+    if (openBrowser) {
+      const openCommand = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+      Bun.spawn([openCommand, `http://${host}:${port}`], {
+        cwd: projectRoot
+      });
+    }
+    const exitCode = await proc.exited;
+    if (exitCode !== 0 && exitCode !== null) {
+      cliConsole.error(`Server exited with code ${exitCode}`);
+      process.exit(exitCode);
+    }
+  } catch (error) {
+    s.error();
+    throw error;
+  }
+}
+defineCommand({
+  name: "dev",
+  description: "Start the development server with hot reload",
+  options: [
+    {
+      name: "port",
+      alias: "p",
+      type: "number",
+      default: 3000,
+      description: "Server port"
+    },
+    {
+      name: "host",
+      alias: "H",
+      type: "string",
+      default: "localhost",
+      description: "Server hostname"
+    },
+    {
+      name: "no-hmr",
+      type: "boolean",
+      default: false,
+      description: "Disable hot module replacement"
+    },
+    {
+      name: "no-watch",
+      type: "boolean",
+      default: false,
+      description: "Disable file watching"
+    },
+    {
+      name: "open",
+      alias: "o",
+      type: "boolean",
+      default: false,
+      description: "Open browser on start"
+    },
+    {
+      name: "config",
+      alias: "c",
+      type: "string",
+      description: "Path to config file"
+    }
+  ],
+  examples: [
+    "bueno dev",
+    "bueno dev --port 4000",
+    "bueno dev --host 0.0.0.0",
+    "bueno dev --no-hmr",
+    "bueno dev --open"
+  ]
+}, handleDev);
+
+// src/cli/commands/build.ts
+async function findEntryPoint2(projectRoot) {
+  const possibleEntries = [
+    "server/main.ts",
+    "src/main.ts",
+    "src/index.ts",
+    "main.ts",
+    "index.ts",
+    "server.ts",
+    "app.ts"
+  ];
+  for (const entry of possibleEntries) {
+    const entryPath = joinPaths(projectRoot, entry);
+    if (await fileExists(entryPath)) {
+      return entry;
+    }
+  }
+  return null;
+}
+async function handleBuild(args) {
+  const target = getOption(args, "target", {
+    name: "target",
+    alias: "t",
+    type: "string",
+    default: "bun",
+    description: ""
+  });
+  const outDir = getOption(args, "outdir", {
+    name: "outdir",
+    alias: "o",
+    type: "string",
+    default: "./dist",
+    description: ""
+  });
+  const minify = !hasFlag(args, "no-minify");
+  const sourcemap = hasFlag(args, "sourcemap");
+  const analyze = hasFlag(args, "analyze");
+  const configPath = getOption(args, "config", {
+    name: "config",
+    alias: "c",
+    type: "string",
+    description: ""
+  });
+  const compile = hasFlag(args, "compile");
+  const crossCompile = getOption(args, "cross-compile", {
+    name: "cross-compile",
+    type: "string",
+    description: ""
+  });
+  const executableName = getOption(args, "executable-name", {
+    name: "executable-name",
+    type: "string",
+    default: "main",
+    description: ""
+  });
+  if (crossCompile) {
+    const validCrossCompileTargets = [
+      "linux-x64",
+      "linux-arm64",
+      "windows-x64",
+      "darwin-x64",
+      "darwin-arm64"
+    ];
+    if (!validCrossCompileTargets.includes(crossCompile)) {
+      throw new CLIError(`Invalid cross-compile target: ${crossCompile}. Valid targets: ${validCrossCompileTargets.join(", ")}`, "INVALID_ARGS" /* INVALID_ARGS */);
+    }
+  }
+  if (crossCompile && !compile) {
+    throw new CLIError("--cross-compile requires --compile flag", "INVALID_ARGS" /* INVALID_ARGS */);
+  }
+  const validTargets = ["bun", "node", "standalone"];
+  if (!validTargets.includes(target)) {
+    throw new CLIError(`Invalid target: ${target}. Valid targets: ${validTargets.join(", ")}`, "INVALID_ARGS" /* INVALID_ARGS */);
+  }
+  const projectRoot = await getProjectRoot();
+  if (!projectRoot) {
+    throw new CLIError("Not in a project directory. Run this command from a Bueno project.", "NOT_FOUND" /* NOT_FOUND */);
+  }
+  if (!await isBuenoProject()) {
+    throw new CLIError("Not a Bueno project. Make sure you have a bueno.config.ts or bueno in your dependencies.", "NOT_FOUND" /* NOT_FOUND */);
+  }
+  const entryPoint = await findEntryPoint2(projectRoot);
+  if (!entryPoint) {
+    throw new CLIError("Could not find entry point. Make sure you have a main.ts or index.ts file.", "FILE_NOT_FOUND" /* FILE_NOT_FOUND */);
+  }
+  if (compile) {
+    cliConsole.header("Compiling Single-File Executable");
+  } else {
+    cliConsole.header("Building for Production");
+  }
+  cliConsole.log(`${colors.bold("Entry:")} ${entryPoint}`);
+  cliConsole.log(`${colors.bold("Target:")} ${target}`);
+  if (compile) {
+    cliConsole.log(`${colors.bold("Compile:")} ${colors.green("enabled")}`);
+    if (crossCompile) {
+      cliConsole.log(`${colors.bold("Cross-compile:")} ${colors.cyan(crossCompile)}`);
+    }
+    cliConsole.log(`${colors.bold("Executable:")} ${executableName}`);
+  }
+  cliConsole.log(`${colors.bold("Output:")} ${outDir}`);
+  cliConsole.log(`${colors.bold("Minify:")} ${minify ? colors.green("enabled") : colors.red("disabled")}`);
+  cliConsole.log(`${colors.bold("Sourcemap:")} ${sourcemap ? colors.green("enabled") : colors.red("disabled")}`);
+  cliConsole.log("");
+  const startTime = Date.now();
+  const s = spinner("Building...");
+  try {
+    const fullOutDir = joinPaths(projectRoot, outDir);
+    if (await fileExists(fullOutDir)) {
+      await deleteDirectory(fullOutDir);
+    }
+    if (compile) {
+      const isWindows = crossCompile === "windows-x64";
+      const executableFileName = isWindows ? `${executableName}.exe` : executableName;
+      const executablePath = joinPaths(fullOutDir, executableFileName);
+      const buildOptions = {
+        entrypoints: [joinPaths(projectRoot, entryPoint)],
+        outdir: fullOutDir,
+        target: crossCompile || "bun",
+        minify,
+        sourcemap: sourcemap ? "external" : undefined,
+        naming: executableFileName,
+        compile: true,
+        define: {
+          "process.env.NODE_ENV": '"production"'
+        }
+      };
+      const buildResult2 = await Bun.build(buildOptions);
+      if (!buildResult2.success) {
+        s.error();
+        for (const error of buildResult2.logs) {
+          cliConsole.error(error.message);
+        }
+        throw new CLIError("Compile failed", "TEMPLATE_ERROR" /* TEMPLATE_ERROR */);
+      }
+      const elapsed2 = Date.now() - startTime;
+      s.success(`Compile completed in ${formatDuration(elapsed2)}`);
+      cliConsole.log("");
+      cliConsole.log(`${colors.bold("Output Executable:")}`);
+      const fs2 = __require("fs");
+      let executableSize = 0;
+      try {
+        const stat = fs2.statSync(executablePath);
+        executableSize = stat.size;
+      } catch (e) {
+        if (buildResult2.outputs.length > 0) {
+          executableSize = buildResult2.outputs[0].size;
+        }
+      }
+      cliConsole.log(`  ${colors.cyan(executablePath.replace(projectRoot, "."))} ${colors.dim(`(${formatSize(executableSize)})`)}`);
+      cliConsole.log("");
+      cliConsole.success("Single-file executable created successfully!");
+      if (crossCompile) {
+        cliConsole.log(`${colors.bold("Target Platform:")} ${crossCompile}`);
+      }
+      cliConsole.log("");
+      cliConsole.info("You can run the executable directly:");
+      if (isWindows) {
+        cliConsole.log(colors.cyan(`  .${outDir}/${executableFileName}`));
+      } else {
+        cliConsole.log(colors.cyan(`  .${outDir}/${executableFileName}`));
+      }
+      if (analyze) {
+        cliConsole.log("");
+        cliConsole.header("Bundle Analysis");
+        cliConsole.log("Output:");
+        for (const entry of buildResult2.outputs) {
+          cliConsole.log(`  ${entry.path} (${formatSize(entry.size)})`);
+        }
+      }
+      return;
+    }
+    const buildResult = await Bun.build({
+      entrypoints: [joinPaths(projectRoot, entryPoint)],
+      outdir: fullOutDir,
+      target: target === "node" ? "node" : "bun",
+      minify,
+      sourcemap: sourcemap ? "external" : undefined,
+      splitting: true,
+      format: "esm",
+      external: target === "standalone" ? [] : ["bun:*"],
+      define: {
+        "process.env.NODE_ENV": '"production"'
+      }
+    });
+    if (!buildResult.success) {
+      s.error();
+      for (const error of buildResult.logs) {
+        cliConsole.error(error.message);
+      }
+      throw new CLIError("Build failed", "TEMPLATE_ERROR" /* TEMPLATE_ERROR */);
+    }
+    const elapsed = Date.now() - startTime;
+    const outputFiles = await listFiles(fullOutDir, { recursive: true });
+    const totalSize = outputFiles.reduce((acc, file) => {
+      const stat = __require("fs").statSync(file);
+      return acc + stat.size;
+    }, 0);
+    s.success(`Build completed in ${formatDuration(elapsed)}`);
+    cliConsole.log("");
+    cliConsole.log(`${colors.bold("Output Files:")}`);
+    for (const file of outputFiles.slice(0, 10)) {
+      const stat = __require("fs").statSync(file);
+      const relativePath = file.replace(projectRoot, ".");
+      cliConsole.log(`  ${colors.dim(relativePath)} ${colors.dim(`(${formatSize(stat.size)})`)}`);
+    }
+    if (outputFiles.length > 10) {
+      cliConsole.log(`  ${colors.dim(`... and ${outputFiles.length - 10} more files`)}`);
+    }
+    cliConsole.log("");
+    cliConsole.log(`${colors.bold("Total Size:")} ${formatSize(totalSize)}`);
+    if (analyze) {
+      cliConsole.log("");
+      cliConsole.header("Bundle Analysis");
+      cliConsole.log("Entry points:");
+      for (const entry of buildResult.outputs) {
+        cliConsole.log(`  ${entry.path} (${formatSize(entry.size)})`);
+      }
+    }
+    if (target === "standalone") {
+      cliConsole.log("");
+      cliConsole.info("Standalone bundle created. You can run it with:");
+      cliConsole.log(colors.cyan(`  bun .${outDir}/${entryPoint.replace(".ts", ".js")}`));
+    }
+  } catch (error) {
+    s.error();
+    throw error;
+  }
+}
+defineCommand({
+  name: "build",
+  description: "Build the application for production",
+  options: [
+    {
+      name: "target",
+      alias: "t",
+      type: "string",
+      default: "bun",
+      description: "Build target (bun, node, standalone)"
+    },
+    {
+      name: "outdir",
+      alias: "o",
+      type: "string",
+      default: "./dist",
+      description: "Output directory"
+    },
+    {
+      name: "no-minify",
+      type: "boolean",
+      default: false,
+      description: "Disable minification"
+    },
+    {
+      name: "sourcemap",
+      type: "boolean",
+      default: false,
+      description: "Generate source maps"
+    },
+    {
+      name: "analyze",
+      type: "boolean",
+      default: false,
+      description: "Analyze bundle size"
+    },
+    {
+      name: "config",
+      alias: "c",
+      type: "string",
+      description: "Path to config file"
+    },
+    {
+      name: "compile",
+      type: "boolean",
+      default: false,
+      description: "Create a single-file executable using Bun compile"
+    },
+    {
+      name: "cross-compile",
+      type: "string",
+      description: "Cross-compile for different platforms (linux-x64, linux-arm64, windows-x64, darwin-x64, darwin-arm64)"
+    },
+    {
+      name: "executable-name",
+      type: "string",
+      default: "main",
+      description: "Custom name for the output executable (default: main)"
+    }
+  ],
+  examples: [
+    "bueno build",
+    "bueno build --target node",
+    "bueno build --target standalone",
+    "bueno build --sourcemap",
+    "bueno build --analyze",
+    "bueno build --compile",
+    "bueno build --compile --outdir ./bin",
+    "bueno build --compile --cross-compile linux-x64",
+    "bueno build --compile --executable-name myapp"
+  ]
+}, handleBuild);
+
+// src/cli/commands/start.ts
+async function findEntryPoint3(projectRoot) {
+  const possibleBuiltEntries = [
+    "dist/index.js",
+    "dist/main.js",
+    "dist/server.js",
+    "dist/app.js"
+  ];
+  for (const entry of possibleBuiltEntries) {
+    const entryPath = joinPaths(projectRoot, entry);
+    if (await fileExists(entryPath)) {
+      return entry;
+    }
+  }
+  const possibleSourceEntries = [
+    "server/main.ts",
+    "src/main.ts",
+    "src/index.ts",
+    "main.ts",
+    "index.ts",
+    "server.ts",
+    "app.ts"
+  ];
+  for (const entry of possibleSourceEntries) {
+    const entryPath = joinPaths(projectRoot, entry);
+    if (await fileExists(entryPath)) {
+      return entry;
+    }
+  }
+  return null;
+}
+async function handleStart(args) {
+  const port = getOption(args, "port", {
+    name: "port",
+    alias: "p",
+    type: "number",
+    default: 3000,
+    description: ""
+  });
+  const host = getOption(args, "host", {
+    name: "host",
+    alias: "H",
+    type: "string",
+    default: "0.0.0.0",
+    description: ""
+  });
+  const workers = getOption(args, "workers", {
+    name: "workers",
+    alias: "w",
+    type: "string",
+    default: "auto",
+    description: ""
+  });
+  const configPath = getOption(args, "config", {
+    name: "config",
+    alias: "c",
+    type: "string",
+    description: ""
+  });
+  const projectRoot = await getProjectRoot();
+  if (!projectRoot) {
+    throw new CLIError("Not in a project directory. Run this command from a Bueno project.", "NOT_FOUND" /* NOT_FOUND */);
+  }
+  if (!await isBuenoProject()) {
+    throw new CLIError("Not a Bueno project. Make sure you have a bueno.config.ts or bueno in your dependencies.", "NOT_FOUND" /* NOT_FOUND */);
+  }
+  const entryPoint = await findEntryPoint3(projectRoot);
+  if (!entryPoint) {
+    throw new CLIError("Could not find entry point. Make sure you have built the application or have a main.ts file.", "FILE_NOT_FOUND" /* FILE_NOT_FOUND */);
+  }
+  cliConsole.header("Starting Production Server");
+  cliConsole.log(`${colors.bold("Entry:")} ${entryPoint}`);
+  cliConsole.log(`${colors.bold("Port:")} ${port}`);
+  cliConsole.log(`${colors.bold("Host:")} ${host}`);
+  cliConsole.log(`${colors.bold("Workers:")} ${workers}`);
+  cliConsole.log("");
+  const env = {
+    NODE_ENV: "production",
+    PORT: String(port),
+    HOST: host
+  };
+  if (configPath) {
+    env.BUENO_CONFIG = configPath;
+  }
+  const s = spinner("Starting production server...");
+  try {
+    const proc = Bun.spawn(["bun", "run", entryPoint], {
+      cwd: projectRoot,
+      env: { ...process.env, ...env },
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+    s.success(`Production server running at ${colors.cyan(`http://${host}:${port}`)}`);
+    const exitCode = await proc.exited;
+    if (exitCode !== 0 && exitCode !== null) {
+      cliConsole.error(`Server exited with code ${exitCode}`);
+      process.exit(exitCode);
+    }
+  } catch (error) {
+    s.error();
+    throw error;
+  }
+}
+defineCommand({
+  name: "start",
+  description: "Start the production server",
+  options: [
+    {
+      name: "port",
+      alias: "p",
+      type: "number",
+      default: 3000,
+      description: "Server port"
+    },
+    {
+      name: "host",
+      alias: "H",
+      type: "string",
+      default: "0.0.0.0",
+      description: "Server hostname"
+    },
+    {
+      name: "workers",
+      alias: "w",
+      type: "string",
+      default: "auto",
+      description: "Number of worker threads"
+    },
+    {
+      name: "config",
+      alias: "c",
+      type: "string",
+      description: "Path to config file"
+    }
+  ],
+  examples: [
+    "bueno start",
+    "bueno start --port 8080",
+    "bueno start --host 0.0.0.0",
+    "bueno start --workers 4"
+  ]
+}, handleStart);
+
+// src/cli/commands/help.ts
+defineCommand({
+  name: "help",
+  description: "Show help information for commands",
+  positionals: [
+    {
+      name: "command",
+      required: false,
+      description: "Command to show help for"
+    }
+  ],
+  options: [
+    {
+      name: "all",
+      alias: "a",
+      type: "boolean",
+      default: false,
+      description: "Show help for all commands"
+    }
+  ]
+}, async (args) => {
+  const commandName = args.positionals[0];
+  if (commandName && registry.has(commandName)) {
+    const cmd = registry.get(commandName);
+    if (cmd) {
+      cliConsole.log(generateHelpText(cmd.definition));
+    }
+  } else if (hasFlag(args, "all")) {
+    cliConsole.log(`
+Bueno CLI - Available Commands
+`);
+    for (const cmd of registry.getAll()) {
+      cliConsole.log(generateHelpText(cmd));
+      cliConsole.log("---");
+    }
+  } else {
+    cliConsole.log(generateGlobalHelpText(registry.getAll()));
+  }
+});
+// src/cli/index.ts
+var VERSION = "0.1.0";
+class CLIError extends Error {
+  type;
+  exitCode;
+  constructor(message, type, exitCode = 1) {
+    super(message);
+    this.type = type;
+    this.exitCode = exitCode;
+    this.name = "CLIError";
+  }
+}
+async function run(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv);
+  if (hasFlag(args, "no-color")) {
+    setColorEnabled(false);
+  }
+  if (hasFlag(args, "verbose")) {
+    process.env.BUENO_VERBOSE = "true";
+  }
+  if (hasFlag(args, "quiet")) {
+    process.env.BUENO_QUIET = "true";
+  }
+  if (hasFlag(args, "version") || hasFlag(args, "v")) {
+    cliConsole.log(`bueno v${VERSION}`);
+    process.exit(0);
+  }
+  if (!args.command || hasFlag(args, "help") || hasFlag(args, "h")) {
+    if (args.command && registry.has(args.command)) {
+      const cmd = registry.get(args.command);
+      if (cmd) {
+        cliConsole.log(generateHelpText(cmd.definition));
+      }
+    } else {
+      cliConsole.log(generateGlobalHelpText(registry.getAll()));
+    }
+    process.exit(0);
+  }
+  try {
+    await registry.execute(args.command, args);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      cliConsole.error(error.message);
+      process.exit(error.exitCode);
+    }
+    if (error instanceof Error) {
+      if (process.env.BUENO_VERBOSE === "true") {
+        cliConsole.error(error.stack ?? error.message);
+      } else {
+        cliConsole.error(error.message);
+      }
+    }
+    process.exit(1);
+  }
+}
+async function main() {
+  process.on("SIGINT", () => {
+    cliConsole.newline();
+    process.exit(130);
+  });
+  process.on("unhandledRejection", (reason) => {
+    cliConsole.error("Unhandled rejection:", reason);
+    process.exit(1);
+  });
+  await run();
+}
+
+// src/cli/bin.ts
+main();