@stacksjs/bun-router 0.0.14 → 0.0.15

package/dist/cli.js

@@ -0,0 +1,3360 @@
+// @bun
+import {
+  middleware
+} from "./chunk-j0e7z7hd.js";
+
+// src/cli/index.ts
+import process15 from "process";
+
+// ../../node_modules/@stacksjs/clapp/dist/index.js
+import { existsSync } from "fs";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+import process from "process";
+import { EventEmitter } from "events";
+import process5 from "process";
+import process2 from "process";
+import process3 from "process";
+import process4 from "process";
+import process7 from "process";
+import tty from "tty";
+import process8, { stdin, stdout } from "process";
+import process9, { stdin as stdin2, stdout as stdout2 } from "process";
+import readline2 from "readline";
+class Telemetry {
+  configPath;
+  config = null;
+  events = [];
+  retryCount = 0;
+  maxRetries = 3;
+  retryDelayMs = 1000;
+  constructor() {
+    const homeDir = os.homedir();
+    const configDir = path.join(homeDir, ".config", "clapp");
+    this.configPath = path.join(configDir, "telemetry.json");
+  }
+  async isEnabled() {
+    if (process.env.DO_NOT_TRACK === "1" || process.env.DO_NOT_TRACK === "true") {
+      return false;
+    }
+    if (process.env.NO_TELEMETRY === "1" || process.env.NO_TELEMETRY === "true") {
+      return false;
+    }
+    const config = await this.loadConfig();
+    return config.enabled;
+  }
+  async enable() {
+    const config = await this.loadConfig();
+    config.enabled = true;
+    if (!config.userId) {
+      config.userId = this.generateUserId();
+    }
+    await this.saveConfig(config);
+  }
+  async disable() {
+    const config = await this.loadConfig();
+    config.enabled = false;
+    await this.saveConfig(config);
+  }
+  async track(event, data) {
+    const enabled = await this.isEnabled();
+    if (!enabled) {
+      return;
+    }
+    const telemetryEvent = {
+      event,
+      ...data,
+      timestamp: Date.now(),
+      platform: os.platform(),
+      nodeVersion: process.version
+    };
+    this.events.push(telemetryEvent);
+    if (this.events.length >= 10) {
+      await this.send();
+    }
+  }
+  async trackCommand(command, duration) {
+    await this.track("command", {
+      command,
+      duration
+    });
+  }
+  async trackError(error, command) {
+    await this.track("error", {
+      error,
+      command
+    });
+  }
+  async send() {
+    const enabled = await this.isEnabled();
+    if (!enabled || this.events.length === 0) {
+      return true;
+    }
+    try {
+      this.events = [];
+      this.retryCount = 0;
+      const config = await this.loadConfig();
+      config.lastSent = Date.now();
+      await this.saveConfig(config);
+      return true;
+    } catch {
+      if (this.retryCount < this.maxRetries) {
+        this.retryCount++;
+        const delay = this.retryDelayMs * 2 ** (this.retryCount - 1);
+        await this.sleep(delay);
+        return this.send();
+      }
+      this.events = [];
+      this.retryCount = 0;
+      return false;
+    }
+  }
+  async flush() {
+    if (this.events.length === 0) {
+      return true;
+    }
+    return this.send();
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async status() {
+    const config = await this.loadConfig();
+    return {
+      enabled: config.enabled,
+      doNotTrack: process.env.DO_NOT_TRACK === "1" || process.env.DO_NOT_TRACK === "true",
+      eventsQueued: this.events.length,
+      lastSent: config.lastSent
+    };
+  }
+  async loadConfig() {
+    if (this.config) {
+      return this.config;
+    }
+    try {
+      if (existsSync(this.configPath)) {
+        const data = await fs.readFile(this.configPath, "utf-8");
+        this.config = JSON.parse(data);
+        return this.config;
+      }
+    } catch {}
+    this.config = {
+      enabled: false
+    };
+    return this.config;
+  }
+  async saveConfig(config) {
+    this.config = config;
+    try {
+      const configDir = path.dirname(this.configPath);
+      await fs.mkdir(configDir, { recursive: true });
+      await fs.writeFile(this.configPath, JSON.stringify(config, null, 2), "utf-8");
+    } catch {}
+  }
+  generateUserId() {
+    const random = Math.random().toString(36).substring(2, 15);
+    const timestamp = Date.now().toString(36);
+    return `${random}-${timestamp}`;
+  }
+}
+var telemetry = new Telemetry;
+function parseArgv(argv, opts = {}) {
+  const result = { _: [] };
+  const alias = opts.alias || {};
+  const booleans = new Set(opts.boolean || []);
+  const aliasOf = {};
+  for (const key of Object.keys(alias)) {
+    for (const a of alias[key]) {
+      aliasOf[a] = key;
+    }
+  }
+  for (const b of booleans) {
+    if (alias[b]) {
+      for (const a of alias[b])
+        booleans.add(a);
+    }
+  }
+  function setKey(key, value) {
+    const canonical = aliasOf[key] || key;
+    result[canonical] = value;
+    if (alias[canonical]) {
+      for (const a of alias[canonical])
+        result[a] = value;
+    }
+    if (aliasOf[key] && alias[aliasOf[key]]) {
+      for (const a of alias[aliasOf[key]])
+        result[a] = value;
+    }
+    result[key] = value;
+  }
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--") {
+      result._.push(...argv.slice(i + 1));
+      break;
+    }
+    if (arg.startsWith("--")) {
+      const eqIdx = arg.indexOf("=");
+      if (eqIdx !== -1) {
+        const key = arg.slice(2, eqIdx);
+        const value = arg.slice(eqIdx + 1);
+        setKey(key, value);
+      } else {
+        const key = arg.slice(2);
+        if (key.startsWith("no-")) {
+          const actualKey = key.slice(3);
+          setKey(actualKey, false);
+          continue;
+        }
+        const canonical = aliasOf[key] || key;
+        if (booleans.has(canonical) || booleans.has(key)) {
+          setKey(key, true);
+        } else {
+          const next = argv[i + 1];
+          if (next !== undefined && !next.startsWith("-")) {
+            setKey(key, next);
+            i++;
+          } else {
+            setKey(key, true);
+          }
+        }
+      }
+    } else if (arg.startsWith("-") && arg.length > 1) {
+      const chars = arg.slice(1);
+      for (let j = 0;j < chars.length; j++) {
+        const ch = chars[j];
+        const canonical = aliasOf[ch] || ch;
+        if (j === chars.length - 1 && !booleans.has(canonical) && !booleans.has(ch)) {
+          const next = argv[i + 1];
+          if (next !== undefined && !next.startsWith("-")) {
+            setKey(ch, next);
+            i++;
+          } else {
+            setKey(ch, true);
+          }
+        } else {
+          setKey(ch, true);
+        }
+      }
+    } else {
+      result._.push(arg);
+    }
+  }
+  return result;
+}
+function removeBrackets(v) {
+  return v.replace(/[<[].+/, "").trim();
+}
+function findAllBrackets(v) {
+  const ANGLED_BRACKET_RE_GLOBAL = /<([^>]+)>/g;
+  const SQUARE_BRACKET_RE_GLOBAL = /\[([^\]]+)\]/g;
+  const res = [];
+  const parse = (match) => {
+    let variadic = false;
+    let value = match[1];
+    if (value.startsWith("...")) {
+      value = value.slice(3);
+      variadic = true;
+    }
+    return {
+      required: match[0].startsWith("<"),
+      value,
+      variadic
+    };
+  };
+  let angledMatch;
+  while (angledMatch = ANGLED_BRACKET_RE_GLOBAL.exec(v)) {
+    res.push(parse(angledMatch));
+  }
+  let squareMatch;
+  while (squareMatch = SQUARE_BRACKET_RE_GLOBAL.exec(v)) {
+    res.push(parse(squareMatch));
+  }
+  return res;
+}
+function getMriOptions(options) {
+  const result = { alias: {}, boolean: [] };
+  for (const [index, option] of options.entries()) {
+    if (option.names.length > 1) {
+      result.alias[option.names[0]] = option.names.slice(1);
+    }
+    if (option.isBoolean) {
+      if (option.negated) {
+        const hasStringTypeOption = options.some((o, i) => {
+          return i !== index && o.names.some((name) => option.names.includes(name)) && typeof o.required === "boolean";
+        });
+        if (!hasStringTypeOption) {
+          result.boolean.push(option.names[0]);
+        }
+      } else {
+        result.boolean.push(option.names[0]);
+      }
+    }
+  }
+  return result;
+}
+function findLongest(arr) {
+  return arr.reduce((a, b) => a.length >= b.length ? a : b, "");
+}
+function padRight(str, length) {
+  return str.length >= length ? str : `${str}${" ".repeat(length - str.length)}`;
+}
+function camelcase(input) {
+  return input.replace(/([a-z])-([a-z])/g, (_, p1, p2) => {
+    return p1 + p2.toUpperCase();
+  });
+}
+function setDotProp(obj, keys, val) {
+  let i = 0;
+  const length = keys.length;
+  let t = obj;
+  let x;
+  for (;i < length; ++i) {
+    x = t[keys[i]];
+    t = t[keys[i]] = i === length - 1 ? val : x != null ? x : !!~keys[i + 1].indexOf(".") || !(+keys[i + 1] > -1) ? {} : [];
+  }
+}
+function setByType(obj, transforms) {
+  for (const key of Object.keys(transforms)) {
+    const transform = transforms[key];
+    if (transform.shouldTransform) {
+      obj[key] = Array.prototype.concat.call([], obj[key]);
+      if (typeof transform.transformFunction === "function") {
+        obj[key] = obj[key].map(transform.transformFunction);
+      }
+    }
+  }
+}
+function getFileName(input) {
+  const m = /([^\\/]+)$/.exec(input);
+  return m ? m[1] : "";
+}
+function camelcaseOptionName(name) {
+  return name.split(".").map((v, i) => {
+    return i === 0 ? camelcase(v) : v;
+  }).join(".");
+}
+
+class ClappError extends Error {
+  exitCode = 2;
+  isUsageError = true;
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, this.constructor);
+    } else {
+      this.stack = new Error(message).stack;
+    }
+  }
+  format(showStack = false) {
+    if (showStack && this.stack) {
+      return `${this.message}
+
+Stack trace:
+${this.stack}`;
+    }
+    return this.message;
+  }
+}
+function isUnicodeSupported() {
+  const { env } = process2;
+  const { TERM, TERM_PROGRAM } = env;
+  if (process2.platform !== "win32") {
+    return TERM !== "linux";
+  }
+  return Boolean(env.WT_SESSION) || Boolean(env.TERMINUS_SUBLIME) || env.ConEmuTask === "{cmd::Cmder}" || TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+var ESC = "\x1B";
+var CSI = `${ESC}[`;
+var cursor = {
+  to(x, y) {
+    if (!y)
+      return `${CSI}${x + 1}G`;
+    return `${CSI}${y + 1};${x + 1}H`;
+  },
+  move(x, y) {
+    let ret = "";
+    if (x < 0)
+      ret += `${CSI}${-x}D`;
+    else if (x > 0)
+      ret += `${CSI}${x}C`;
+    if (y < 0)
+      ret += `${CSI}${-y}A`;
+    else if (y > 0)
+      ret += `${CSI}${y}B`;
+    return ret;
+  },
+  up: (count = 1) => `${CSI}${count}A`,
+  down: (count = 1) => `${CSI}${count}B`,
+  forward: (count = 1) => `${CSI}${count}C`,
+  backward: (count = 1) => `${CSI}${count}D`,
+  nextLine: (count = 1) => `${CSI}E`.repeat(count),
+  prevLine: (count = 1) => `${CSI}F`.repeat(count),
+  left: `${CSI}G`,
+  hide: `${CSI}?25l`,
+  show: `${CSI}?25h`,
+  save: `${ESC}7`,
+  restore: `${ESC}8`
+};
+var erase = {
+  screen: `${CSI}2J`,
+  up: (count = 1) => `${CSI}1J`.repeat(count),
+  down: (count = 1) => `${CSI}J`.repeat(count),
+  line: `${CSI}2K`,
+  lineEnd: `${CSI}K`,
+  lineStart: `${CSI}1K`,
+  lines(count) {
+    let clear = "";
+    for (let i = 0;i < count; i++)
+      clear += this.line + (i < count - 1 ? cursor.up() : "");
+    if (count)
+      clear += cursor.left;
+    return clear;
+  }
+};
+var clear = {
+  screen: `${ESC}c`
+};
+function levenshteinDistance(a, b) {
+  const matrix = [];
+  for (let i = 0;i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0;j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1;i <= b.length; i++) {
+    for (let j = 1;j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+function findSimilarCommands(input, commands, maxDistance = 2, maxSuggestions = 3) {
+  return commands.map((cmd) => ({ cmd, distance: levenshteinDistance(input, cmd) })).filter(({ distance }) => distance <= maxDistance).sort((a, b) => a.distance - b.distance).slice(0, maxSuggestions).map(({ cmd }) => cmd);
+}
+
+class Option {
+  rawName;
+  description;
+  name;
+  names;
+  isBoolean;
+  required;
+  config;
+  negated;
+  constructor(rawName, description, config) {
+    this.rawName = rawName;
+    this.description = description;
+    this.config = Object.assign({}, config);
+    rawName = rawName.replace(/\.\*/g, "");
+    this.negated = false;
+    this.names = removeBrackets(rawName).split(",").map((v) => {
+      let name = v.trim().replace(/^-{1,2}/, "");
+      if (name.startsWith("no-")) {
+        this.negated = true;
+        name = name.replace(/^no-/, "");
+      }
+      return camelcaseOptionName(name);
+    }).sort((a, b) => a.length > b.length ? 1 : -1);
+    this.name = this.names[this.names.length - 1];
+    if (this.negated && this.config.default == null) {
+      this.config.default = true;
+    }
+    if (rawName.includes("<")) {
+      this.required = true;
+    } else if (rawName.includes("[")) {
+      this.required = false;
+    } else {
+      this.isBoolean = true;
+    }
+  }
+}
+var processArgs = process3.argv;
+var platformInfo = `${process3.platform}-${process3.arch} bun-v${typeof Bun !== "undefined" ? Bun.version : "unknown"}`;
+var processArgs2 = process4.argv;
+var platformInfo2 = `${process4.platform}-${process4.arch} node-${process4.version}`;
+
+class Command {
+  rawName;
+  description;
+  config;
+  cli;
+  options;
+  aliasNames;
+  name;
+  namespace;
+  args;
+  commandAction;
+  usageText;
+  versionNumber;
+  examples;
+  helpCallback;
+  globalCommand;
+  beforeHooks;
+  afterHooks;
+  middleware;
+  constructor(rawName, description, config, cli) {
+    this.rawName = rawName;
+    this.description = description;
+    this.config = config;
+    this.cli = cli;
+    this.options = [];
+    this.aliasNames = [];
+    this.name = removeBrackets(rawName);
+    const nameWithoutBrackets = removeBrackets(rawName);
+    const colonIndex = nameWithoutBrackets.indexOf(":");
+    if (colonIndex > 0) {
+      this.namespace = nameWithoutBrackets.substring(0, colonIndex);
+      this.name = nameWithoutBrackets.substring(colonIndex + 1);
+    }
+    this.args = findAllBrackets(rawName);
+    this.examples = [];
+    this.beforeHooks = [];
+    this.afterHooks = [];
+    this.middleware = [];
+    if (!config) {
+      this.config = {};
+    }
+  }
+  usage(text) {
+    this.usageText = text;
+    return this;
+  }
+  allowUnknownOptions() {
+    this.config.allowUnknownOptions = true;
+    return this;
+  }
+  ignoreOptionDefaultValue() {
+    this.config.ignoreOptionDefaultValue = true;
+    return this;
+  }
+  version(version, customFlags = "-v, --version") {
+    this.versionNumber = version;
+    this.option(customFlags, "Display version number");
+    return this;
+  }
+  example(example) {
+    this.examples.push(example);
+    return this;
+  }
+  option(rawName, description, config) {
+    const option = new Option(rawName, description, config);
+    this.options.push(option);
+    return this;
+  }
+  alias(name) {
+    this.aliasNames.push(name);
+    return this;
+  }
+  action(callback) {
+    this.commandAction = callback;
+    return this;
+  }
+  before(handler) {
+    this.beforeHooks.push(handler);
+    return this;
+  }
+  after(handler) {
+    this.afterHooks.push(handler);
+    return this;
+  }
+  use(handler) {
+    this.middleware.push(handler);
+    return this;
+  }
+  isMatched(name) {
+    if (this.aliasNames.includes(name))
+      return true;
+    if (this.name === name)
+      return true;
+    if (this.namespace && `${this.namespace}:${this.name}` === name)
+      return true;
+    return false;
+  }
+  get isDefaultCommand() {
+    return this.name === "" || this.aliasNames.includes("!");
+  }
+  get isGlobalCommand() {
+    return this instanceof GlobalCommand;
+  }
+  hasOption(name) {
+    name = name.split(".")[0];
+    return !!this.options.find((option) => {
+      return option.names.includes(name);
+    });
+  }
+  outputHelp() {
+    const { name, commands } = this.cli;
+    const {
+      versionNumber,
+      options: globalOptions,
+      helpCallback
+    } = this.cli.globalCommand;
+    let sections = [
+      {
+        body: `${name}${versionNumber ? `/${versionNumber}` : ""}`
+      }
+    ];
+    sections.push({
+      title: "Usage",
+      body: `  $ ${name} ${this.usageText || this.rawName}`
+    });
+    const showCommands = (this.isGlobalCommand || this.isDefaultCommand) && commands.length > 0;
+    if (showCommands) {
+      const longestCommandName = findLongest(commands.map((command) => command.rawName));
+      const namespaceGroups = new Map;
+      const noNamespaceCommands = [];
+      for (const command of commands) {
+        if (command.namespace) {
+          if (!namespaceGroups.has(command.namespace)) {
+            namespaceGroups.set(command.namespace, []);
+          }
+          namespaceGroups.get(command.namespace).push(command);
+        } else {
+          noNamespaceCommands.push(command);
+        }
+      }
+      let commandBody = "";
+      if (noNamespaceCommands.length > 0) {
+        commandBody += noNamespaceCommands.map((command) => {
+          return `  ${padRight(command.rawName, longestCommandName.length)}  ${command.description}`;
+        }).join(`
+`);
+      }
+      const sortedNamespaces = Array.from(namespaceGroups.keys()).sort();
+      for (const namespace of sortedNamespaces) {
+        const namespaceCommands = namespaceGroups.get(namespace);
+        if (commandBody.length > 0) {
+          commandBody += `
+
+`;
+        }
+        commandBody += `  ${namespace}:
+`;
+        commandBody += namespaceCommands.map((command) => {
+          return `    ${padRight(command.rawName, longestCommandName.length - 2)}  ${command.description}`;
+        }).join(`
+`);
+      }
+      sections.push({
+        title: "Commands",
+        body: commandBody
+      });
+      sections.push({
+        title: `For more info, run any command with the \`--help\` flag`,
+        body: commands.map((command) => `  $ ${name}${command.name === "" ? "" : ` ${command.name}`} --help`).join(`
+`)
+      });
+    }
+    let options = this.isGlobalCommand ? globalOptions : [...this.options, ...globalOptions || []];
+    if (!this.isGlobalCommand && !this.isDefaultCommand) {
+      options = options.filter((option) => option.name !== "version");
+    }
+    if (options.length > 0) {
+      const longestOptionName = findLongest(options.map((option) => option.rawName));
+      sections.push({
+        title: "Options",
+        body: options.map((option) => {
+          return `  ${padRight(option.rawName, longestOptionName.length)}  ${option.description} ${option.config.default === undefined ? "" : `(default: ${option.config.default})`}`;
+        }).join(`
+`)
+      });
+    }
+    if (this.examples.length > 0) {
+      sections.push({
+        title: "Examples",
+        body: this.examples.map((example) => {
+          if (typeof example === "function") {
+            return example(name);
+          }
+          return example;
+        }).join(`
+`)
+      });
+    }
+    if (helpCallback) {
+      sections = helpCallback(sections) || sections;
+    }
+    console.log(sections.map((section) => {
+      return section.title ? `${section.title}:
+${section.body}` : section.body;
+    }).join(`
+
+`));
+  }
+  outputVersion() {
+    const { name } = this.cli;
+    const { versionNumber } = this.cli.globalCommand;
+    if (versionNumber) {
+      const platformInfo3 = typeof Bun !== "undefined" ? platformInfo : platformInfo2;
+      console.log(`${name}/${versionNumber} ${platformInfo3}`);
+    }
+  }
+  checkRequiredArgs() {
+    const minimalArgsCount = this.args.filter((arg) => arg.required).length;
+    if (this.cli.args.length < minimalArgsCount) {
+      const requiredArgs = this.args.filter((arg) => arg.required);
+      const missingArgs = requiredArgs.slice(this.cli.args.length);
+      const argNames = missingArgs.map((arg) => `<${arg.value}>`).join(" ");
+      throw new ClappError(`Missing required argument${missingArgs.length > 1 ? "s" : ""}: ${argNames}
+
+` + `Run \`${this.cli.name} ${this.rawName} --help\` for usage information.`);
+    }
+  }
+  checkUnknownOptions() {
+    const { options, globalCommand } = this.cli;
+    if (!this.config.allowUnknownOptions) {
+      for (const name of Object.keys(options)) {
+        if (name !== "--" && !this.hasOption(name) && !globalCommand.hasOption(name)) {
+          const allOptions = [...globalCommand.options, ...this.options];
+          const allOptionNames = allOptions.flatMap((opt) => opt.names);
+          const optionFlag = name.length > 1 ? `--${name}` : `-${name}`;
+          const suggestions = findSimilarCommands(name, allOptionNames);
+          let errorMsg = `Unknown option \`${optionFlag}\``;
+          if (suggestions.length > 0) {
+            errorMsg += `
+
+Did you mean one of these?`;
+            suggestions.forEach((suggestion) => {
+              const suggestedFlag = suggestion.length > 1 ? `--${suggestion}` : `-${suggestion}`;
+              errorMsg += `
+  \u2022 ${suggestedFlag}`;
+            });
+          }
+          errorMsg += `
+
+Run \`${this.cli.name} ${this.rawName} --help\` to see available options.`;
+          throw new ClappError(errorMsg);
+        }
+      }
+    }
+  }
+  checkOptionValue() {
+    const { options: parsedOptions, globalCommand } = this.cli;
+    const options = [...globalCommand.options, ...this.options];
+    for (const option of options) {
+      const value = parsedOptions[option.name.split(".")[0]];
+      if (option.required) {
+        const hasNegated = options.some((o) => o.negated && o.names.includes(option.name));
+        if (value === true || value === false && !hasNegated) {
+          throw new ClappError(`Option \`${option.rawName}\` requires a value.
+
+` + `Example: ${this.cli.name} ${this.rawName} ${option.rawName} <value>`);
+        }
+      }
+    }
+  }
+}
+
+class GlobalCommand extends Command {
+  constructor(cli) {
+    super("@@global@@", "", {}, cli);
+  }
+}
+var Command_default = Command;
+var codes = {
+  red: ["\x1B[31m", "\x1B[39m"],
+  green: ["\x1B[32m", "\x1B[39m"],
+  blue: ["\x1B[34m", "\x1B[39m"],
+  yellow: ["\x1B[33m", "\x1B[39m"],
+  cyan: ["\x1B[36m", "\x1B[39m"],
+  magenta: ["\x1B[35m", "\x1B[39m"],
+  white: ["\x1B[37m", "\x1B[39m"],
+  gray: ["\x1B[90m", "\x1B[39m"],
+  bgRed: ["\x1B[41m", "\x1B[49m"],
+  bgGreen: ["\x1B[42m", "\x1B[49m"],
+  bgBlue: ["\x1B[44m", "\x1B[49m"],
+  bgYellow: ["\x1B[43m", "\x1B[49m"],
+  bgCyan: ["\x1B[46m", "\x1B[49m"],
+  bgMagenta: ["\x1B[45m", "\x1B[49m"],
+  bold: ["\x1B[1m", "\x1B[22m"],
+  italic: ["\x1B[3m", "\x1B[23m"],
+  underline: ["\x1B[4m", "\x1B[24m"],
+  dim: ["\x1B[2m", "\x1B[22m"],
+  inverse: ["\x1B[7m", "\x1B[27m"],
+  hidden: ["\x1B[8m", "\x1B[28m"],
+  strikethrough: ["\x1B[9m", "\x1B[29m"]
+};
+var theme = {
+  primary: "blue",
+  secondary: "cyan",
+  success: "green",
+  warning: "yellow",
+  error: "red",
+  info: "magenta",
+  muted: "gray"
+};
+function detectColorSupport() {
+  return true;
+}
+function createStyler() {
+  const styler = {};
+  styler.supportsColor = detectColorSupport();
+  function createStyleFunction(styleName, styles = []) {
+    const styleList = styleName === "" ? [] : [...styles, styleName];
+    const fn = function(text) {
+      if (!styler.supportsColor)
+        return text;
+      let openCodes = "";
+      let closeCodes = "";
+      for (const style of styleList) {
+        if (style in theme && theme[style] in codes) {
+          const themeStyle = theme[style];
+          openCodes += codes[themeStyle][0];
+          closeCodes = codes[themeStyle][1] + closeCodes;
+        } else if (style in codes) {
+          openCodes += codes[style][0];
+          closeCodes = codes[style][1] + closeCodes;
+        }
+      }
+      return openCodes + text + closeCodes;
+    };
+    const allStyles2 = [...Object.keys(codes), ...Object.keys(theme)];
+    for (const style of allStyles2) {
+      if (!(style in fn)) {
+        Object.defineProperty(fn, style, {
+          get() {
+            return createStyleFunction(style, styleList);
+          }
+        });
+      }
+    }
+    return fn;
+  }
+  const allStyles = [...Object.keys(codes), ...Object.keys(theme)];
+  for (const style of allStyles) {
+    if (!(style in styler)) {
+      Object.defineProperty(styler, style, {
+        get() {
+          return createStyleFunction(style);
+        }
+      });
+    }
+  }
+  return styler;
+}
+var style = createStyler();
+class CLI extends EventEmitter {
+  name;
+  commands;
+  globalCommand;
+  matchedCommand;
+  matchedCommandName;
+  rawArgs;
+  args;
+  options;
+  showHelpOnExit;
+  showVersionOnExit;
+  enableDidYouMean = true;
+  signalHandlersSet = false;
+  isVerbose = false;
+  isQuiet = false;
+  isDebug = false;
+  isNoInteraction = false;
+  environment;
+  isDryRun = false;
+  isForce = false;
+  useEmoji = true;
+  theme;
+  isNoCache = false;
+  constructor(name = "") {
+    super();
+    this.name = name;
+    this.commands = [];
+    this.rawArgs = [];
+    this.args = [];
+    this.options = {};
+    this.globalCommand = new GlobalCommand(this);
+    this.globalCommand.usage("<command> [options]");
+  }
+  handleSignals(cleanup) {
+    if (this.signalHandlersSet) {
+      return this;
+    }
+    const handleSignal = async (signal) => {
+      console.log(`
+
+Received ${signal}, cleaning up...`);
+      if (cleanup) {
+        try {
+          await cleanup();
+        } catch (error) {
+          console.error("Error during cleanup:", error);
+        }
+      }
+      process5.exit(0);
+    };
+    process5.on("SIGINT", () => handleSignal("SIGINT"));
+    process5.on("SIGTERM", () => handleSignal("SIGTERM"));
+    this.signalHandlersSet = true;
+    return this;
+  }
+  didYouMean(enabled = true) {
+    this.enableDidYouMean = enabled;
+    return this;
+  }
+  verbose() {
+    this.globalCommand.option("-v, --verbose", "Enable verbose output");
+    return this;
+  }
+  quiet() {
+    this.globalCommand.option("-q, --quiet", "Suppress non-essential output");
+    return this;
+  }
+  debug() {
+    this.globalCommand.option("--debug", "Enable debug mode with detailed error information");
+    return this;
+  }
+  noInteraction() {
+    this.globalCommand.option("-n, --no-interaction", "Do not ask any interactive questions (for CI/CD)");
+    return this;
+  }
+  env() {
+    this.globalCommand.option("--env <environment>", "Target environment (e.g., production, staging, local)");
+    return this;
+  }
+  dryRun() {
+    this.globalCommand.option("--dry-run", "Preview actions without executing them");
+    return this;
+  }
+  force() {
+    this.globalCommand.option("-f, --force", "Skip confirmation prompts");
+    return this;
+  }
+  emoji() {
+    this.globalCommand.option("--no-emoji", "Disable emoji in output");
+    return this;
+  }
+  themes() {
+    this.globalCommand.option("--theme <theme>", "Color theme (default, dracula, nord, solarized, monokai)");
+    return this;
+  }
+  cache() {
+    this.globalCommand.option("--no-cache", "Disable caching");
+    return this;
+  }
+  usage(text) {
+    this.globalCommand.usage(text);
+    return this;
+  }
+  command(rawName, description, config) {
+    if (!config) {
+      config = {};
+    }
+    const command = new Command_default(rawName, description || "", config, this);
+    command.globalCommand = this.globalCommand;
+    this.commands.push(command);
+    return command;
+  }
+  option(rawName, description, config) {
+    this.globalCommand.option(rawName, description, config);
+    return this;
+  }
+  help(callback) {
+    this.globalCommand.option("-h, --help", "Display this message");
+    this.globalCommand.helpCallback = callback;
+    this.showHelpOnExit = true;
+    return this;
+  }
+  version(version, customFlags = "-v, --version") {
+    this.globalCommand.version(version, customFlags);
+    this.showVersionOnExit = true;
+    return this;
+  }
+  example(example) {
+    this.globalCommand.example(example);
+    return this;
+  }
+  outputHelp() {
+    if (this.matchedCommand) {
+      this.matchedCommand.outputHelp();
+    } else {
+      this.globalCommand.outputHelp();
+    }
+  }
+  outputVersion() {
+    this.globalCommand.outputVersion();
+  }
+  setParsedInfo({ args, options }, matchedCommand, matchedCommandName) {
+    this.args = args;
+    this.options = options;
+    if (matchedCommand) {
+      this.matchedCommand = matchedCommand;
+    }
+    if (matchedCommandName) {
+      this.matchedCommandName = matchedCommandName;
+    }
+    return this;
+  }
+  unsetMatchedCommand() {
+    this.matchedCommand = undefined;
+    this.matchedCommandName = undefined;
+  }
+  showCommandNotFound(input) {
+    console.log(style.red(`
+\u2717 Command "${input}" not found.
+`));
+    if (this.enableDidYouMean) {
+      const allCommandNames = [];
+      for (const command of this.commands) {
+        if (command.name) {
+          allCommandNames.push(command.name);
+        }
+        if (command.aliasNames) {
+          allCommandNames.push(...command.aliasNames);
+        }
+      }
+      const suggestions = findSimilarCommands(input, allCommandNames);
+      if (suggestions.length > 0) {
+        console.log(style.yellow("Did you mean one of these?"));
+        suggestions.forEach((cmd) => console.log(`  ${style.dim("\u2022")} ${this.name} ${cmd}`));
+        console.log("");
+      }
+    }
+    console.log(style.dim("Run"), `${this.name} --help`, style.dim("to see all available commands"));
+    process5.exit(1);
+  }
+  async parse(argv = processArgs2, options = {}) {
+    let { run = true, exitOnError = false } = options;
+    if (exitOnError) {
+      try {
+        return await this.parse(argv, { run });
+      } catch (err) {
+        this.handleUsageError(err);
+        throw err;
+      }
+    }
+    this.rawArgs = argv;
+    if (!this.name) {
+      this.name = argv[1] ? getFileName(argv[1]) : "cli";
+    }
+    let shouldParse = true;
+    const slicedArgv = argv.slice(2);
+    const candidateName = slicedArgv[0];
+    if (candidateName && !candidateName.startsWith("-")) {
+      for (const command of this.commands) {
+        if (command.isMatched(candidateName)) {
+          const parsed = this.mri(slicedArgv, command);
+          shouldParse = false;
+          const parsedInfo = {
+            ...parsed,
+            args: parsed.args.slice(1)
+          };
+          this.setParsedInfo(parsedInfo, command, candidateName);
+          this.emit(`command:${candidateName}`, command);
+          break;
+        }
+      }
+    }
+    if (shouldParse) {
+      for (const command of this.commands) {
+        if (command.name === "") {
+          shouldParse = false;
+          const parsed = this.mri(slicedArgv, command);
+          this.setParsedInfo(parsed, command);
+          this.emit(`command:!`, command);
+          break;
+        }
+      }
+    }
+    if (shouldParse) {
+      const parsed = this.mri(argv.slice(2));
+      this.setParsedInfo(parsed);
+    }
+    if (this.options.verbose) {
+      this.isVerbose = true;
+    }
+    if (this.options.quiet) {
+      this.isQuiet = true;
+    }
+    if (this.options.debug) {
+      this.isDebug = true;
+    }
+    if (this.options.noInteraction) {
+      this.isNoInteraction = true;
+    }
+    if (this.options.env) {
+      this.environment = String(this.options.env);
+    }
+    if (this.options.dryRun) {
+      this.isDryRun = true;
+    }
+    if (this.options.force) {
+      this.isForce = true;
+    }
+    if (this.options.noEmoji !== undefined) {
+      this.useEmoji = !this.options.noEmoji;
+    }
+    if (this.options.theme) {
+      this.theme = String(this.options.theme);
+    }
+    if (this.options.noCache !== undefined) {
+      this.isNoCache = Boolean(this.options.noCache);
+    }
+    if (this.options.help && this.showHelpOnExit) {
+      this.outputHelp();
+      run = false;
+      this.unsetMatchedCommand();
+    }
+    if (this.options.version && this.showVersionOnExit && this.matchedCommandName == null) {
+      this.outputVersion();
+      run = false;
+      this.unsetMatchedCommand();
+    }
+    const parsedArgv = { args: this.args, options: this.options };
+    if (run) {
+      await this.runMatchedCommand();
+    }
+    if (!this.matchedCommand && this.args[0]) {
+      this.emit("command:*");
+      const hasWildcardListener = this.listenerCount("command:*") > 0;
+      if (!hasWildcardListener) {
+        this.showCommandNotFound(this.args[0]);
+      }
+    }
+    return parsedArgv;
+  }
+  mri(argv, command) {
+    const cliOptions = [
+      ...this.globalCommand.options,
+      ...command ? command.options : []
+    ];
+    const mriOptions = getMriOptions(cliOptions);
+    let argsAfterDoubleDashes = [];
+    const doubleDashesIndex = argv.indexOf("--");
+    if (doubleDashesIndex > -1) {
+      argsAfterDoubleDashes = argv.slice(doubleDashesIndex + 1);
+      argv = argv.slice(0, doubleDashesIndex);
+    }
+    const raw = parseArgv(argv, mriOptions);
+    const parsed = { _: raw._ };
+    for (const name of Object.keys(raw)) {
+      if (name !== "_") {
+        parsed[camelcaseOptionName(name)] = raw[name];
+      }
+    }
+    const args = parsed._;
+    const options = {
+      "--": argsAfterDoubleDashes
+    };
+    const ignoreDefault = command && command.config.ignoreOptionDefaultValue ? command.config.ignoreOptionDefaultValue : this.globalCommand.config.ignoreOptionDefaultValue;
+    const transforms = Object.create(null);
+    for (const cliOption of cliOptions) {
+      if (!ignoreDefault && cliOption.config.default !== undefined) {
+        for (const name of cliOption.names) {
+          options[name] = cliOption.config.default;
+        }
+      }
+      if (Array.isArray(cliOption.config.type)) {
+        if (transforms[cliOption.name] === undefined) {
+          transforms[cliOption.name] = {
+            shouldTransform: true,
+            transformFunction: cliOption.config.type[0]
+          };
+        }
+      }
+    }
+    for (const key of Object.keys(parsed)) {
+      if (key !== "_") {
+        const keys = key.split(".");
+        setDotProp(options, keys, parsed[key]);
+        setByType(options, transforms);
+      }
+    }
+    return {
+      args,
+      options
+    };
+  }
+  async run(argv = processArgs2) {
+    return this.parse(argv, { run: true, exitOnError: true });
+  }
+  handleUsageError(err) {
+    const isClappError = !!err && typeof err === "object" && err.name === "ClappError";
+    const isUsage = isClappError && err.isUsageError !== false;
+    if (!isUsage)
+      return;
+    const e = err;
+    const raw = e.message ?? "command-line error";
+    const label = this.name ? `${this.name}: ` : "";
+    const suffix = /--help/.test(raw) ? "" : `
+Run \`${this.name ?? "cli"} --help\` for usage.`;
+    process5.stderr.write(`${label}${raw}${suffix}
+`);
+    process5.exit(e.exitCode ?? 2);
+  }
+  async runMatchedCommand() {
+    const { args, options, matchedCommand: command } = this;
+    if (!command || !command.commandAction)
+      return;
+    command.checkUnknownOptions();
+    command.checkOptionValue();
+    command.checkRequiredArgs();
+    const actionArgs = [];
+    command.args.forEach((arg, index) => {
+      if (arg.variadic) {
+        actionArgs.push(args.slice(index));
+      } else {
+        actionArgs.push(args[index]);
+      }
+    });
+    actionArgs.push(options);
+    const context = {
+      command,
+      args: actionArgs,
+      options
+    };
+    for (const hook of command.beforeHooks) {
+      await hook(context);
+    }
+    let actionResult;
+    const executeAction = async () => {
+      const result = command.commandAction.apply(this, actionArgs);
+      if (result instanceof Promise) {
+        actionResult = await result;
+      } else {
+        actionResult = result;
+      }
+      return actionResult;
+    };
+    if (command.middleware.length > 0) {
+      let index = 0;
+      const next = async () => {
+        if (index < command.middleware.length) {
+          const middleware2 = command.middleware[index++];
+          await middleware2({ ...context, next });
+        } else {
+          await executeAction();
+        }
+      };
+      await next();
+    } else {
+      await executeAction();
+    }
+    for (const hook of command.afterHooks) {
+      await hook(context);
+    }
+    return actionResult;
+  }
+  removeSignalHandlers() {
+    if (!this.signalHandlersSet) {
+      return this;
+    }
+    process5.removeAllListeners("SIGINT");
+    process5.removeAllListeners("SIGTERM");
+    this.signalHandlersSet = false;
+    return this;
+  }
+  destroy() {
+    this.removeSignalHandlers();
+    this.commands = [];
+    this.rawArgs = [];
+    this.args = [];
+    this.options = {};
+    this.matchedCommand = undefined;
+    this.matchedCommandName = undefined;
+    this.removeAllListeners();
+  }
+}
+class CLICache {
+  cache;
+  enabled;
+  cleanupInterval = null;
+  hits = 0;
+  misses = 0;
+  constructor() {
+    this.cache = new Map;
+    this.enabled = true;
+    this.startCleanupInterval();
+  }
+  startCleanupInterval() {
+    if (this.cleanupInterval) {
+      return;
+    }
+    this.cleanupInterval = setInterval(() => {
+      this.cleanup();
+    }, 30000);
+    this.cleanupInterval.unref();
+  }
+  stopCleanup() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  get(key) {
+    if (!this.enabled) {
+      this.misses++;
+      return;
+    }
+    const entry = this.cache.get(key);
+    if (!entry) {
+      this.misses++;
+      return;
+    }
+    const now = Date.now();
+    if (now - entry.timestamp > entry.ttl) {
+      this.cache.delete(key);
+      this.misses++;
+      return;
+    }
+    this.hits++;
+    return entry.value;
+  }
+  set(key, value, ttl = 5000) {
+    if (!this.enabled) {
+      return;
+    }
+    this.cache.set(key, {
+      value,
+      timestamp: Date.now(),
+      ttl
+    });
+  }
+  has(key) {
+    if (!this.enabled) {
+      return false;
+    }
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return false;
+    }
+    const now = Date.now();
+    if (now - entry.timestamp > entry.ttl) {
+      this.cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  delete(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  disable() {
+    this.enabled = false;
+    this.clear();
+  }
+  enable() {
+    this.enabled = true;
+  }
+  stats() {
+    return {
+      size: this.cache.size,
+      enabled: this.enabled,
+      hits: this.hits,
+      misses: this.misses
+    };
+  }
+  resetStats() {
+    this.hits = 0;
+    this.misses = 0;
+  }
+  keys() {
+    return Array.from(this.cache.keys());
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      if (now - entry.timestamp > entry.ttl) {
+        this.cache.delete(key);
+      }
+    }
+  }
+  destroy() {
+    this.stopCleanup();
+    this.clear();
+    this.resetStats();
+  }
+}
+var cliCache = new CLICache;
+function detectColorSupport2() {
+  if ("FORCE_COLOR" in process7.env) {
+    return process7.env.FORCE_COLOR !== "0";
+  }
+  if ("NO_COLOR" in process7.env || process7.env.TERM === "dumb") {
+    return false;
+  }
+  if (process7.platform === "win32") {
+    return true;
+  }
+  return tty.isatty(1) && tty.isatty(2);
+}
+var enabled = detectColorSupport2();
+function wrap(open, close) {
+  if (!enabled)
+    return (text) => text;
+  return (text) => open + text + close;
+}
+var reset = wrap("\x1B[0m", "\x1B[0m");
+var red = wrap("\x1B[31m", "\x1B[39m");
+var green = wrap("\x1B[32m", "\x1B[39m");
+var yellow = wrap("\x1B[33m", "\x1B[39m");
+var blue = wrap("\x1B[34m", "\x1B[39m");
+var magenta = wrap("\x1B[35m", "\x1B[39m");
+var cyan = wrap("\x1B[36m", "\x1B[39m");
+var white = wrap("\x1B[37m", "\x1B[39m");
+var gray = wrap("\x1B[90m", "\x1B[39m");
+var bold = wrap("\x1B[1m", "\x1B[22m");
+var italic = wrap("\x1B[3m", "\x1B[23m");
+var underline = wrap("\x1B[4m", "\x1B[24m");
+var dim = wrap("\x1B[2m", "\x1B[22m");
+var inverse = wrap("\x1B[7m", "\x1B[27m");
+var hidden = wrap("\x1B[8m", "\x1B[28m");
+var strikethrough = wrap("\x1B[9m", "\x1B[29m");
+var bgRed = wrap("\x1B[41m", "\x1B[49m");
+var bgGreen = wrap("\x1B[42m", "\x1B[49m");
+var bgYellow = wrap("\x1B[43m", "\x1B[49m");
+var bgBlue = wrap("\x1B[44m", "\x1B[49m");
+var bgMagenta = wrap("\x1B[45m", "\x1B[49m");
+var bgCyan = wrap("\x1B[46m", "\x1B[49m");
+var bgWhite = wrap("\x1B[47m", "\x1B[49m");
+var isColorSupported = enabled;
+var colors = {
+  reset,
+  red,
+  green,
+  yellow,
+  blue,
+  magenta,
+  cyan,
+  white,
+  gray,
+  bold,
+  italic,
+  underline,
+  dim,
+  inverse,
+  hidden,
+  strikethrough,
+  bgRed,
+  bgGreen,
+  bgYellow,
+  bgBlue,
+  bgMagenta,
+  bgCyan,
+  bgWhite,
+  isColorSupported
+};
+var colors_default = colors;
+var actions = ["up", "down", "left", "right", "space", "enter", "cancel"];
+var settings = {
+  actions: new Set(actions),
+  aliases: new Map([
+    ["k", "up"],
+    ["j", "down"],
+    ["h", "left"],
+    ["l", "right"],
+    ["\x03", "cancel"],
+    ["escape", "cancel"]
+  ]),
+  messages: {
+    cancel: "Canceled",
+    error: "Something went wrong"
+  }
+};
+function isActionKey(key, action) {
+  if (typeof key === "string") {
+    return settings.aliases.get(key) === action;
+  }
+  for (const value of key) {
+    if (value === undefined)
+      continue;
+    if (isActionKey(value, action)) {
+      return true;
+    }
+  }
+  return false;
+}
+function diffLines(a, b) {
+  if (a === b)
+    return [];
+  const aLines = a.split(`
+`);
+  const bLines = b.split(`
+`);
+  const diff = [];
+  for (let i = 0;i < Math.max(aLines.length, bLines.length); i++) {
+    if (aLines[i] !== bLines[i])
+      diff.push(i);
+  }
+  return diff;
+}
+var isWindows = process8.platform.startsWith("win");
+var CANCEL_SYMBOL = Symbol("clapp:cancel");
+function setRawMode(input, value) {
+  const i = input;
+  if (i.isTTY)
+    i.setRawMode(value);
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function stringWidth(str) {
+  return stripAnsi(str).length;
+}
+function wrapAnsi(text, columns, options) {
+  if (!columns || columns < 1)
+    return text;
+  const hard = options?.hard ?? false;
+  const trim = options?.trim ?? true;
+  const lines = text.split(`
+`);
+  const result = [];
+  for (const line of lines) {
+    if (stringWidth(line) <= columns) {
+      result.push(trim ? line.trimEnd() : line);
+      continue;
+    }
+    if (hard) {
+      let current = "";
+      let currentWidth = 0;
+      let i = 0;
+      while (i < line.length) {
+        const ansiMatch = line.slice(i).match(/^\x1b\[[0-9;]*m/);
+        if (ansiMatch) {
+          current += ansiMatch[0];
+          i += ansiMatch[0].length;
+          continue;
+        }
+        if (currentWidth >= columns) {
+          result.push(trim ? current.trimEnd() : current);
+          current = "";
+          currentWidth = 0;
+        }
+        current += line[i];
+        currentWidth++;
+        i++;
+      }
+      if (current) {
+        result.push(trim ? current.trimEnd() : current);
+      }
+    } else {
+      result.push(trim ? line.trimEnd() : line);
+    }
+  }
+  return result.join(`
+`);
+}
+
+class Prompt {
+  input;
+  output;
+  _abortSignal;
+  rl;
+  opts;
+  _render;
+  _track = false;
+  _prevFrame = "";
+  _subscribers = new Map;
+  _cursor = 0;
+  _manualLine = "";
+  state = "initial";
+  error = "";
+  value;
+  userInput = "";
+  constructor(options, trackValue = true) {
+    const { input = stdin2, output = stdout2, render, signal, ...opts } = options;
+    this.opts = opts;
+    this.onKeypress = this.onKeypress.bind(this);
+    this.close = this.close.bind(this);
+    this.render = this.render.bind(this);
+    this._render = render.bind(this);
+    this._track = trackValue;
+    this._abortSignal = signal;
+    this.input = input;
+    this.output = output;
+  }
+  unsubscribe() {
+    this._subscribers.clear();
+  }
+  setSubscriber(event, opts) {
+    const params = this._subscribers.get(event) ?? [];
+    params.push(opts);
+    this._subscribers.set(event, params);
+  }
+  on(event, cb) {
+    this.setSubscriber(event, { cb });
+    return this;
+  }
+  once(event, cb) {
+    this.setSubscriber(event, { cb, once: true });
+    return this;
+  }
+  emit(event, ...data) {
+    const cbs = this._subscribers.get(event) ?? [];
+    const cleanup = [];
+    for (const subscriber of cbs) {
+      subscriber.cb(...data);
+      if (subscriber.once) {
+        cleanup.push(() => cbs.splice(cbs.indexOf(subscriber), 1));
+      }
+    }
+    for (const cb of cleanup) {
+      cb();
+    }
+    return this;
+  }
+  prompt() {
+    return new Promise((resolve) => {
+      if (this._abortSignal) {
+        if (this._abortSignal.aborted) {
+          this.state = "cancel";
+          this.close();
+          return resolve(CANCEL_SYMBOL);
+        }
+        this._abortSignal.addEventListener("abort", () => {
+          this.state = "cancel";
+          this.close();
+        }, { once: true });
+      }
+      this.rl = readline2.createInterface({
+        input: this.input,
+        tabSize: 2,
+        prompt: "",
+        escapeCodeTimeout: 50,
+        terminal: true
+      });
+      this.rl.prompt();
+      if (this.opts.initialUserInput !== undefined) {
+        this._setUserInput(this.opts.initialUserInput, true);
+      }
+      this.input.on("keypress", this.onKeypress);
+      setRawMode(this.input, true);
+      this.output.on("resize", this.render);
+      this.render();
+      this.once("submit", () => {
+        this.output.write(cursor.show);
+        this.output.off("resize", this.render);
+        setRawMode(this.input, false);
+        resolve(this.value);
+      });
+      this.once("cancel", () => {
+        this.output.write(cursor.show);
+        this.output.off("resize", this.render);
+        setRawMode(this.input, false);
+        resolve(CANCEL_SYMBOL);
+      });
+    });
+  }
+  _isActionKey(char, _key) {
+    return char === "\t";
+  }
+  _setValue(value) {
+    this.value = value;
+    this.emit("value", this.value);
+  }
+  _setUserInput(value, write) {
+    this.userInput = value ?? "";
+    this.emit("userInput", this.userInput);
+    if (write && this._track && this.rl) {
+      this.rl.write(this.userInput);
+      this._cursor = this.rl.cursor;
+    }
+  }
+  onKeypress(char, key) {
+    if (this._track && key.name !== "return") {
+      if (key.name && this._isActionKey(char, key)) {
+        this.rl?.write(null, { ctrl: true, name: "h" });
+      }
+      this._cursor = this.rl?.cursor ?? 0;
+      const isSpecialKey = key.name === "tab" || key.name === "escape" || key.name === "backspace" || key.name === "delete" || key.name === "enter" || key.name === "return" || key.name && ["up", "down", "left", "right"].includes(key.name);
+      if (char && !isSpecialKey && char.length === 1 && char >= " ") {
+        this._manualLine += char;
+      } else if (key.name === "backspace" && this._manualLine.length > 0) {
+        this._manualLine = this._manualLine.slice(0, -1);
+      }
+      const effectiveLine = this._manualLine.length >= (this.rl?.line?.length || 0) ? this._manualLine : this.rl?.line;
+      this._setUserInput(effectiveLine);
+    }
+    if (this.state === "error") {
+      this.state = "active";
+      this.error = "";
+    }
+    if (key?.name) {
+      if (!this._track && settings.aliases.has(key.name)) {
+        this.emit("cursor", settings.aliases.get(key.name));
+      }
+      if (settings.actions.has(key.name)) {
+        this.emit("cursor", key.name);
+      }
+    }
+    if (char && (char.toLowerCase() === "y" || char.toLowerCase() === "n")) {
+      this.emit("confirm", char.toLowerCase() === "y");
+    }
+    this.emit("key", char?.toLowerCase(), key);
+    if (key?.name === "return") {
+      if (this.opts.validate) {
+        const problem = this.opts.validate(this.value);
+        if (problem) {
+          this.error = problem instanceof Error ? problem.message : problem;
+          this.state = "error";
+        }
+      }
+      if (this.state !== "error") {
+        this.state = "submit";
+      }
+    }
+    if (isActionKey([char, key?.name, key?.sequence], "cancel")) {
+      this.state = "cancel";
+    }
+    if (this.state === "submit" || this.state === "cancel") {
+      this.emit("finalize");
+    }
+    this.render();
+    if (this.state === "submit" || this.state === "cancel") {
+      this.close();
+    }
+  }
+  close() {
+    this.input.unpipe();
+    this.input.removeListener("keypress", this.onKeypress);
+    this.output.write(`
+`);
+    setRawMode(this.input, false);
+    this.rl?.close();
+    this.rl = undefined;
+    this.emit(`${this.state}`, this.value);
+    if (this.state === "cancel") {
+      setTimeout(() => {
+        this.unsubscribe();
+      }, 10);
+    } else {
+      this.unsubscribe();
+    }
+  }
+  restoreCursor() {
+    const lines = wrapAnsi(this._prevFrame, process9.stdout.columns, { hard: true, trim: false }).split(`
+`).length - 1;
+    this.output.write(cursor.move(-999, lines * -1));
+  }
+  render() {
+    const frame = wrapAnsi(this._render(this) ?? "", process9.stdout.columns, {
+      hard: true,
+      trim: false
+    });
+    if (frame === this._prevFrame) {
+      return;
+    }
+    if (this.state === "initial") {
+      this.output.write(cursor.hide);
+    } else {
+      const diff = diffLines(this._prevFrame, frame);
+      this.restoreCursor();
+      if (diff && diff?.length === 1) {
+        const diffLine = diff[0];
+        this.output.write(cursor.move(0, diffLine));
+        this.output.write(erase.lines(1));
+        const lines = frame.split(`
+`);
+        this.output.write(lines[diffLine]);
+        this._prevFrame = frame;
+        this.output.write(cursor.move(0, lines.length - diffLine - 1));
+        return;
+      }
+      if (diff && diff?.length > 1) {
+        const diffLine = diff[0];
+        this.output.write(cursor.move(0, diffLine));
+        this.output.write(erase.down());
+        const lines = frame.split(`
+`);
+        const newLines = lines.slice(diffLine);
+        this.output.write(newLines.join(`
+`));
+        this._prevFrame = frame;
+        return;
+      }
+      this.output.write(erase.down());
+    }
+    this.output.write(frame);
+    if (this.state === "initial") {
+      this.state = "active";
+    }
+    this._prevFrame = frame;
+  }
+}
+function getCursorForValue(selected, items) {
+  if (selected === undefined) {
+    return 0;
+  }
+  const currLength = items.length;
+  if (currLength === 0) {
+    return 0;
+  }
+  const index = items.findIndex((item) => item.value === selected);
+  return index !== -1 ? index : 0;
+}
+function defaultFilter(input, option) {
+  const label = option.label ?? String(option.value);
+  return label.toLowerCase().includes(input.toLowerCase());
+}
+function normalisedValue(multiple, values) {
+  if (!values) {
+    return;
+  }
+  if (multiple) {
+    return values;
+  }
+  return values[0];
+}
+
+class AutocompletePrompt extends Prompt {
+  filteredOptions;
+  multiple;
+  isNavigating = false;
+  selectedValues = [];
+  focusedValue;
+  #cursor = 0;
+  #lastUserInput = "";
+  #filterFn;
+  #options;
+  get cursor() {
+    return this.#cursor;
+  }
+  get userInputWithCursor() {
+    if (!this.userInput) {
+      return colors_default.inverse(colors_default.hidden("_"));
+    }
+    if (this._cursor >= this.userInput.length) {
+      return `${this.userInput}\u2588`;
+    }
+    const s1 = this.userInput.slice(0, this._cursor);
+    const [s2, ...s3] = this.userInput.slice(this._cursor);
+    return `${s1}${colors_default.inverse(s2)}${s3.join("")}`;
+  }
+  get options() {
+    if (typeof this.#options === "function") {
+      return this.#options();
+    }
+    return this.#options;
+  }
+  constructor(opts) {
+    super(opts);
+    this.#options = opts.options;
+    const options = this.options;
+    this.filteredOptions = [...options];
+    this.multiple = opts.multiple === true;
+    this.#filterFn = opts.filter ?? defaultFilter;
+    let initialValues;
+    if (opts.initialValue && Array.isArray(opts.initialValue)) {
+      if (this.multiple) {
+        initialValues = opts.initialValue;
+      } else {
+        initialValues = opts.initialValue.slice(0, 1);
+      }
+    } else {
+      if (!this.multiple && this.options.length > 0) {
+        initialValues = [this.options[0].value];
+      }
+    }
+    if (initialValues) {
+      for (const selectedValue of initialValues) {
+        const selectedIndex = options.findIndex((opt) => opt.value === selectedValue);
+        if (selectedIndex !== -1) {
+          this.toggleSelected(selectedValue);
+          this.#cursor = selectedIndex;
+        }
+      }
+    }
+    this.focusedValue = this.options[this.#cursor]?.value;
+    this.on("key", (char, key) => this.#onKey(char, key));
+    this.on("userInput", (value) => this.#onUserInputChanged(value));
+  }
+  _isActionKey(char, key) {
+    return char === "\t" || this.multiple && this.isNavigating && key.name === "space" && char !== undefined && char !== "";
+  }
+  #onKey(_char, key) {
+    const isUpKey = key.name === "up";
+    const isDownKey = key.name === "down";
+    const isReturnKey = key.name === "return";
+    if (isUpKey || isDownKey) {
+      this.#cursor = Math.max(0, Math.min(this.#cursor + (isUpKey ? -1 : 1), this.filteredOptions.length - 1));
+      this.focusedValue = this.filteredOptions[this.#cursor]?.value;
+      if (!this.multiple) {
+        this.selectedValues = [this.focusedValue];
+      }
+      this.isNavigating = true;
+    } else if (isReturnKey) {
+      this.value = normalisedValue(this.multiple, this.selectedValues);
+    } else {
+      if (this.multiple) {
+        if (this.focusedValue !== undefined && (key.name === "tab" || this.isNavigating && key.name === "space")) {
+          this.toggleSelected(this.focusedValue);
+        } else {
+          this.isNavigating = false;
+        }
+      } else {
+        if (this.focusedValue) {
+          this.selectedValues = [this.focusedValue];
+        }
+        this.isNavigating = false;
+      }
+    }
+  }
+  deselectAll() {
+    this.selectedValues = [];
+  }
+  toggleSelected(value) {
+    if (this.filteredOptions.length === 0) {
+      return;
+    }
+    if (this.multiple) {
+      if (this.selectedValues.includes(value)) {
+        this.selectedValues = this.selectedValues.filter((v) => v !== value);
+      } else {
+        this.selectedValues = [...this.selectedValues, value];
+      }
+    } else {
+      this.selectedValues = [value];
+    }
+  }
+  #onUserInputChanged(value) {
+    if (value !== this.#lastUserInput) {
+      this.#lastUserInput = value;
+      const options = this.options;
+      if (value) {
+        this.filteredOptions = options.filter((opt) => this.#filterFn(value, opt));
+      } else {
+        this.filteredOptions = [...options];
+      }
+      this.#cursor = getCursorForValue(this.focusedValue, this.filteredOptions);
+      this.focusedValue = this.filteredOptions[this.#cursor]?.value;
+      if (!this.multiple) {
+        if (this.focusedValue !== undefined) {
+          this.toggleSelected(this.focusedValue);
+        } else {
+          this.deselectAll();
+        }
+      }
+    }
+  }
+}
+class GroupMultiSelectPrompt extends Prompt {
+  options;
+  cursor = 0;
+  #selectableGroups;
+  getGroupItems(group) {
+    return this.options.filter((o) => o.group === group);
+  }
+  isGroupSelected(group) {
+    const items = this.getGroupItems(group);
+    const value = this.value;
+    if (value === undefined) {
+      return false;
+    }
+    return items.every((i) => value.includes(i.value));
+  }
+  toggleValue() {
+    const item = this.options[this.cursor];
+    if (this.value === undefined) {
+      this.value = [];
+    }
+    if (item.group === true) {
+      const group = item.value;
+      const groupedItems = this.getGroupItems(group);
+      if (this.isGroupSelected(group)) {
+        this.value = this.value.filter((v) => groupedItems.findIndex((i) => i.value === v) === -1);
+      } else {
+        this.value = [...this.value, ...groupedItems.map((i) => i.value)];
+      }
+      this.value = Array.from(new Set(this.value));
+    } else {
+      const selected = this.value.includes(item.value);
+      this.value = selected ? this.value.filter((v) => v !== item.value) : [...this.value, item.value];
+    }
+  }
+  constructor(opts) {
+    super(opts, false);
+    const { options } = opts;
+    this.#selectableGroups = opts.selectableGroups !== false;
+    this.options = Object.entries(options).flatMap(([key, option]) => [
+      { value: key, group: true, label: key },
+      ...option.map((opt) => ({ ...opt, group: key }))
+    ]);
+    this.value = [...opts.initialValues ?? []];
+    this.cursor = Math.max(this.options.findIndex(({ value }) => value === opts.cursorAt), this.#selectableGroups ? 0 : 1);
+    this.on("cursor", (key) => {
+      switch (key) {
+        case "left":
+        case "up": {
+          this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
+          const currentIsGroup = this.options[this.cursor]?.group === true;
+          if (!this.#selectableGroups && currentIsGroup) {
+            this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
+          }
+          break;
+        }
+        case "down":
+        case "right": {
+          this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
+          const currentIsGroup = this.options[this.cursor]?.group === true;
+          if (!this.#selectableGroups && currentIsGroup) {
+            this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
+          }
+          break;
+        }
+        case "space":
+          this.toggleValue();
+          break;
+      }
+    });
+  }
+}
+var unicode = isUnicodeSupported();
+var unicodeOr = (c, fallback) => unicode ? c : fallback;
+var S_STEP_ACTIVE = unicodeOr("\u25C6", "*");
+var S_STEP_CANCEL = unicodeOr("\u25A0", "x");
+var S_STEP_ERROR = unicodeOr("\u25B2", "x");
+var S_STEP_SUBMIT = unicodeOr("\u25C7", "o");
+var S_BAR_START = unicodeOr("\u250C", "T");
+var S_BAR = unicodeOr("\u2502", "|");
+var S_BAR_END = unicodeOr("\u2514", "\u2014");
+var S_RADIO_ACTIVE = unicodeOr("\u25CF", ">");
+var S_RADIO_INACTIVE = unicodeOr("\u25CB", " ");
+var S_CHECKBOX_ACTIVE = unicodeOr("\u25FB", "[\u2022]");
+var S_CHECKBOX_SELECTED = unicodeOr("\u25FC", "[+]");
+var S_CHECKBOX_INACTIVE = unicodeOr("\u25FB", "[ ]");
+var S_PASSWORD_MASK = unicodeOr("\u25AA", "\u2022");
+var S_BAR_H = unicodeOr("\u2500", "-");
+var S_CORNER_TOP_RIGHT = unicodeOr("\u256E", "+");
+var S_CONNECT_LEFT = unicodeOr("\u251C", "+");
+var S_CORNER_BOTTOM_RIGHT = unicodeOr("\u256F", "+");
+var S_INFO = unicodeOr("\u25CF", "\u2022");
+var S_SUCCESS = unicodeOr("\u25C6", "*");
+var S_WARN = unicodeOr("\u25B2", "!");
+var S_ERROR = unicodeOr("\u25A0", "x");
+var S_PROGRESS_CHAR = {
+  light: unicodeOr("\u2500", "-"),
+  heavy: unicodeOr("\u2501", "="),
+  block: unicodeOr("\u2588", "#")
+};
+function getPrefix() {
+  return `${colors_default.gray(S_BAR)}  `;
+}
+var prefix = getPrefix();
+// package.json
+var version = "0.0.15";
+
+// src/cli/middleware.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+import process6 from "process";
+
+// src/cli/colors.ts
+var colors2 = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+var chalk = {
+  red: (text) => `${colors2.red}${text}${colors2.reset}`,
+  green: (text) => `${colors2.green}${text}${colors2.reset}`,
+  yellow: (text) => `${colors2.yellow}${text}${colors2.reset}`,
+  blue: (text) => `${colors2.blue}${text}${colors2.reset}`,
+  cyan: (text) => `${colors2.cyan}${text}${colors2.reset}`,
+  white: (text) => `${colors2.white}${text}${colors2.reset}`,
+  gray: (text) => `${colors2.gray}${text}${colors2.reset}`,
+  bold: (text) => `${colors2.bold}${text}${colors2.reset}`,
+  dim: (text) => `${colors2.dim}${text}${colors2.reset}`,
+  hex: (_color) => (text) => text
+};
+
+// src/cli/middleware.ts
+async function generateMiddlewareTypes(outputPath) {
+  const middlewareInfo = Object.entries(middleware).map(([key, instance]) => ({
+    name: key,
+    className: instance.constructor.name
+  }));
+  const typeContent = `/**
+ * This file is auto-generated.
+ * DO NOT EDIT THIS FILE DIRECTLY.
+ * To update, run 'bun router middleware:types'
+ */
+import type { ${middlewareInfo.map((m) => m.className).join(", ")} } from './middleware'
+
+/**
+ * Available middleware map with middleware names as keys
+ */
+export interface MiddlewareMap {
+${middlewareInfo.map((m) => `  '${m.name}': ${m.className}`).join(`
+`)}
+}
+
+/**
+ * String literal type of available middleware names
+ */
+export type MiddlewareName = ${middlewareInfo.map((m) => `'${m.name}'`).join(" | ")}
+
+/**
+ * Middleware configuration type for router setup
+ */
+export type MiddlewareConfig = MiddlewareName | ${middlewareInfo.map((m) => m.className).join(" | ")}
+
+/**
+ * Function to check if a middleware name is valid
+ */
+export function isValidMiddleware(name: string): name is MiddlewareName {
+  return [${middlewareInfo.map((m) => `'${m.name}'`).join(", ")}].includes(name)
+}
+`;
+  await fs2.writeFile(outputPath, typeContent);
+}
+async function findTsFiles(dir) {
+  const files = [];
+  const entries = await fs2.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path2.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await findTsFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith(".ts")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+async function scanFileForMiddleware(filePath) {
+  const middlewareClasses = [];
+  try {
+    const content = await fs2.readFile(filePath, "utf-8");
+    const classRegex = /export\s+(?:default\s+)?class\s+(\w+)\s+(?:implements\s+Middleware|\{[\s\S]*?handle\s*\([\s\S]*?\))/g;
+    let match = null;
+    while (match = classRegex.exec(content)) {
+      const className = match[1];
+      if (className.includes("Middleware") || match[0].includes("implements Middleware")) {
+        const relativePath = path2.relative(process6.cwd(), filePath);
+        const importPath = relativePath.replace(/\.ts$/, "");
+        middlewareClasses.push({
+          name: className,
+          path: importPath
+        });
+      }
+    }
+  } catch (error) {
+    console.warn(chalk.yellow(`Error scanning file ${filePath}: ${error}`));
+  }
+  return middlewareClasses;
+}
+async function generateMiddlewareMap(directoryPath, outputPath) {
+  console.log(chalk.blue(`Scanning directory: ${directoryPath} for middleware classes...`));
+  try {
+    const tsFiles = await findTsFiles(directoryPath);
+    const allMiddleware = [];
+    for (const file of tsFiles) {
+      const middlewareInFile = await scanFileForMiddleware(file);
+      allMiddleware.push(...middlewareInFile);
+    }
+    if (allMiddleware.length === 0) {
+      console.warn(chalk.yellow("No middleware classes found in the specified directory."));
+      return;
+    }
+    const imports = allMiddleware.map((m) => `import { ${m.name} } from '${m.path}'`).join(`
+`);
+    const interfaceMembers = allMiddleware.map((m) => `  ${m.name}: typeof ${m.name}`).join(`
+`);
+    const typeNames = allMiddleware.map((m) => m.name).join(" | ");
+    const typeContent = `/**
+ * This file is auto-generated.
+ * DO NOT EDIT THIS FILE DIRECTLY.
+ * To update, run 'bun router middleware:map'
+ */
+
+${imports}
+
+/**
+ * Map of all available middleware in the project
+ */
+export interface MiddlewareMap {
+${interfaceMembers}
+}
+
+/**
+ * Type representing all available middleware classes in the project
+ */
+export type MiddlewareType = ${typeNames}
+
+/**
+ * Type for a middleware handler function
+ */
+export type MiddlewareHandler = (req: any, next: () => Promise<Response>) => Promise<Response>
+
+/**
+ * Ensure the middleware module exports all the middleware classes used in the project
+ */
+export const middlewareMap: MiddlewareMap = {
+${allMiddleware.map((m) => `  ${m.name}: ${m.name}`).join(`,
+`)}
+}
+`;
+    await fs2.writeFile(outputPath, typeContent);
+    console.log(chalk.green(`\u2728 Middleware map generated at ${outputPath} with ${allMiddleware.length} middleware classes`));
+    console.log(chalk.blue("Found middleware classes:"));
+    for (const m of allMiddleware) {
+      console.log(chalk.cyan(`  - ${m.name} (${m.path})`));
+    }
+  } catch (error) {
+    console.error(chalk.red(`Error generating middleware map: ${error}`));
+    throw error;
+  }
+}
+async function watchDirectoryForMiddleware(directoryPath, outputPath) {
+  try {
+    await fs2.access(directoryPath);
+  } catch {
+    console.error(chalk.red(`Directory not found at ${directoryPath}`));
+    process6.exit(1);
+  }
+  await generateMiddlewareMap(directoryPath, outputPath);
+  console.log(chalk.blue(`Watching for changes in ${directoryPath}...`));
+  let timeoutId = null;
+  const watcher = fs2.watch(directoryPath, { recursive: true });
+  for await (const _event of watcher) {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(async () => {
+      console.log(chalk.yellow(`Changes detected. Regenerating middleware map...`));
+      try {
+        await generateMiddlewareMap(directoryPath, outputPath);
+      } catch (error) {
+        console.error(chalk.red(`Error regenerating middleware map: ${error.message}`));
+      }
+      timeoutId = null;
+    }, 500);
+  }
+}
+async function watchMiddlewareDirectory(outputPath) {
+  const middlewarePath = path2.join(process6.cwd(), "src", "middleware");
+  try {
+    await fs2.access(middlewarePath);
+  } catch {
+    console.error(chalk.red(`Middleware directory not found at ${middlewarePath}`));
+    process6.exit(1);
+  }
+  await generateMiddlewareTypes(outputPath);
+  console.log(chalk.green(`\u2728 Middleware types generated at ${outputPath}`));
+  console.log(chalk.blue(`Watching for changes in ${middlewarePath}...`));
+  let timeoutId = null;
+  const watcher = fs2.watch(middlewarePath, { recursive: true });
+  for await (const _event of watcher) {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(async () => {
+      console.log(chalk.yellow(`Changes detected in middleware directory. Regenerating types...`));
+      try {
+        await generateMiddlewareTypes(outputPath);
+        console.log(chalk.green(`\u2728 Middleware types regenerated at ${outputPath}`));
+      } catch (error) {
+        console.error(chalk.red(`Error regenerating types: ${error.message}`));
+      }
+      timeoutId = null;
+    }, 500);
+  }
+}
+
+// src/cli/openapi.ts
+import fs3 from "fs/promises";
+import process10 from "process";
+async function generateOpenAPISpec(options) {
+  try {
+    const routesFile = `${process10.cwd()}/routes/index.ts`;
+    const { router } = await import(routesFile);
+    if (!router) {
+      console.error(chalk.red(`Could not find router instance in ${routesFile}.`));
+      process10.exit(1);
+    }
+    const routes = router.routes || [];
+    if (routes.length === 0) {
+      console.log(chalk.yellow("No routes defined. Creating empty OpenAPI specification."));
+    }
+    const apiRoutes = routes.filter((route) => {
+      return route.type === "api" || route.path.startsWith("/api");
+    });
+    const openapi = {
+      openapi: "3.0.3",
+      info: {
+        title: options.title || "API Documentation",
+        version: options.version || "1.0.0",
+        description: options.description || "Generated API documentation"
+      },
+      servers: generateServers(options),
+      paths: {},
+      components: {
+        schemas: {},
+        securitySchemes: {}
+      },
+      tags: []
+    };
+    const uniqueTags = new Set;
+    for (const route of apiRoutes) {
+      const pathItem = openapi.paths[route.path] || {};
+      let tag = "";
+      if (options.tags !== false) {
+        tag = route.tag || extractTagFromPath(route.path);
+        uniqueTags.add(tag);
+      }
+      const operation = {
+        summary: route.summary || `${route.method.toUpperCase()} ${route.path}`,
+        description: route.description || "",
+        operationId: route.name || generateOperationId(route.method, route.path),
+        parameters: generateParameters(route),
+        responses: generateResponses(route)
+      };
+      if (tag) {
+        operation.tags = [tag];
+      }
+      if (["post", "put", "patch"].includes(route.method.toLowerCase())) {
+        operation.requestBody = generateRequestBody(route);
+      }
+      if (options.security !== false && route.middleware) {
+        const securityItems = extractSecurityFromMiddleware(route.middleware);
+        if (securityItems.length > 0) {
+          operation.security = securityItems;
+        }
+      }
+      pathItem[route.method.toLowerCase()] = operation;
+      openapi.paths[route.path] = pathItem;
+    }
+    if (options.tags !== false) {
+      openapi.tags = Array.from(uniqueTags).map((tag) => ({
+        name: tag,
+        description: `Operations related to ${tag}`
+      }));
+    }
+    const outputPath = options.output || "openapi.json";
+    await fs3.writeFile(outputPath, JSON.stringify(openapi, null, 2));
+    console.log(chalk.green(`\u2728 OpenAPI specification generated at ${outputPath}`));
+    console.log(chalk.blue(`Import this file into Postman, Swagger UI, or other API tools to explore your API.`));
+  } catch (error) {
+    if (error.code === "ERR_MODULE_NOT_FOUND") {
+      console.error(chalk.red(`Routes file not found at ${process10.cwd()}/routes/index.ts`));
+      console.error(chalk.yellow('Make sure your routes are defined and exported as "router" in routes/index.ts'));
+    } else {
+      console.error(chalk.red(`Error generating OpenAPI specification: ${error.message}`));
+    }
+    throw error;
+  }
+}
+function generateServers(options) {
+  const servers = [];
+  if (options.servers) {
+    const serverUrls = options.servers.split(",").map((url) => url.trim());
+    for (const url of serverUrls) {
+      servers.push({
+        url,
+        description: `Server ${servers.length + 1}`
+      });
+    }
+  }
+  if (servers.length === 0) {
+    servers.push({
+      url: options.basePath || "/",
+      description: "Default server"
+    });
+  }
+  return servers;
+}
+function extractTagFromPath(path3) {
+  const segments = path3.split("/").filter(Boolean);
+  if (segments.length > 0) {
+    if (segments[0].toLowerCase() === "api" && segments.length > 1) {
+      return segments[1];
+    }
+    return segments[0];
+  }
+  return "default";
+}
+function generateOperationId(method, path3) {
+  const pathWithoutParams = path3.replace(/\{([^}]+)\}/g, "_$1");
+  const segments = pathWithoutParams.split("/").filter(Boolean);
+  if (segments.length === 0) {
+    return method.toLowerCase();
+  }
+  let operationId = method.toLowerCase();
+  for (const segment of segments) {
+    operationId += segment.charAt(0).toUpperCase() + segment.slice(1);
+  }
+  return operationId;
+}
+function generateParameters(route) {
+  const parameters = [];
+  const pathParams = route.path.match(/\{([^}]+)\}/g);
+  if (pathParams) {
+    for (const param of pathParams) {
+      const paramName = param.slice(1, -1);
+      parameters.push({
+        name: paramName,
+        in: "path",
+        required: true,
+        schema: {
+          type: "string"
+        },
+        description: `Path parameter: ${paramName}`
+      });
+    }
+  }
+  if (route.params && route.params.query) {
+    for (const [name, schema] of Object.entries(route.params.query)) {
+      parameters.push({
+        name,
+        in: "query",
+        schema: mapSchemaType(schema),
+        required: schema.required === true,
+        description: schema.description || `Query parameter: ${name}`
+      });
+    }
+  }
+  return parameters;
+}
+function mapSchemaType(schema) {
+  if (!schema || typeof schema !== "object") {
+    return { type: "string" };
+  }
+  const openApiSchema = {};
+  if (schema.type) {
+    openApiSchema.type = schema.type;
+  }
+  if (schema.format) {
+    openApiSchema.format = schema.format;
+  }
+  if (schema.enum) {
+    openApiSchema.enum = schema.enum;
+  }
+  if (schema.default !== undefined) {
+    openApiSchema.default = schema.default;
+  }
+  return openApiSchema;
+}
+function generateResponses(route) {
+  const responses = {
+    200: {
+      description: "Successful response",
+      content: {
+        "application/json": {
+          schema: {}
+        }
+      }
+    }
+  };
+  responses["400"] = {
+    description: "Bad request",
+    content: {
+      "application/json": {
+        schema: {
+          type: "object",
+          properties: {
+            error: { type: "string" }
+          }
+        }
+      }
+    }
+  };
+  responses["401"] = {
+    description: "Unauthorized",
+    content: {
+      "application/json": {
+        schema: {
+          type: "object",
+          properties: {
+            error: { type: "string" }
+          }
+        }
+      }
+    }
+  };
+  responses["404"] = {
+    description: "Not found",
+    content: {
+      "application/json": {
+        schema: {
+          type: "object",
+          properties: {
+            error: { type: "string" }
+          }
+        }
+      }
+    }
+  };
+  responses["500"] = {
+    description: "Server error",
+    content: {
+      "application/json": {
+        schema: {
+          type: "object",
+          properties: {
+            error: { type: "string" }
+          }
+        }
+      }
+    }
+  };
+  if (route.responses) {
+    for (const [status, response] of Object.entries(route.responses)) {
+      responses[status] = {
+        description: response.description || `Response with status ${status}`,
+        content: {
+          "application/json": {
+            schema: response.schema || {}
+          }
+        }
+      };
+    }
+  }
+  return responses;
+}
+function generateRequestBody(route) {
+  const requestBody = {
+    required: true,
+    content: {
+      "application/json": {
+        schema: {
+          type: "object"
+        }
+      }
+    }
+  };
+  if (route.params && route.params.body) {
+    requestBody.content["application/json"].schema = route.params.body;
+  }
+  return requestBody;
+}
+function extractSecurityFromMiddleware(middleware2) {
+  const securityItems = [];
+  for (const mw of middleware2) {
+    const name = typeof mw === "string" ? mw : mw.name;
+    if (name && name.toLowerCase().includes("auth")) {
+      if (name.toLowerCase().includes("jwt")) {
+        securityItems.push({ BearerAuth: [] });
+      } else if (name.toLowerCase().includes("apikey")) {
+        securityItems.push({ ApiKeyAuth: [] });
+      } else if (name.toLowerCase().includes("basic")) {
+        securityItems.push({ BasicAuth: [] });
+      } else {
+        securityItems.push({ [name]: [] });
+      }
+    }
+  }
+  return securityItems;
+}
+
+// src/cli/router.ts
+import fs4 from "fs/promises";
+import path3 from "path";
+import process12 from "process";
+async function generateRouterTypes(outputPath) {
+  try {
+    const routesFile = `${process12.cwd()}/routes/index.ts`;
+    const { router } = await import(routesFile);
+    if (!router) {
+      console.error(chalk.red(`Could not find router instance in ${routesFile}.`));
+      process12.exit(1);
+    }
+    const routerMethods = Object.getOwnPropertyNames(Object.getPrototypeOf(router)).filter((method) => !method.startsWith("_") && method !== "constructor" && typeof router[method] === "function");
+    const extendedProperties = Object.keys(router).filter((prop) => !["routes", "middleware", "hooks", "config"].includes(prop) && typeof prop === "string" && !prop.startsWith("_"));
+    const typeContent = `/**
+ * This file is auto-generated.
+ * DO NOT EDIT THIS FILE DIRECTLY.
+ * To update, run 'bun router router:types'
+ */
+import type { Router, RouteHandler, MiddlewareHandler, RouteDefinition } from '../src/types'
+
+/**
+ * Extended Router interface with all available methods and properties
+ */
+export interface ExtendedRouter extends Router {
+  ${routerMethods.map((method) => {
+      if (["get", "post", "put", "delete", "patch", "options", "head"].includes(method)) {
+        return `${method}(path: string, handler: RouteHandler, options?: any): Router`;
+      } else if (method === "use") {
+        return `${method}(middleware: MiddlewareHandler | MiddlewareHandler[]): Router`;
+      } else if (method === "group") {
+        return `${method}(prefix: string, callback: (router: Router) => void): Router`;
+      } else {
+        return `${method}: Function`;
+      }
+    }).join(`
+  `)}
+
+  ${extendedProperties.map((prop) => {
+      const propType = typeof router[prop];
+      return `${prop}: ${propType}`;
+    }).join(`
+  `)}
+}
+
+/**
+ * Type for extending the router with custom methods
+ */
+export type RouterExtension = {
+  [key: string]: Function | any
+}
+
+/**
+ * Helper type for correctly typing router extensions
+ *
+ * Example usage:
+ * \`\`\`typescript
+ * import { Router, ExtendRouter } from './router-types'
+ *
+ * // Define extension type
+ * interface MyCustomRouter extends ExtendRouter<{
+ *   customMethod(param: string): void
+ * }> {}
+ *
+ * // Create and extend the router
+ * const router = new Router() as MyCustomRouter
+ * router.customMethod = (param: string) => {
+ *   console.log(param)
+ * }
+ * \`\`\`
+ */
+export type ExtendRouter<T extends RouterExtension> = Router & T
+`;
+    await fs4.writeFile(outputPath, typeContent);
+    console.log(chalk.green(`\u2728 Router types generated at ${outputPath}`));
+  } catch (error) {
+    if (error.code === "ERR_MODULE_NOT_FOUND") {
+      console.error(chalk.red(`Routes file not found at ${process12.cwd()}/routes/index.ts`));
+      console.error(chalk.yellow('Make sure your routes are defined and exported as "router" in routes/index.ts'));
+    } else {
+      console.error(chalk.red(`Error generating router types: ${error.message}`));
+    }
+    throw error;
+  }
+}
+async function watchRouterFiles(outputPath) {
+  const routerFiles = [
+    path3.join(process12.cwd(), "routes"),
+    path3.join(process12.cwd(), "src")
+  ];
+  let validPath = false;
+  for (const dirPath of routerFiles) {
+    try {
+      await fs4.access(dirPath);
+      validPath = true;
+      break;
+    } catch {}
+  }
+  if (!validPath) {
+    console.error(chalk.red(`No valid source directories found to watch.`));
+    process12.exit(1);
+  }
+  await generateRouterTypes(outputPath);
+  console.log(chalk.green(`\u2728 Router types generated at ${outputPath}`));
+  console.log(chalk.blue(`Watching for changes in router files...`));
+  let timeoutId = null;
+  for (const dirPath of routerFiles) {
+    try {
+      const watcher = fs4.watch(dirPath, { recursive: true });
+      (async () => {
+        for await (const _event of watcher) {
+          if (timeoutId) {
+            clearTimeout(timeoutId);
+          }
+          timeoutId = setTimeout(async () => {
+            console.log(chalk.yellow(`Changes detected in router files. Regenerating types...`));
+            try {
+              await generateRouterTypes(outputPath);
+              console.log(chalk.green(`\u2728 Router types regenerated at ${outputPath}`));
+            } catch (error) {
+              console.error(chalk.red(`Error regenerating types: ${error.message}`));
+            }
+            timeoutId = null;
+          }, 500);
+        }
+      })();
+    } catch {}
+  }
+}
+
+// src/cli/routes.ts
+import fs5 from "fs/promises";
+import path4 from "path";
+import process13 from "process";
+async function displayRoutes(options) {
+  try {
+    const routesFile = `${process13.cwd()}/routes/index.ts`;
+    const { router } = await import(routesFile);
+    if (!router) {
+      console.error(chalk.red(`Could not find router instance in ${routesFile}.`));
+      process13.exit(1);
+    }
+    const routes = router.routes || [];
+    if (routes.length === 0) {
+      console.log(chalk.yellow("No routes defined."));
+      return;
+    }
+    let filteredRoutes = routes;
+    if (options.path) {
+      filteredRoutes = filteredRoutes.filter((route) => route.path.startsWith(options.path));
+    }
+    console.log(chalk.bold(`
+Routes:`));
+    console.log(chalk.dim("+-----------------+-------------------------+------------------+----------------+"));
+    console.log(chalk.dim("| ") + chalk.bold("Method") + chalk.dim("          | ") + chalk.bold("URI") + chalk.dim("                     | ") + chalk.bold("Name") + chalk.dim("             | ") + chalk.bold("Handler") + chalk.dim("         |"));
+    console.log(chalk.dim("+-----------------+-------------------------+------------------+----------------+"));
+    filteredRoutes.forEach((route) => {
+      const method = padString(route.method, 15);
+      const path5 = padString(route.path, 23);
+      const name = padString(route.name || "", 16);
+      let handler;
+      if (typeof route.handler === "string") {
+        handler = route.handler;
+      } else if (typeof route.handler === "function") {
+        handler = route.handler.name ? `${route.handler.name}()` : "Anonymous Function";
+      } else {
+        handler = "Class Handler";
+      }
+      handler = padString(handler, 14);
+      console.log(chalk.dim("| ") + getMethodColor(route.method)(method) + chalk.dim(" | ") + chalk.green(path5) + chalk.dim(" | ") + chalk.yellow(name) + chalk.dim(" | ") + chalk.blue(handler) + chalk.dim(" |"));
+      if (options.verbose && route.middleware && route.middleware.length > 0) {
+        console.log(chalk.dim("|                 | ") + chalk.dim("Middleware: ") + route.middleware.map((m) => typeof m === "string" ? m : m.name || "Anonymous").join(", ") + chalk.dim("                                           |"));
+      }
+    });
+    console.log(chalk.dim("+-----------------+-------------------------+------------------+----------------+"));
+    console.log(`
+Showing ${filteredRoutes.length} routes`);
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error.message}`));
+    console.error(chalk.yellow(`Make sure your routes are defined in ${process13.cwd()}/routes/index.ts and export a 'router' instance.`));
+    throw error;
+  }
+}
+async function generateRouteTypes(outputPath) {
+  try {
+    const routesFile = `${process13.cwd()}/routes/index.ts`;
+    const { router } = await import(routesFile);
+    if (!router) {
+      console.error(chalk.red(`Could not find router instance in ${routesFile}.`));
+      process13.exit(1);
+    }
+    const routes = router.routes || [];
+    if (routes.length === 0) {
+      console.log(chalk.yellow("No routes defined. Creating empty types file."));
+    }
+    const routeNames = routes.map((route) => {
+      if (route.name)
+        return route.name;
+      const methodLower = route.method.toLowerCase();
+      const pathFormatted = route.path.replace(/^\//, "").replace(/\//g, ".").replace(/\{([^}]+)\}/g, ":$1");
+      return pathFormatted ? `${methodLower}.${pathFormatted}` : methodLower;
+    });
+    const uniqueRouteNames = [...new Set(routeNames)];
+    const typeContent = `/**
+ * This file is auto-generated.
+ * DO NOT EDIT THIS FILE DIRECTLY.
+ * To update, run 'bun router route:types'
+ */
+
+/**
+ * String literal type for all available route names
+ */
+export type RouteName = ${uniqueRouteNames.length > 0 ? uniqueRouteNames.map((name) => `'${name}'`).join(" | ") : "string"}
+
+/**
+ * Object type with route names as keys and string (for path generation) as values
+ */
+export interface RouteNameMap {
+${uniqueRouteNames.map((name) => `  '${name}': string`).join(`
+`)}
+}
+
+/**
+ * Type-safe function to generate a URL for a named route
+ */
+export type RouteFunction = <T extends RouteName>(name: T, params?: Record<string, string>) => string
+
+/**
+ * Validate that a string is a valid route name
+ */
+export function isValidRouteName(name: string): name is RouteName {
+  return [${uniqueRouteNames.map((name) => `'${name}'`).join(", ")}].includes(name)
+}
+`;
+    await fs5.writeFile(outputPath, typeContent);
+    console.log(chalk.green(`\u2728 Route types generated at ${outputPath}`));
+  } catch (error) {
+    if (error.code === "ERR_MODULE_NOT_FOUND") {
+      console.error(chalk.red(`Routes file not found at ${process13.cwd()}/routes/index.ts`));
+      console.error(chalk.yellow('Make sure your routes are defined and exported as "router" in routes/index.ts'));
+    } else {
+      console.error(chalk.red(`Error generating route types: ${error.message}`));
+    }
+    throw error;
+  }
+}
+async function watchRoutesDirectory(outputPath) {
+  const routesPath = path4.join(process13.cwd(), "routes");
+  try {
+    await fs5.access(routesPath);
+  } catch {
+    console.error(chalk.red(`Routes directory not found at ${routesPath}`));
+    process13.exit(1);
+  }
+  await generateRouteTypes(outputPath);
+  console.log(chalk.green(`\u2728 Route types generated at ${outputPath}`));
+  console.log(chalk.blue(`Watching for changes in ${routesPath}...`));
+  let timeoutId = null;
+  const watcher = fs5.watch(routesPath, { recursive: true });
+  for await (const _event of watcher) {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(async () => {
+      console.log(chalk.yellow(`Changes detected in routes directory. Regenerating types...`));
+      try {
+        await generateRouteTypes(outputPath);
+        console.log(chalk.green(`\u2728 Route types regenerated at ${outputPath}`));
+      } catch (error) {
+        console.error(chalk.red(`Error regenerating types: ${error.message}`));
+      }
+      timeoutId = null;
+    }, 500);
+  }
+}
+function padString(str, length) {
+  return (str + " ".repeat(length)).substring(0, length);
+}
+function getMethodColor(method) {
+  switch (method.toUpperCase()) {
+    case "GET":
+      return chalk.cyan;
+    case "POST":
+      return chalk.green;
+    case "PUT":
+      return chalk.yellow;
+    case "PATCH":
+      return chalk.yellow;
+    case "DELETE":
+      return chalk.red;
+    case "OPTIONS":
+      return chalk.gray;
+    default:
+      return chalk.white;
+  }
+}
+
+// src/cli/utils.ts
+import process14 from "process";
+var format = {
+  success: (message) => chalk.green(`\u2728 ${message}`),
+  info: (message) => chalk.blue(message),
+  warning: (message) => chalk.yellow(message),
+  error: (message) => chalk.red(message),
+  dim: (message) => chalk.dim(message),
+  bold: (message) => chalk.bold(message)
+};
+var logger = {
+  success: (message) => console.log(format.success(message)),
+  info: (message) => console.log(format.info(message)),
+  warning: (message) => console.log(format.warning(message)),
+  error: (message) => console.error(format.error(message)),
+  debug: (message) => console.debug(format.dim(message))
+};
+async function loadRouter() {
+  try {
+    const routesFile = `${process14.cwd()}/routes/index.ts`;
+    const { router } = await import(routesFile);
+    if (!router) {
+      logger.error(`Could not find router instance in ${routesFile}.`);
+      process14.exit(1);
+    }
+    return router;
+  } catch (error) {
+    if (error.code === "ERR_MODULE_NOT_FOUND") {
+      logger.error(`Routes file not found at ${process14.cwd()}/routes/index.ts`);
+      logger.warning('Make sure your routes are defined and exported as "router" in routes/index.ts');
+    } else {
+      logger.error(`Error loading router: ${error.message}`);
+    }
+    throw error;
+  }
+}
+function getMethodColor2(method) {
+  switch (method.toUpperCase()) {
+    case "GET":
+      return chalk.cyan.toString();
+    case "POST":
+      return chalk.green.toString();
+    case "PUT":
+      return chalk.yellow.toString();
+    case "PATCH":
+      return chalk.yellow.toString();
+    case "DELETE":
+      return chalk.red.toString();
+    case "OPTIONS":
+      return chalk.gray.toString();
+    default:
+      return chalk.white.toString();
+  }
+}
+async function checkRouterHealth(options) {
+  logger.info("\uD83D\uDD0D Checking router health...");
+  try {
+    const router = await loadRouter();
+    const routes = router.routes || [];
+    const globalMiddleware = router.globalMiddleware || [];
+    const namedRoutes = router.namedRoutes || new Map;
+    const health = {
+      totalRoutes: routes.length,
+      namedRoutes: namedRoutes.size,
+      globalMiddleware: globalMiddleware.length,
+      routesByMethod: {},
+      duplicateRoutes: [],
+      routesWithMiddleware: 0,
+      staticRoutes: 0,
+      dynamicRoutes: 0
+    };
+    const routeMap = new Map;
+    for (const route of routes) {
+      const key = `${route.method}:${route.path}`;
+      health.routesByMethod[route.method] = (health.routesByMethod[route.method] || 0) + 1;
+      if (!routeMap.has(key)) {
+        routeMap.set(key, []);
+      }
+      routeMap.get(key).push(route.path);
+      if (routeMap.get(key).length > 1) {
+        health.duplicateRoutes.push({ path: route.path, method: route.method });
+      }
+      if (route.middleware && route.middleware.length > 0) {
+        health.routesWithMiddleware++;
+      }
+      if (route.path.includes("{") || route.path.includes("*")) {
+        health.dynamicRoutes++;
+      } else {
+        health.staticRoutes++;
+      }
+    }
+    logger.success(`Router health check completed`);
+    console.log(`\uD83D\uDCCA Routes: ${health.totalRoutes} total (${health.staticRoutes} static, ${health.dynamicRoutes} dynamic)`);
+    console.log(`\uD83D\uDCDB Named routes: ${health.namedRoutes}`);
+    console.log(`\uD83D\uDEE1\uFE0F  Global middleware: ${health.globalMiddleware}`);
+    console.log(`\uD83D\uDD27 Routes with middleware: ${health.routesWithMiddleware}`);
+    if (options.verbose) {
+      console.log(`
+\uD83D\uDCC8 Routes by method:`);
+      for (const [method, count] of Object.entries(health.routesByMethod)) {
+        const color = getMethodColor2(method);
+        console.log(`  ${chalk.hex(color)(method.padEnd(8))}: ${count}`);
+      }
+      if (health.duplicateRoutes.length > 0) {
+        logger.warning(`
+\u26A0\uFE0F  Found ${health.duplicateRoutes.length} duplicate route(s):`);
+        for (const duplicate of health.duplicateRoutes) {
+          console.log(`  ${duplicate.method} ${duplicate.path}`);
+        }
+      }
+      const issues = [];
+      if (health.totalRoutes === 0) {
+        issues.push("No routes defined");
+      }
+      if (health.duplicateRoutes.length > 0) {
+        issues.push(`${health.duplicateRoutes.length} duplicate routes`);
+      }
+      if (health.routesWithMiddleware === 0 && health.globalMiddleware === 0) {
+        issues.push("No middleware configured");
+      }
+      if (issues.length > 0) {
+        logger.warning(`
+\u26A0\uFE0F  Potential issues:`);
+        for (const issue of issues) {
+          console.log(`  \u2022 ${issue}`);
+        }
+      } else {
+        logger.success(`
+\u2705 No issues detected`);
+      }
+    }
+  } catch (error) {
+    logger.error(`Health check failed: ${error.message}`);
+    throw error;
+  }
+}
+async function testRoutes(options) {
+  const baseUrl = options.baseUrl || "http://localhost:3000";
+  const timeout = options.timeout || 5000;
+  const allowedMethods = options.method ? options.method.split(",").map((m) => m.trim().toUpperCase()) : null;
+  logger.info(`\uD83E\uDDEA Testing routes at ${baseUrl}...`);
+  try {
+    const router = await loadRouter();
+    const routes = router.routes || [];
+    let filteredRoutes = routes;
+    if (options.filter) {
+      const pattern = new RegExp(options.filter.replace(/\*/g, ".*"));
+      filteredRoutes = routes.filter((route) => pattern.test(route.path));
+    }
+    if (allowedMethods) {
+      filteredRoutes = filteredRoutes.filter((route) => allowedMethods.includes(route.method));
+    }
+    if (filteredRoutes.length === 0) {
+      logger.warning("No routes match the specified filters");
+      return;
+    }
+    logger.info(`Testing ${filteredRoutes.length} routes...`);
+    const results = {
+      total: 0,
+      passed: 0,
+      failed: 0,
+      errors: []
+    };
+    for (const route of filteredRoutes) {
+      results.total++;
+      if (route.path.includes("{")) {
+        logger.debug(`Skipping parameterized route: ${route.method} ${route.path}`);
+        continue;
+      }
+      try {
+        const url = `${baseUrl}${route.path}`;
+        const response = await fetch(url, {
+          method: route.method,
+          signal: AbortSignal.timeout(timeout)
+        });
+        if (response.status < 500) {
+          results.passed++;
+          logger.debug(`\u2705 ${route.method} ${route.path} \u2192 ${response.status}`);
+        } else {
+          results.failed++;
+          results.errors.push({
+            route: `${route.method} ${route.path}`,
+            error: `HTTP ${response.status}`
+          });
+        }
+      } catch (error) {
+        results.failed++;
+        results.errors.push({
+          route: `${route.method} ${route.path}`,
+          error: error.message
+        });
+      }
+    }
+    console.log(`
+\uD83D\uDCCA Test Results:`);
+    console.log(`  Total: ${results.total}`);
+    console.log(`  Passed: ${chalk.green(String(results.passed))}`);
+    console.log(`  Failed: ${chalk.red(String(results.failed))}`);
+    if (results.errors.length > 0) {
+      console.log(`
+\u274C Failures:`);
+      for (const error of results.errors) {
+        console.log(`  ${error.route}: ${error.error}`);
+      }
+    }
+    if (results.failed > 0) {
+      process14.exit(1);
+    } else {
+      logger.success("All tests passed!");
+    }
+  } catch (error) {
+    logger.error(`Route testing failed: ${error.message}`);
+    throw error;
+  }
+}
+async function debugRoute(path5, options) {
+  const method = options.method?.toUpperCase() || "GET";
+  logger.info(`\uD83D\uDD0D Debugging route matching for: ${method} ${path5}`);
+  try {
+    const router = await loadRouter();
+    const match = router.matchRoute ? router.matchRoute(path5, method) : null;
+    if (match) {
+      logger.success(`\u2705 Route matched!`);
+      console.log(`  Route: ${match.route.method} ${match.route.path}`);
+      console.log(`  Handler: ${typeof match.route.handler}`);
+      if (Object.keys(match.params || {}).length > 0) {
+        console.log(`  Parameters:`);
+        for (const [key, value] of Object.entries(match.params)) {
+          console.log(`    ${key}: ${value}`);
+        }
+      }
+      if (match.route.middleware && match.route.middleware.length > 0) {
+        console.log(`  Middleware: ${match.route.middleware.length} handler(s)`);
+      }
+      if (match.route.name) {
+        console.log(`  Named route: ${match.route.name}`);
+      }
+    } else {
+      logger.error(`\u274C No route matched for ${method} ${path5}`);
+      if (options.verbose) {
+        console.log(`
+\uD83D\uDCCB Available routes:`);
+        const routes = router.routes || [];
+        const methodRoutes = routes.filter((r) => r.method === method);
+        if (methodRoutes.length === 0) {
+          console.log(`  No routes defined for ${method} method`);
+        } else {
+          for (const route of methodRoutes) {
+            console.log(`  ${route.method} ${route.path}`);
+          }
+        }
+      }
+    }
+  } catch (error) {
+    logger.error(`Route debugging failed: ${error.message}`);
+    throw error;
+  }
+}
+async function clearCaches(options) {
+  logger.info("\uD83D\uDDD1\uFE0F  Clearing route caches...");
+  try {
+    const router = await loadRouter();
+    if (options.stats) {
+      if (router.getCacheStats) {
+        const stats = router.getCacheStats();
+        console.log("\uD83D\uDCCA Cache statistics before clearing:");
+        console.log(`  Hit rate: ${stats.hitRate}%`);
+        console.log(`  Total hits: ${stats.hits}`);
+        console.log(`  Total misses: ${stats.misses}`);
+        console.log(`  Cache size: ${stats.size}`);
+      }
+      if (router.routeCache) {
+        console.log(`  Route cache entries: ${router.routeCache.size}`);
+      }
+      if (router.templateCache) {
+        console.log(`  Template cache entries: ${router.templateCache.size}`);
+      }
+    }
+    if (router.clearRouteCache) {
+      router.clearRouteCache();
+    }
+    if (router.routeCache && router.routeCache.clear) {
+      router.routeCache.clear();
+    }
+    if (router.templateCache && router.templateCache.clear) {
+      router.templateCache.clear();
+    }
+    if (router.clearModelCache) {
+      router.clearModelCache();
+    }
+    logger.success("\u2705 Caches cleared successfully");
+  } catch (error) {
+    logger.error(`Cache clearing failed: ${error.message}`);
+    throw error;
+  }
+}
+async function validateRoutes(options) {
+  logger.info("\uD83D\uDD0D Validating route definitions...");
+  try {
+    const router = await loadRouter();
+    const routes = router.routes || [];
+    const issues = [];
+    const warnings = [];
+    for (const route of routes) {
+      if (!route.method) {
+        issues.push(`Route missing method: ${route.path}`);
+      }
+      if (!route.path) {
+        issues.push(`Route missing path: ${route.method || "UNKNOWN"}`);
+      }
+      if (!route.handler) {
+        issues.push(`Route missing handler: ${route.method} ${route.path}`);
+      }
+      if (route.path && !route.path.startsWith("/")) {
+        issues.push(`Route path should start with '/': ${route.method} ${route.path}`);
+      }
+      if (route.path && route.path.includes("{")) {
+        const params = route.path.match(/\{[^}]+\}/g) || [];
+        for (const param of params) {
+          if (!param.match(/^\{[a-z_]\w*(\?|:[^}]+)?\}$/i)) {
+            issues.push(`Invalid parameter syntax in ${route.method} ${route.path}: ${param}`);
+          }
+        }
+      }
+      if (options.strict) {
+        if (!route.name && !route.path.includes("{") && route.path !== "/") {
+          warnings.push(`Consider adding a name to route: ${route.method} ${route.path}`);
+        }
+        if (route.path.includes("/admin") && (!route.middleware || route.middleware.length === 0)) {
+          warnings.push(`Admin route missing middleware: ${route.method} ${route.path}`);
+        }
+      }
+    }
+    const routeMap = new Map;
+    for (const route of routes) {
+      const key = `${route.method}:${route.path}`;
+      routeMap.set(key, (routeMap.get(key) || 0) + 1);
+    }
+    for (const [key, count] of routeMap.entries()) {
+      if (count > 1) {
+        issues.push(`Duplicate route detected: ${key} (${count} times)`);
+      }
+    }
+    if (issues.length === 0 && warnings.length === 0) {
+      logger.success("\u2705 All route definitions are valid");
+      return;
+    }
+    if (issues.length > 0) {
+      logger.error(`\u274C Found ${issues.length} validation error(s):`);
+      for (const issue of issues) {
+        console.log(`  \u2022 ${issue}`);
+      }
+    }
+    if (warnings.length > 0) {
+      logger.warning(`\u26A0\uFE0F  Found ${warnings.length} warning(s):`);
+      for (const warning of warnings) {
+        console.log(`  \u2022 ${warning}`);
+      }
+    }
+    if (options.fix) {
+      logger.info("\uD83D\uDD27 Auto-fixing is not yet implemented");
+    }
+    if (issues.length > 0) {
+      process14.exit(1);
+    }
+  } catch (error) {
+    logger.error(`Route validation failed: ${error.message}`);
+    throw error;
+  }
+}
+
+// src/cli/index.ts
+function createCLI() {
+  const cli = new CLI("router");
+  cli.version(version);
+  registerRouteCommands(cli);
+  registerMiddlewareCommands(cli);
+  registerRouterCommands(cli);
+  registerOpenAPICommands(cli);
+  registerUtilityCommands(cli);
+  cli.help();
+  return cli;
+}
+function registerRouteCommands(cli) {
+  cli.command("route:list", "List all registered routes").option("-v, --verbose", "Show detailed information including middleware").option("-vv, --extra-verbose", "Show very detailed information").option("--path <path>", "Filter routes by path prefix").option("--except-vendor", "Exclude vendor routes").option("--only-vendor", "Show only vendor routes").example("router route:list").example("router route:list -v").example("router route:list --path=/api").action(async (options) => {
+    try {
+      await displayRoutes(options);
+    } catch (error) {
+      console.error(`Failed to list routes: ${error.message}`);
+      process15.exit(1);
+    }
+  });
+  cli.command("route:types", "Generate TypeScript types for route names").option("--output <file>", "Output file path", { default: "route-types.ts" }).option("--watch", "Watch for changes in routes directory").example("router route:types").example("router route:types --output src/types/routes.ts").example("router route:types --watch").action(async (options) => {
+    try {
+      const outputPath = options.output || "route-types.ts";
+      if (options.watch) {
+        await watchRoutesDirectory(outputPath);
+      } else {
+        await generateRouteTypes(outputPath);
+      }
+    } catch (error) {
+      console.error(`Failed to generate route types: ${error.message}`);
+      process15.exit(1);
+    }
+  });
+}
+function registerMiddlewareCommands(cli) {
+  cli.command("middleware:types", "Generate TypeScript types for middleware configurations").option("--output <file>", "Output file path", { default: "middleware-types.ts" }).option("--watch", "Watch for changes in middleware directory").example("router middleware:types").example("router middleware:types --output src/types/middleware.ts").example("router middleware:types --watch").action(async (options) => {
+    try {
+      const outputPath = options.output || "middleware-types.ts";
+      if (options.watch) {
+        await watchMiddlewareDirectory(outputPath);
+      } else {
+        await generateMiddlewareTypes(outputPath);
+      }
+    } catch (error) {
+      console.error(`Failed to generate middleware types: ${error.message}`);
+      process15.exit(1);
+    }
+  });
+  cli.command("middleware:map", "Generate TypeScript types for all middleware in the project").option("--dir <directory>", "Directory to scan for middleware classes", { default: "src" }).option("--output <file>", "Output file path", { default: "middleware-map.ts" }).option("--watch", "Watch for changes in the specified directory").example("router middleware:map").example("router middleware:map --dir app").example("router middleware:map --output src/types/project-middleware.ts").example("router middleware:map --watch").action(async (options) => {
+    try {
+      const outputPath = options.output || "middleware-map.ts";
+      const directoryPath = options.dir || "src";
+      if (options.watch) {
+        await watchDirectoryForMiddleware(directoryPath, outputPath);
+      } else {
+        await generateMiddlewareMap(directoryPath, outputPath);
+      }
+    } catch (error) {
+      console.error(`Failed to generate middleware map: ${error.message}`);
+      process15.exit(1);
+    }
+  });
+}
+function registerRouterCommands(cli) {
+  cli.command("router:types", "Generate TypeScript types for router extensions").option("--output <file>", "Output file path", { default: "router-types.ts" }).option("--watch", "Watch for changes in router files").example("router router:types").example("router router:types --output src/types/router.ts").example("router router:types --watch").action(async (options) => {
+    try {
+      const outputPath = options.output || "router-types.ts";
+      if (options.watch) {
+        await watchRouterFiles(outputPath);
+      } else {
+        await generateRouterTypes(outputPath);
+      }
+    } catch (error) {
+      console.error(`Failed to generate router types: ${error.message}`);
+      process15.exit(1);
+    }
+  });
+}
+function registerOpenAPICommands(cli) {
+  cli.command("openapi", "Generate OpenAPI specification for API routes").option("--output <file>", "Output file path", { default: "openapi.json" }).option("--title <title>", "API title", { default: "API Documentation" }).option("--version <version>", "API version", { default: "1.0.0" }).option("--description <description>", "API description").option("--base-path <path>", "Base API path", { default: "/" }).option("--servers <urls>", "Comma-separated list of server URLs").option("--tags", "Group endpoints by tags", { default: true }).option("--security", "Include security schemes if available", { default: true }).example("router openapi").example("router openapi --output api-spec.json").example('router openapi --title "My API" --version 2.0').example("router openapi --servers http://localhost:3000,https://api.example.com").action(async (options) => {
+    try {
+      await generateOpenAPISpec(options);
+    } catch (error) {
+      console.error(`Failed to generate OpenAPI specification: ${error.message}`);
+      process15.exit(1);
+    }
+  });
+}
+function registerUtilityCommands(cli) {
+  cli.command("health", "Check router health and configuration").option("--verbose", "Show detailed health information").example("router health").example("router health --verbose").action(async (options) => {
+    try {
+      await checkRouterHealth(options);
+    } catch (error) {
+      console.error(`Health check failed: ${error.message}`);
+      process15.exit(1);
+    }
+  });
+  cli.command("test:routes", "Test routes by making HTTP requests").option("--base-url <url>", "Base URL for testing", { default: "http://localhost:3000" }).option("--filter <pattern>", "Filter routes by path pattern").option("--method <methods>", "Test only specific HTTP methods (comma-separated)").option("--timeout <ms>", "Request timeout in milliseconds", { default: 5000 }).example("router test:routes").example("router test:routes --base-url http://localhost:8080").example('router test:routes --filter "/api/*"').example("router test:routes --method GET,POST").action(async (options) => {
+    try {
+      await testRoutes(options);
+    } catch (error) {
+      console.error(`Route testing failed: ${error.message}`);
+      process15.exit(1);
+    }
+  });
+  cli.command("debug:route <path>", "Debug route matching for a specific path").option("--method <method>", "HTTP method to test", { default: "GET" }).option("--verbose", "Show detailed matching information").example("router debug:route /api/users/123").example("router debug:route /api/users/123 --method POST --verbose").action(async (path5, options) => {
+    try {
+      await debugRoute(path5, options);
+    } catch (error) {
+      console.error(`Route debugging failed: ${error.message}`);
+      process15.exit(1);
+    }
+  });
+  cli.command("cache:clear", "Clear route caches").option("--stats", "Show cache statistics before clearing").example("router cache:clear").example("router cache:clear --stats").action(async (options) => {
+    try {
+      await clearCaches(options);
+    } catch (error) {
+      console.error(`Cache clearing failed: ${error.message}`);
+      process15.exit(1);
+    }
+  });
+  cli.command("validate", "Validate route definitions and configuration").option("--strict", "Use strict validation rules").option("--fix", "Automatically fix simple issues").example("router validate").example("router validate --strict --fix").action(async (options) => {
+    try {
+      await validateRoutes(options);
+    } catch (error) {
+      console.error(`Route validation failed: ${error.message}`);
+      process15.exit(1);
+    }
+  });
+}
+
+// src/cli.ts
+var cli = createCLI();
+cli.parse();